From 79430bf10b553f62f13e50a36c67cf9cef915ac0 Mon Sep 17 00:00:00 2001
From: Vitaliy Lyudvichenko <vludv@yandex-team.ru>
Date: Thu, 16 Nov 2017 22:03:32 +0300
Subject: [PATCH 001/107] Fixed SummingMergeTree. [#CLICKHOUSE-2]

---
 .../SummingSortedBlockInputStream.cpp         | 95 +++++++++++--------
 .../SummingSortedBlockInputStream.h           | 18 ++--
 .../00084_summing_merge_tree.reference        |  2 +
 .../0_stateless/00084_summing_merge_tree.sql  | 10 ++
 4 files changed, 75 insertions(+), 50 deletions(-)

diff --git a/dbms/src/DataStreams/SummingSortedBlockInputStream.cpp b/dbms/src/DataStreams/SummingSortedBlockInputStream.cpp
index 7d0f94e997e..bc5c5dfc7dc 100644
--- a/dbms/src/DataStreams/SummingSortedBlockInputStream.cpp
+++ b/dbms/src/DataStreams/SummingSortedBlockInputStream.cpp
@@ -36,7 +36,7 @@ String SummingSortedBlockInputStream::getID() const
 }
 
 
-void SummingSortedBlockInputStream::insertCurrentRow(ColumnPlainPtrs & merged_columns)
+void SummingSortedBlockInputStream::insertCurrentRowIfNeeded(ColumnPlainPtrs & merged_columns, bool force_insertion)
 {
     for (auto & desc : columns_to_aggregate)
     {
@@ -46,6 +46,19 @@ void SummingSortedBlockInputStream::insertCurrentRow(ColumnPlainPtrs & merged_co
             try
             {
                 desc.function->insertResultInto(desc.state.data(), *desc.merged_column);
+
+                /// Update zero status of current row
+                if (desc.column_numbers.size() == 1)
+                {
+                    // Flag row as non-empty if at least one column number if non-zero
+                    current_row_is_zero = current_row_is_zero && desc.merged_column->get64(desc.merged_column->size() - 1) == 0;
+                }
+                else
+                {
+                    /// It is sumMap aggregate function.
+                    /// Assume that the row isn't empty in this case (just because it is compatible with previous version)
+                    current_row_is_zero = false;
+                }
             }
             catch (...)
             {
@@ -60,8 +73,22 @@ void SummingSortedBlockInputStream::insertCurrentRow(ColumnPlainPtrs & merged_co
             desc.merged_column->insertDefault();
     }
 
+    /// If it is "zero" row and it is not the last row of the result block, then
+    ///  rollback the insertion (at this moment we need rollback only cols from columns_to_aggregate)
+    if (!force_insertion && current_row_is_zero)
+    {
+        for (auto & desc : columns_to_aggregate)
+            desc.merged_column->popBack(1);
+
+        return;
+    }
+
     for (auto i : column_numbers_not_to_aggregate)
         merged_columns[i]->insert(current_row[i]);
+
+    /// Update per-block and per-group flags
+    ++merged_rows;
+    output_is_non_empty = true;
 }
 
 
@@ -155,6 +182,7 @@ Block SummingSortedBlockInputStream::readImpl()
                     desc.column_numbers = {i};
                     desc.function = factory.get("sumWithOverflow", {column.type});
                     desc.function->setArguments({column.type});
+                    desc.add_function = desc.function->getAddressOfAddFunction();
                     desc.state.resize(desc.function->sizeOfData());
                     columns_to_aggregate.emplace_back(std::move(desc));
                 }
@@ -237,6 +265,7 @@ Block SummingSortedBlockInputStream::readImpl()
                 // Create summation for all value columns in the map
                 desc.function = factory.get("sumMap", argument_types);
                 desc.function->setArguments(argument_types);
+                desc.add_function = desc.function->getAddressOfAddFunction();
                 desc.state.resize(desc.function->sizeOfData());
                 columns_to_aggregate.emplace_back(std::move(desc));
             }
@@ -279,7 +308,7 @@ Block SummingSortedBlockInputStream::readImpl()
 template <typename TSortCursor>
 void SummingSortedBlockInputStream::merge(ColumnPlainPtrs & merged_columns, std::priority_queue<TSortCursor> & queue)
 {
-    size_t merged_rows = 0;
+    merged_rows = 0;
 
     /// Take the rows in needed order and put them in `merged_block` until rows no more than `max_block_size`
     while (!queue.empty())
@@ -308,12 +337,7 @@ void SummingSortedBlockInputStream::merge(ColumnPlainPtrs & merged_columns, std:
         if (key_differs)
         {
             /// Write the data for the previous group.
-            if (!current_row_is_zero)
-            {
-                ++merged_rows;
-                output_is_non_empty = true;
-                insertCurrentRow(merged_columns);
-            }
+            insertCurrentRowIfNeeded(merged_columns, false);
 
             current_key.swap(next_key);
 
@@ -327,11 +351,12 @@ void SummingSortedBlockInputStream::merge(ColumnPlainPtrs & merged_columns, std:
             }
 
             // Start aggregations with current row
-            current_row_is_zero = !addRow(current_row, current);
+            addRow(current_row, current);
+            current_row_is_zero = true;
         }
         else
         {
-            current_row_is_zero = !addRow(current_row, current);
+            addRow(current_row, current);
 
             // Merge maps only for same rows
             for (auto & desc : maps_to_sum)
@@ -355,12 +380,7 @@ void SummingSortedBlockInputStream::merge(ColumnPlainPtrs & merged_columns, std:
 
     /// We will write the data for the last group, if it is non-zero.
     /// 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;  /// Dead store (result is unused). Left for clarity.
-        insertCurrentRow(merged_columns);
-    }
-
+    insertCurrentRowIfNeeded(merged_columns, !output_is_non_empty);
     finished = true;
 }
 
@@ -449,38 +469,29 @@ bool SummingSortedBlockInputStream::mergeMap(const MapDescription & desc, Row &
 
 
 template <typename TSortCursor>
-bool SummingSortedBlockInputStream::addRow(Row & row, TSortCursor & cursor)
+void SummingSortedBlockInputStream::addRow(Row & row, TSortCursor & cursor)
 {
-    bool res = false;
     for (auto & desc : columns_to_aggregate)
     {
-        if (desc.created)
-        {
-            // Specialized case for unary functions
-            if (desc.column_numbers.size() == 1)
-            {
-                auto & col = cursor->all_columns[desc.column_numbers[0]];
-                desc.function->add(desc.state.data(), &col, cursor->pos, nullptr);
-                // Flag row as non-empty if at least one column number if non-zero
-                // Note: This defers compaction of signed type rows that sum to zero by one merge
-                if (!res)
-                    res = col->get64(cursor->pos) != 0;
-            }
-            else
-            {
-                // Gather all source columns into a vector
-                ConstColumnPlainPtrs columns(desc.column_numbers.size());
-                for (size_t i = 0; i < desc.column_numbers.size(); ++i)
-                    columns[i] = cursor->all_columns[desc.column_numbers[i]];
+        if (!desc.created)
+            throw Exception("Logical error in SummingSortedBlockInputStream, there are no description", ErrorCodes::LOGICAL_ERROR);
 
-                desc.function->add(desc.state.data(), columns.data(), cursor->pos, nullptr);
-                // Note: we can't detect whether the aggregation result is non-empty here yet
-                res = true;
-            }
+        // Specialized case for unary functions
+        if (desc.column_numbers.size() == 1)
+        {
+            auto & col = cursor->all_columns[desc.column_numbers[0]];
+            desc.add_function(desc.function.get(), desc.state.data(), &col, cursor->pos, nullptr);
+        }
+        else
+        {
+            // Gather all source columns into a vector
+            ConstColumnPlainPtrs columns(desc.column_numbers.size());
+            for (size_t i = 0; i < desc.column_numbers.size(); ++i)
+                columns[i] = cursor->all_columns[desc.column_numbers[i]];
+
+            desc.add_function(desc.function.get(),desc.state.data(), columns.data(), cursor->pos, nullptr);
         }
     }
-
-    return res;
 }
 
 }
diff --git a/dbms/src/DataStreams/SummingSortedBlockInputStream.h b/dbms/src/DataStreams/SummingSortedBlockInputStream.h
index f21d79d01a6..493e32d5326 100644
--- a/dbms/src/DataStreams/SummingSortedBlockInputStream.h
+++ b/dbms/src/DataStreams/SummingSortedBlockInputStream.h
@@ -73,6 +73,7 @@ private:
     struct AggregateDescription
     {
         AggregateFunctionPtr function;
+        IAggregateFunction::AddFunc add_function = nullptr;
         std::vector<size_t> column_numbers;
         ColumnPtr merged_column;
         std::vector<char> state;
@@ -100,9 +101,10 @@ private:
     RowRef next_key;           /// The primary key of the next row.
 
     Row current_row;
-    bool current_row_is_zero = true;    /// The current row is summed to zero, and it should be deleted.
+    bool current_row_is_zero = true;    /// Are all summed columns zero (or empty)? It is updated incrementally.
 
-    bool output_is_non_empty = false;    /// Have we given out at least one row as a result.
+    bool output_is_non_empty = false;   /// Have we given out at least one row as a result.
+    size_t merged_rows = 0;             /// Number of rows merged into current result block
 
     /** We support two different cursors - with Collation and without.
      *  Templates are used instead of polymorphic SortCursor and calls to virtual functions.
@@ -110,17 +112,17 @@ private:
     template <typename TSortCursor>
     void merge(ColumnPlainPtrs & merged_columns, std::priority_queue<TSortCursor> & queue);
 
-    /// Insert the summed row for the current group into the result.
-    void insertCurrentRow(ColumnPlainPtrs & merged_columns);
+    /// Insert the summed row for the current group into the result and updates some of per-block flags if the row is not "zero".
+    /// If force_insertion=true, then the row will be inserted even if it is "zero"
+    void insertCurrentRowIfNeeded(ColumnPlainPtrs & merged_columns, bool force_insertion);
 
+    /// Returns true is merge result is not empty
     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.
-      */
+    // Add the row under the cursor to the `row`.
     template <typename TSortCursor>
-    bool addRow(Row & row, TSortCursor & cursor);
+    void addRow(Row & row, TSortCursor & cursor);
 };
 
 }
diff --git a/dbms/tests/queries/0_stateless/00084_summing_merge_tree.reference b/dbms/tests/queries/0_stateless/00084_summing_merge_tree.reference
index 7142e1ca063..72f24941378 100644
--- a/dbms/tests/queries/0_stateless/00084_summing_merge_tree.reference
+++ b/dbms/tests/queries/0_stateless/00084_summing_merge_tree.reference
@@ -2,3 +2,5 @@
 2000-01-01	Hello	5	7	9
 2000-01-01	Goodbye	1	2	3
 2000-01-01	Hello	1	7	9
+0	2
+666	1
diff --git a/dbms/tests/queries/0_stateless/00084_summing_merge_tree.sql b/dbms/tests/queries/0_stateless/00084_summing_merge_tree.sql
index 82b5117625f..c03092d0277 100644
--- a/dbms/tests/queries/0_stateless/00084_summing_merge_tree.sql
+++ b/dbms/tests/queries/0_stateless/00084_summing_merge_tree.sql
@@ -29,3 +29,13 @@ SELECT * FROM test.summing_merge_tree ORDER BY d, a, x, y, z;
 
 
 DROP TABLE test.summing_merge_tree;
+
+--
+DROP TABLE IF EXISTS test.summing;
+CREATE TABLE test.summing (p Date, k UInt64, s UInt64) ENGINE = SummingMergeTree(p, k, 1);
+
+INSERT INTO test.summing (k, s) VALUES (0, 1);
+INSERT INTO test.summing (k, s) VALUES (0, 1), (666, 1), (666, 0);
+OPTIMIZE TABLE test.summing PARTITION 197001;
+
+SELECT k, s FROM test.summing ORDER BY k;

From 1b50717c7543ce2fef5273491c392ab6ef07195d Mon Sep 17 00:00:00 2001
From: alexey-milovidov <milovidov@yandex-team.ru>
Date: Thu, 16 Nov 2017 23:29:30 +0300
Subject: [PATCH 002/107] Update SummingSortedBlockInputStream.h

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

diff --git a/dbms/src/DataStreams/SummingSortedBlockInputStream.h b/dbms/src/DataStreams/SummingSortedBlockInputStream.h
index 493e32d5326..4e12bf45827 100644
--- a/dbms/src/DataStreams/SummingSortedBlockInputStream.h
+++ b/dbms/src/DataStreams/SummingSortedBlockInputStream.h
@@ -116,7 +116,7 @@ private:
     /// If force_insertion=true, then the row will be inserted even if it is "zero"
     void insertCurrentRowIfNeeded(ColumnPlainPtrs & merged_columns, bool force_insertion);
 
-    /// Returns true is merge result is not empty
+    /// Returns true if merge result is not empty
     template <typename TSortCursor>
     bool mergeMap(const MapDescription & map, Row & row, TSortCursor & cursor);
 

From 40b5fb292e29d38de7beb2af3657632d6ef9d560 Mon Sep 17 00:00:00 2001
From: alexey-milovidov <milovidov@yandex-team.ru>
Date: Thu, 16 Nov 2017 23:37:45 +0300
Subject: [PATCH 003/107] Update SummingSortedBlockInputStream.h

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

diff --git a/dbms/src/DataStreams/SummingSortedBlockInputStream.h b/dbms/src/DataStreams/SummingSortedBlockInputStream.h
index 4e12bf45827..e4207daf88d 100644
--- a/dbms/src/DataStreams/SummingSortedBlockInputStream.h
+++ b/dbms/src/DataStreams/SummingSortedBlockInputStream.h
@@ -45,8 +45,8 @@ private:
     /// Read up to the end.
     bool finished = false;
 
-    /// Columns with which numbers should be summed.
-    Names column_names_to_sum;    /// If set, it is converted to column_numbers_to_sum when initialized.
+    /// Columns with which values should be summed.
+    Names column_names_to_sum;    /// If set, it is converted to column_numbers_to_aggregate when initialized.
     ColumnNumbers column_numbers_not_to_aggregate;
 
     /** A table can have nested tables that are treated in a special way.

From 9229961721a2bcb521617577f02f9aca2422239c Mon Sep 17 00:00:00 2001
From: Vitaliy Lyudvichenko <vludv@yandex-team.ru>
Date: Mon, 20 Nov 2017 22:33:12 +0300
Subject: [PATCH 004/107] Add multi index for data_parts storage. And fixed
 bugs. [#CLICKHOUSE-3452]

Fixed handling of obsolete parts.
Fixed conflict resolution between simultaneous PreCommitted covering parts.
Fixed memory leak caused by ordinary MergeTree parts stucked in Deleting state.
Added hidden _state column into system.parts.
---
 contrib/poco                                  |   2 +-
 dbms/src/Core/ErrorCodes.cpp                  |   1 +
 dbms/src/Storages/MergeTree/MergeTreeData.cpp | 483 +++++++++++-------
 dbms/src/Storages/MergeTree/MergeTreeData.h   | 149 +++++-
 .../MergeTree/MergeTreeDataMerger.cpp         |   2 +-
 .../Storages/MergeTree/MergeTreeDataPart.cpp  |  13 +
 .../Storages/MergeTree/MergeTreeDataPart.h    |  15 +-
 dbms/src/Storages/StorageMergeTree.cpp        |   6 +-
 .../Storages/StorageReplicatedMergeTree.cpp   |  49 +-
 .../Storages/System/StorageSystemParts.cpp    |  40 +-
 dbms/src/Storages/System/StorageSystemParts.h |   4 +
 .../Storages/tests/gtest_range_filtered.cpp   |  44 --
 .../integration/test_random_inserts/test.py   |   5 +-
 .../integration/test_random_inserts/test.sh   |   5 +-
 libs/libcommon/include/common/RangeFiltered.h | 127 -----
 15 files changed, 524 insertions(+), 421 deletions(-)
 delete mode 100644 dbms/src/Storages/tests/gtest_range_filtered.cpp
 delete mode 100644 libs/libcommon/include/common/RangeFiltered.h

diff --git a/contrib/poco b/contrib/poco
index 1366df1c7e0..bcf9ebad48b 160000
--- a/contrib/poco
+++ b/contrib/poco
@@ -1 +1 @@
-Subproject commit 1366df1c7e068bb2efd846bc8dc8e286b090904e
+Subproject commit bcf9ebad48b2162d25f5fc432b176d74a09f498d
diff --git a/dbms/src/Core/ErrorCodes.cpp b/dbms/src/Core/ErrorCodes.cpp
index ffeda42047b..bd4914ea08b 100644
--- a/dbms/src/Core/ErrorCodes.cpp
+++ b/dbms/src/Core/ErrorCodes.cpp
@@ -386,6 +386,7 @@ namespace ErrorCodes
     extern const int HTTP_LENGTH_REQUIRED = 381;
     extern const int CANNOT_LOAD_CATBOOST_MODEL = 382;
     extern const int CANNOT_APPLY_CATBOOST_MODEL = 383;
+    extern const int PART_IS_TEMPORARILY_LOCKED = 384;
 
     extern const int KEEPER_EXCEPTION = 999;
     extern const int POCO_EXCEPTION = 1000;
diff --git a/dbms/src/Storages/MergeTree/MergeTreeData.cpp b/dbms/src/Storages/MergeTree/MergeTreeData.cpp
index 8e7146e4bfa..0a63dc2348b 100644
--- a/dbms/src/Storages/MergeTree/MergeTreeData.cpp
+++ b/dbms/src/Storages/MergeTree/MergeTreeData.cpp
@@ -74,6 +74,7 @@ namespace ErrorCodes
     extern const int CORRUPTED_DATA;
     extern const int INVALID_PARTITION_VALUE;
     extern const int METADATA_MISMATCH;
+    extern const int PART_IS_TEMPORARILY_LOCKED;
 }
 
 
@@ -106,7 +107,9 @@ MergeTreeData::MergeTreeData(
     database_name(database_), table_name(table_),
     full_path(full_path_), columns(columns_),
     broken_part_callback(broken_part_callback_),
-    log_name(log_name_), log(&Logger::get(log_name + " (Data)"))
+    log_name(log_name_), log(&Logger::get(log_name + " (Data)")),
+    data_parts_by_name(data_parts_indexes.get<TagByName>()),
+    data_parts_by_state_and_name(data_parts_indexes.get<TagByStateAndName>())
 {
     merging_params.check(*columns);
 
@@ -381,7 +384,7 @@ Int64 MergeTreeData::getMaxDataPartIndex()
     std::lock_guard<std::mutex> lock_all(data_parts_mutex);
 
     Int64 max_block_id = 0;
-    for (const auto & part : data_parts)
+    for (const DataPartPtr & part : data_parts_by_name)
         max_block_id = std::max(max_block_id, part->info.max_block);
 
     return max_block_id;
@@ -392,9 +395,6 @@ void MergeTreeData::loadDataParts(bool skip_sanity_checks)
 {
     LOG_DEBUG(log, "Loading data parts");
 
-    std::lock_guard<std::mutex> lock(data_parts_mutex);
-    data_parts.clear();
-
     Strings part_file_names;
     Poco::DirectoryIterator end;
     for (Poco::DirectoryIterator it(full_path); it != end; ++it)
@@ -410,6 +410,9 @@ void MergeTreeData::loadDataParts(bool skip_sanity_checks)
     DataPartsVector broken_parts_to_detach;
     size_t suspicious_broken_parts = 0;
 
+    std::lock_guard<std::mutex> lock(data_parts_mutex);
+    data_parts_indexes.clear();
+
     for (const String & file_name : part_file_names)
     {
         MergeTreePartInfo part_info;
@@ -496,7 +499,8 @@ void MergeTreeData::loadDataParts(bool skip_sanity_checks)
         /// Assume that all parts are Committed, covered parts will be detected and marked as Outdated later
         part->state = DataPartState::Committed;
 
-        data_parts.insert(part);
+        if (!data_parts_indexes.insert(part).second)
+            throw Exception("Part " + part->name + " already exists", ErrorCodes::DUPLICATE_DATA_PART);
     }
 
     if (suspicious_broken_parts > settings.max_suspicious_broken_parts && !skip_sanity_checks)
@@ -512,13 +516,21 @@ void MergeTreeData::loadDataParts(bool skip_sanity_checks)
     /// were merged), but that for some reason are still not deleted from the filesystem.
     /// Deletion of files will be performed later in the clearOldParts() method.
 
-    if (data_parts.size() >= 2)
+    if (data_parts_indexes.size() >= 2)
     {
-        auto committed_parts = getDataPartsRange({DataPartState::Committed});
-        auto prev_jt = committed_parts.begin();
+        /// Now all parts are committed, so data_parts_by_state_and_name == committed_parts_range
+        auto prev_jt = data_parts_by_state_and_name.begin();
         auto curr_jt = std::next(prev_jt);
 
-        while (curr_jt != committed_parts.end())
+        auto deactivate_part = [&] (DataPartIteratorByStateAndName it)
+        {
+            (*it)->remove_time = (*it)->modification_time;
+            modifyPartState(it, DataPartState::Outdated);
+        };
+
+        (*prev_jt)->assertState({DataPartState::Committed});
+
+        while (curr_jt != data_parts_by_state_and_name.end() && (*curr_jt)->state == DataPartState::Committed)
         {
             /// Don't consider data parts belonging to different partitions.
             if ((*curr_jt)->info.partition_id != (*prev_jt)->info.partition_id)
@@ -530,16 +542,15 @@ void MergeTreeData::loadDataParts(bool skip_sanity_checks)
 
             if ((*curr_jt)->contains(**prev_jt))
             {
-                (*prev_jt)->remove_time = (*prev_jt)->modification_time;
-                (*prev_jt)->state = DataPartState::Outdated; /// prev_jt becomes invalid here
+                deactivate_part(prev_jt);
                 prev_jt = curr_jt;
                 ++curr_jt;
             }
             else if ((*prev_jt)->contains(**curr_jt))
             {
-                (*curr_jt)->remove_time = (*curr_jt)->modification_time;
-                (*curr_jt)->state = DataPartState::Outdated; /// curr_jt becomes invalid here
-                ++curr_jt;
+                auto next = std::next(curr_jt);
+                deactivate_part(curr_jt);
+                curr_jt = next;
             }
             else
             {
@@ -551,7 +562,7 @@ void MergeTreeData::loadDataParts(bool skip_sanity_checks)
 
     calculateColumnSizesImpl();
 
-    LOG_DEBUG(log, "Loaded data parts (" << data_parts.size() << " items)");
+    LOG_DEBUG(log, "Loaded data parts (" << data_parts_indexes.size() << " items)");
 }
 
 
@@ -619,21 +630,30 @@ MergeTreeData::DataPartsVector MergeTreeData::grabOldParts()
         return res;
 
     time_t now = time(nullptr);
+    std::vector<DataPartIteratorByStateAndName> parts_to_delete;
 
     {
         std::lock_guard<std::mutex> lock_parts(data_parts_mutex);
 
-        for (auto it = data_parts.begin(); it != data_parts.end(); ++it)
+        auto outdated_parts_range = getDataPartsStateRange(DataPartState::Outdated);
+        for (auto it = outdated_parts_range.begin(); it != outdated_parts_range.end(); ++it)
         {
-            if ((*it)->state == DataPartState::Outdated &&
-                it->unique() && /// Grab only parts that is not using by anyone (SELECTs for example)
-                (*it)->remove_time < now &&
-                now - (*it)->remove_time > settings.old_parts_lifetime.totalSeconds())
+            const DataPartPtr & part = *it;
+
+            if (part.unique() && /// Grab only parts that is not using by anyone (SELECTs for example)
+                part->remove_time < now &&
+                now - part->remove_time > settings.old_parts_lifetime.totalSeconds())
             {
-                (*it)->state = DataPartState::Deleting;
-                res.push_back(*it);
+                parts_to_delete.emplace_back(it);
             }
         }
+
+        res.reserve(parts_to_delete.size());
+        for (const auto & it_to_delete : parts_to_delete)
+        {
+            res.emplace_back(*it_to_delete);
+            modifyPartState(it_to_delete, DataPartState::Deleting);
+        }
     }
 
     if (!res.empty())
@@ -650,7 +670,7 @@ void MergeTreeData::rollbackDeletingParts(const MergeTreeData::DataPartsVector &
     {
         /// We should modify it under data_parts_mutex
         part->assertState({DataPartState::Deleting});
-        part->state = DataPartState::Outdated;
+        modifyPartState(part, DataPartState::Outdated);
     }
 }
 
@@ -661,26 +681,27 @@ void MergeTreeData::removePartsFinally(const MergeTreeData::DataPartsVector & pa
     /// TODO: use data_parts iterators instead of pointers
     for (auto & part : parts)
     {
-        if (part->state != DataPartState::Deleting)
-            throw Exception("An attempt to delete part " + part->getNameWithState() + " with unexpected state", ErrorCodes::LOGICAL_ERROR);
-
-        auto it = data_parts.find(part);
-        if (it == data_parts.end())
+        auto it = data_parts_by_name.find(part->info);
+        if (it == data_parts_by_name.end())
             throw Exception("Deleting data part " + part->name + " is not exist", ErrorCodes::LOGICAL_ERROR);
 
-        data_parts.erase(it);
+        (*it)->assertState({DataPartState::Deleting});
+
+        data_parts_indexes.erase(it);
     }
 }
 
-void MergeTreeData::clearOldParts()
+void MergeTreeData::clearOldPartsFromFilesystem()
 {
     auto parts_to_remove = grabOldParts();
 
     for (const DataPartPtr & part : parts_to_remove)
     {
-        LOG_DEBUG(log, "Removing part " << part->name);
+        LOG_DEBUG(log, "Removing part from filesystem " << part->name);
         part->remove();
     }
+
+    removePartsFinally(parts_to_remove);
 }
 
 void MergeTreeData::setPath(const String & new_full_path, bool move_data)
@@ -710,7 +731,7 @@ void MergeTreeData::dropAllData()
 
     LOG_TRACE(log, "dropAllData: removing data from memory.");
 
-    data_parts.clear();
+    data_parts_indexes.clear();
     column_sizes.clear();
 
     context.dropCaches();
@@ -1319,9 +1340,13 @@ MergeTreeData::DataPartsVector MergeTreeData::renameTempPartAndReplace(
 
     part->assertState({DataPartState::Temporary});
 
-    DataPartsVector replaced;
+    MergeTreePartInfo part_info = part->info;
+    String part_name;
+
+    DataPartsVector replaced_parts;
+    std::vector<DataPartIteratorByStateAndName> replaced_iterators;
     {
-        std::lock_guard<std::mutex> lock(data_parts_mutex);
+        std::unique_lock<std::mutex> lock(data_parts_mutex);
 
         if (DataPartPtr existing_part_in_partition = getAnyPartInPartition(part->info.partition_id, lock))
         {
@@ -1336,141 +1361,163 @@ MergeTreeData::DataPartsVector MergeTreeData::renameTempPartAndReplace(
           * Otherwise there is race condition - merge of blocks could happen in interval that doesn't yet contain new part.
           */
         if (increment)
-            part->info.min_block = part->info.max_block = increment->get();
+            part_info.min_block = part_info.max_block = increment->get();
 
-        String new_name;
         if (format_version < MERGE_TREE_DATA_MIN_FORMAT_VERSION_WITH_CUSTOM_PARTITIONING)
-            new_name = part->info.getPartNameV0(part->getMinDate(), part->getMaxDate());
+            part_name = part_info.getPartNameV0(part->getMinDate(), part->getMaxDate());
         else
-            new_name = part->info.getPartName();
+            part_name = part_info.getPartName();
 
-        LOG_TRACE(log, "Renaming temporary part " << part->relative_path << " to " << new_name << ".");
+        LOG_TRACE(log, "Renaming temporary part " << part->relative_path << " to " << part_name << ".");
 
-        auto it_duplicate = data_parts.find(part);
-        if (it_duplicate != data_parts.end())
+        auto it_duplicate = data_parts_by_name.find(part_info);
+        if (it_duplicate != data_parts_by_name.end())
         {
             String message = "Part " + (*it_duplicate)->getNameWithState() + " already exists";
+
             if ((*it_duplicate)->checkState({DataPartState::Outdated, DataPartState::Deleting}))
-                message += ", but it will be deleted soon";
+            {
+                throw Exception(message + ", but it will be deleted soon", ErrorCodes::PART_IS_TEMPORARILY_LOCKED);
+            }
 
             throw Exception(message, ErrorCodes::DUPLICATE_DATA_PART);
         }
 
-        /// Rename the part only in memory. Will rename it on disk only if all check is passed.
-        /// It allows us maintain invariant: if non-temporary parts in filesystem then they are in data_parts
-        part->name = new_name;
+        /// Check that part is not covered and doesn't cover other in-progress parts, it makes sense only for Replicated* engines
+        if (out_transaction)
+        {
+            auto check_coverage = [&part_info, &part_name] (const DataPartPtr & part)
+            {
+                if (part_info.contains(part->info))
+                {
+                    throw Exception("Cannot add part " + part_name + " covering pre-committed part " + part->name, ErrorCodes::PART_IS_TEMPORARILY_LOCKED);
+                }
+                else
+                {
+                    if (part->info.contains(part_info))
+                        throw Exception("Cannot add part " + part_name + " covered by pre-committed part " + part->name + ". It is a bug", ErrorCodes::LOGICAL_ERROR);
+                }
+            };
+
+            auto it_middle = data_parts_by_state_and_name.lower_bound(DataPartStateAndInfo(DataPartState::PreCommitted, part_info));
+
+            auto precommitted_parts_range = getDataPartsStateRange(DataPartState::PreCommitted);
+
+            for (auto it = it_middle; it != precommitted_parts_range.begin();)
+            {
+                --it;
+                check_coverage(*it);
+            }
+
+            for (auto it = it_middle; it != precommitted_parts_range.end();)
+            {
+                check_coverage(*it);
+                ++it;
+            }
+        }
 
         /// Is the part covered by some other part?
-        bool obsolete = false;
+        DataPartPtr covering_part;
 
-        auto check_replacing_part_state = [&] (const DataPartPtr & cur_part)
-        {
-            cur_part->assertState({DataPartState::PreCommitted, DataPartState::Committed});
-            if (cur_part->state == DataPartState::PreCommitted)
-                throw Exception("Could not add part " + new_name + " while replacing part " + cur_part->name + " is in pre-committed state", ErrorCodes::LOGICAL_ERROR);
-        };
+        auto it_middle = data_parts_by_state_and_name.lower_bound(DataPartStateAndInfo(DataPartState::Committed, part_info));
 
-        /// Don't consider parts going to be deleted
-        auto active_parts = getDataPartsRange({DataPartState::Committed, DataPartState::PreCommitted});
         /// Parts contained in the part are consecutive in data_parts, intersecting the insertion place for the part itself.
-        auto it_middle = active_parts.convert(data_parts.lower_bound(part));
+        auto committed_parts_range = getDataPartsStateRange(DataPartState::Committed);
 
         /// Go to the left.
-        for (auto it = it_middle; it != active_parts.begin();)
+        for (auto it = it_middle; it != committed_parts_range.begin();)
         {
             --it;
 
-            if (!part->contains(**it))
+            if (!part_info.contains((*it)->info))
             {
-                if ((*it)->contains(*part))
-                    obsolete = true;
-                ++it;
+                if ((*it)->info.contains(part_info))
+                    covering_part = *it;
                 break;
             }
 
-            check_replacing_part_state(*it);
-            replaced.push_back(*it);
-//            replaced.push_back(*it);
-//            (*it)->remove_time = time(nullptr);
-//            (*it)->state = replaced_parts_state;
-//            removePartContributionToColumnSizes(*it);
-//            data_parts.erase(it++); /// Yes, ++, not --.
+            replaced_iterators.push_back(it);
         }
 
         /// Parts must be in ascending order.
-        std::reverse(replaced.begin(), replaced.end());
+        std::reverse(replaced_iterators.begin(), replaced_iterators.end());
 
         /// Go to the right.
-        for (auto it = it_middle; it != active_parts.end();)
+        for (auto it = it_middle; it != committed_parts_range.end();)
         {
-            if ((*it)->name == part->name)
-                throw Exception("Unexpected duplicate part " + part->getNameWithState() + ". It is a bug.", ErrorCodes::LOGICAL_ERROR);
+            if ((*it)->name == part_name)
+                throw Exception("Unexpected duplicate part " + (*it)->getNameWithState() + ". It is a bug.", ErrorCodes::LOGICAL_ERROR);
 
-            if (!part->contains(**it))
+            if (!part_info.contains((*it)->info))
             {
-                if ((*it)->contains(*part))
-                    obsolete = true;
+                if ((*it)->info.contains(part_info))
+                    covering_part = *it;
                 break;
             }
 
-            check_replacing_part_state(*it);
-            replaced.push_back(*it);
+            replaced_iterators.push_back(it);
             ++it;
-//            replaced.push_back(*it);
-//            (*it)->remove_time = time(nullptr);
-//            (*it)->state = replaced_parts_state;
-//            removePartContributionToColumnSizes(*it);
-//            data_parts.erase(it++);
         }
 
-        if (obsolete)
+        if (covering_part)
         {
-            LOG_WARNING(log, "Obsolete part " << part->name << " added");
+            LOG_WARNING(log, "Tried to add obsolete part " << part_name << " covered by " << covering_part->getNameWithState());
+
+            /// It is a temporary part, we want to delete it from filesystem immediately
+            /// Other fields remain the same
             part->remove_time = time(nullptr);
-            /// I case of fail, we want to delete part from filesystem immediately (to avoid any conflicts)
             part->is_temp = true;
+
+            /// Nothing to commit or rollback
+            if (out_transaction)
+            {
+                out_transaction->data = this;
+                out_transaction->parts_to_add_on_rollback = {};
+                out_transaction->parts_to_remove_on_rollback = {};
+            }
+
+            /// We replaced nothing
+            return {};
+        }
+
+        /// All checks are passed. Now we can rename the part on disk.
+        /// So, we maintain invariant: if a non-temporary part in filesystem then it is in data_parts
+        ///
+        /// Ordinary MergeTree engines (they don't use out_transaction) commit parts immediately,
+        ///  whereas ReplicatedMergeTree uses intermediate PreCommitted state
+        part->name = part_name;
+        part->info = part_info;
+        part->is_temp = false;
+        part->state = (out_transaction) ? DataPartState::PreCommitted : DataPartState::Committed;
+        part->renameTo(part_name);
+
+        data_parts_indexes.insert(part);
+
+        replaced_parts.reserve(replaced_iterators.size());
+        for (auto it_replacing_part : replaced_iterators)
+            replaced_parts.emplace_back(*it_replacing_part);
+
+        if (!out_transaction)
+        {
+            addPartContributionToColumnSizes(part);
+
+            auto current_time = time(nullptr);
+            for (auto it_replacing_part : replaced_iterators)
+            {
+                (*it_replacing_part)->remove_time = current_time;
+                modifyPartState(it_replacing_part, DataPartState::Outdated);
+                removePartContributionToColumnSizes(*it_replacing_part);
+            }
         }
         else
         {
-            /// Now we can rename part on filesystem
-            part->is_temp = false;
-            part->renameTo(new_name);
-
-            if (!out_transaction)
-            {
-                /// Ordinary MergeTree engines (they don't use out_transaction) commit parts immediately
-                part->state = DataPartState::Committed;
-                addPartContributionToColumnSizes(part);
-            }
-            else
-            {
-                /// Whereas ReplicatedMergeTree uses intermediate PreCommitted state
-                part->state = DataPartState::PreCommitted;
-            }
-
-            data_parts.insert(part);
-
-            auto current_time = time(nullptr);
-            for (auto & replacing_part : replaced)
-            {
-                if (!out_transaction)
-                {
-                    replacing_part->remove_time = current_time;
-                    replacing_part->state = DataPartState::Outdated;
-                    removePartContributionToColumnSizes(replacing_part);
-                }
-            }
+            out_transaction->data = this;
+            out_transaction->parts_to_add_on_rollback = replaced_parts;
+            out_transaction->parts_to_remove_on_rollback = {part};
         }
     }
 
-    if (out_transaction)
-    {
-        out_transaction->data = this;
-        out_transaction->parts_to_add_on_rollback = replaced;
-        out_transaction->parts_to_remove_on_rollback = {part};
-    }
-
-    return replaced;
+    return replaced_parts;
 }
 
 void MergeTreeData::removePartsFromWorkingSet(const DataPartsVector & remove, bool clear_without_timeout)
@@ -1479,7 +1526,7 @@ void MergeTreeData::removePartsFromWorkingSet(const DataPartsVector & remove, bo
 
     for (auto & part : remove)
     {
-        if (!data_parts.count(part))
+        if (!data_parts_by_name.count(part->info))
             throw Exception("Part " + part->getNameWithState() + " not found in data_parts", ErrorCodes::LOGICAL_ERROR);
 
         part->assertState({DataPartState::PreCommitted, DataPartState::Committed, DataPartState::Outdated});
@@ -1490,7 +1537,8 @@ void MergeTreeData::removePartsFromWorkingSet(const DataPartsVector & remove, bo
     {
         if (part->state == DataPartState::Committed)
             removePartContributionToColumnSizes(part);
-        part->state = DataPartState::Outdated;
+
+        modifyPartState(part, DataPartState::Outdated);
         part->remove_time = remove_time;
     }
 }
@@ -1502,65 +1550,93 @@ void MergeTreeData::renameAndDetachPart(const DataPartPtr & part_to_detach, cons
     LOG_INFO(log, "Renaming " << part_to_detach->relative_path << " to " << prefix << part_to_detach->name << " and detaching it.");
 
     std::lock_guard<std::mutex> lock(data_parts_mutex);
-    //std::lock_guard<std::mutex> lock_all(all_data_parts_mutex);
 
-    auto it_part = data_parts.find(part_to_detach);
-    if (it_part == data_parts.end())
+    auto it_part = data_parts_by_name.find(part_to_detach->info);
+    if (it_part == data_parts_by_name.end())
         throw Exception("No such data part " + part_to_detach->getNameWithState(), ErrorCodes::NO_SUCH_DATA_PART);
 
     /// What if part_to_detach is reference to *it_part? Make a new owner just in case.
-    auto part = *it_part;
+    DataPartPtr part = *it_part;
 
-    removePartContributionToColumnSizes(part);
-    part->state = DataPartState::Deleting;
+    if (part->state == DataPartState::Committed)
+        removePartContributionToColumnSizes(part);
+    modifyPartState(it_part, DataPartState::Deleting);
     if (move_to_detached || !prefix.empty())
         part->renameAddPrefix(move_to_detached, prefix);
+    data_parts_indexes.erase(it_part);
+
+    if (restore_covered && part->info.level == 0)
+    {
+        LOG_WARNING(log, "Will not recover parts covered by zero-level part " << part->name);
+        return;
+    }
 
     if (restore_covered)
     {
-        auto suitable_parts = getDataPartsRange({DataPartState::PreCommitted, DataPartState::Committed, DataPartState::Outdated});
-        auto it = suitable_parts.convert(data_parts.lower_bound(part));
-
         Strings restored;
         bool error = false;
+        String error_parts;
 
         Int64 pos = part->info.min_block;
 
-        if (it != suitable_parts.begin())
+        auto is_appropriate_state = [] (DataPartState state)
         {
-            --it;
-            if (part->contains(**it))
+            return state == DataPartState::Committed || state == DataPartState::Outdated;
+        };
+
+        auto update_error = [&] (DataPartIteratorByAndName it)
+        {
+            error = true;
+            error_parts += (*it)->getNameWithState() + " ";
+        };
+
+        auto it_middle = data_parts_by_name.lower_bound(part->info);
+
+        /// Restore the leftmost part covered by the part
+        if (it_middle != data_parts_by_name.begin())
+        {
+            auto it = std::prev(it_middle);
+
+            if (part->contains(**it) && is_appropriate_state((*it)->state))
             {
+                /// Maybe, we must consider part level somehow
                 if ((*it)->info.min_block != part->info.min_block)
-                    error = true;
+                    update_error(it);
 
                 if ((*it)->state != DataPartState::Committed)
                 {
                     addPartContributionToColumnSizes(*it);
-                    (*it)->state = DataPartState::Committed;
+                    modifyPartState(it, DataPartState::Committed); // iterator is not invalidated here
                 }
 
                 pos = (*it)->info.max_block + 1;
                 restored.push_back((*it)->name);
             }
             else
-                error = true;
-            ++it;
+                update_error(it);
         }
         else
             error = true;
 
-        for (; it != suitable_parts.end() && part->contains(**it); ++it)
+        /// Restore "right" parts
+        for (auto it = it_middle; it != data_parts_by_name.end() && part->contains(**it); ++it)
         {
             if ((*it)->info.min_block < pos)
                 continue;
+
+            if (!is_appropriate_state((*it)->state))
+            {
+                update_error(it);
+                continue;
+            }
+
             if ((*it)->info.min_block > pos)
-                error = true;
+                update_error(it);
 
             if ((*it)->state != DataPartState::Committed)
             {
                 addPartContributionToColumnSizes(*it);
-                (*it)->state = DataPartState::Committed;
+                modifyPartState(it, DataPartState::Committed);
             }
 
             pos = (*it)->info.max_block + 1;
@@ -1576,18 +1652,24 @@ void MergeTreeData::renameAndDetachPart(const DataPartPtr & part_to_detach, cons
         }
 
         if (error)
-            LOG_ERROR(log, "The set of parts restored in place of " << part->name << " looks incomplete. There might or might not be a data loss.");
+        {
+            LOG_ERROR(log, "The set of parts restored in place of " << part->name << " looks incomplete."
+                           << " There might or might not be a data loss."
+                           << (error_parts.empty() ? "" : " Suspicious parts: " + error_parts));
+        }
     }
 }
 
 
 size_t MergeTreeData::getTotalActiveSizeInBytes() const
 {
-    std::lock_guard<std::mutex> lock(data_parts_mutex);
-
     size_t res = 0;
-    for (auto & part : getDataPartsRange({DataPartState::Committed}))
-        res += part->size_in_bytes;
+    {
+        std::lock_guard<std::mutex> lock(data_parts_mutex);
+
+        for (auto & part : getDataPartsStateRange(DataPartState::Committed))
+            res += part->size_in_bytes;
+    }
 
     return res;
 }
@@ -1601,7 +1683,7 @@ size_t MergeTreeData::getMaxPartsCountForPartition() const
     size_t cur_count = 0;
     const String * cur_partition_id = nullptr;
 
-    for (const auto & part : getDataPartsRange({DataPartState::Committed}))
+    for (const auto & part : getDataPartsStateRange(DataPartState::Committed))
     {
         if (cur_partition_id && part->info.partition_id == *cur_partition_id)
         {
@@ -1656,11 +1738,12 @@ MergeTreeData::DataPartPtr MergeTreeData::getActiveContainingPart(const String &
 
     std::lock_guard<std::mutex> lock(data_parts_mutex);
 
-    /// The part can be covered only by the previous or the next one in data_parts.
-    auto committed_parts = getDataPartsRange({DataPartState::Committed});
-    auto it = committed_parts.convert(data_parts.lower_bound(part_info));
+    auto committed_parts_range = getDataPartsStateRange(DataPartState::Committed);
 
-    if (it != committed_parts.end())
+    /// The part can be covered only by the previous or the next one in data_parts.
+    auto it = data_parts_by_state_and_name.lower_bound(DataPartStateAndInfo(DataPartState::Committed, part_info));
+
+    if (it != committed_parts_range.end())
     {
         if ((*it)->name == part_name)
             return *it;
@@ -1668,7 +1751,7 @@ MergeTreeData::DataPartPtr MergeTreeData::getActiveContainingPart(const String &
             return *it;
     }
 
-    if (it != committed_parts.begin())
+    if (it != committed_parts_range.begin())
     {
         --it;
         if ((*it)->info.contains(part_info))
@@ -1685,10 +1768,15 @@ MergeTreeData::DataPartPtr MergeTreeData::getPartIfExists(const String & part_na
 
     std::lock_guard<std::mutex> lock(data_parts_mutex);
 
-    auto filtered_parts = getDataPartsRange(valid_states);
-    auto it = filtered_parts.convert(data_parts.find(part_info));
-    if (it != filtered_parts.end() && (*it)->name == part_name)
-        return *it;
+    auto it = data_parts_by_name.find(part_info);
+    if (it == data_parts_by_name.end())
+        return nullptr;
+
+    for (auto state : valid_states)
+    {
+        if ((*it)->state == state)
+            return  *it;
+    }
 
     return nullptr;
 }
@@ -1742,7 +1830,8 @@ void MergeTreeData::calculateColumnSizesImpl()
     column_sizes.clear();
 
     /// Take into account only committed parts
-    for (const auto & part : getDataPartsRange({DataPartState::Committed}))
+    auto committed_parts_range = getDataPartsStateRange(DataPartState::Committed);
+    for (const auto & part : committed_parts_range)
         addPartContributionToColumnSizes(part);
 }
 
@@ -1953,7 +2042,7 @@ String MergeTreeData::getPartitionIDFromQuery(const ASTPtr & ast, const Context
     String partition_id = partition.getID(*this);
 
     {
-        std::lock_guard<std::mutex> data_parts_lock(data_parts_mutex);
+        std::unique_lock<std::mutex> data_parts_lock(data_parts_mutex);
         DataPartPtr existing_part_in_partition = getAnyPartInPartition(partition_id, data_parts_lock);
         if (existing_part_in_partition && existing_part_in_partition->partition.value != partition.value)
         {
@@ -1969,28 +2058,48 @@ String MergeTreeData::getPartitionIDFromQuery(const ASTPtr & ast, const Context
     return partition_id;
 }
 
-MergeTreeData::DataPartsVector MergeTreeData::getDataPartsVector(const DataPartStates & affordable_states) const
+MergeTreeData::DataPartsVector MergeTreeData::getDataPartsVector(const DataPartStates & affordable_states, DataPartStateVector * out_states) const
 {
     DataPartsVector res;
+    DataPartsVector buf;
     {
         std::lock_guard<std::mutex> lock(data_parts_mutex);
-        std::copy_if(data_parts.begin(), data_parts.end(), std::back_inserter(res), DataPart::getStatesFilter(affordable_states));
+
+        for (auto state : affordable_states)
+        {
+            buf = std::move(res);
+            res.clear();
+
+            auto range = getDataPartsStateRange(state);
+            std::merge(range.begin(), range.end(), buf.begin(), buf.end(), std::back_inserter(res), LessDataPart());
+        }
+
+        if (out_states != nullptr)
+        {
+            out_states->resize(res.size());
+            for (size_t i = 0; i < res.size(); ++i)
+                (*out_states)[i] = res[i]->state;
+        }
     }
+
     return res;
 }
 
-MergeTreeData::DataPartsVector MergeTreeData::getDataPartsVector(const MergeTreeData::DataPartStates & affordable_states,
-                                                                 MergeTreeData::DataPartStateVector & out_states_snapshot) const
+MergeTreeData::DataPartsVector MergeTreeData::getAllDataPartsVector(MergeTreeData::DataPartStateVector * out_states) const
 {
     DataPartsVector res;
     {
         std::lock_guard<std::mutex> lock(data_parts_mutex);
-        std::copy_if(data_parts.begin(), data_parts.end(), std::back_inserter(res), DataPart::getStatesFilter(affordable_states));
+        res.assign(data_parts_by_name.begin(), data_parts_by_name.end());
 
-        out_states_snapshot.resize(res.size());
-        for (size_t i = 0; i < res.size(); ++i)
-            out_states_snapshot[i] = res[i]->state;
+        if (out_states != nullptr)
+        {
+            out_states->resize(res.size());
+            for (size_t i = 0; i < res.size(); ++i)
+                (*out_states)[i] = res[i]->state;
+        }
     }
+
     return res;
 }
 
@@ -1999,7 +2108,11 @@ MergeTreeData::DataParts MergeTreeData::getDataParts(const DataPartStates & affo
     DataParts res;
     {
         std::lock_guard<std::mutex> lock(data_parts_mutex);
-        std::copy_if(data_parts.begin(), data_parts.end(), std::inserter(res, res.end()), DataPart::getStatesFilter(affordable_states));
+        for (auto state : affordable_states)
+        {
+            auto range = getDataPartsStateRange(state);
+            res.insert(range.begin(), range.end());
+        }
     }
     return res;
 }
@@ -2014,28 +2127,23 @@ MergeTreeData::DataPartsVector MergeTreeData::getDataPartsVector() const
     return getDataPartsVector({DataPartState::Committed});
 }
 
-MergeTreeData::DataParts MergeTreeData::getAllDataParts() const
-{
-    return getDataParts({DataPartState::PreCommitted, DataPartState::Committed, DataPartState::Outdated});
-}
-
 MergeTreeData::DataPartPtr MergeTreeData::getAnyPartInPartition(
-    const String & partition_id, std::lock_guard<std::mutex> & data_parts_lock)
+    const String & partition_id, std::unique_lock<std::mutex> & data_parts_lock)
 {
     auto min_block = std::numeric_limits<Int64>::min();
     MergeTreePartInfo dummy_part_info(partition_id, min_block, min_block, 0);
 
-    auto committed_parts = getDataPartsRange({DataPartState::Committed});
-    auto it = committed_parts.convert(data_parts.lower_bound(dummy_part_info));
+    auto it = data_parts_by_state_and_name.lower_bound(DataPartStateAndInfo(DataPartState::Committed, dummy_part_info));
 
-    if (it != committed_parts.end() && (*it)->info.partition_id == partition_id)
+    if (it != data_parts_by_state_and_name.end() && (*it)->state == DataPartState::Committed && (*it)->info.partition_id == partition_id)
         return *it;
-    return {};
+
+    return nullptr;
 }
 
 void MergeTreeData::Transaction::rollback()
 {
-    if (data && (!parts_to_remove_on_rollback.empty() || !parts_to_add_on_rollback.empty()))
+    if (!isEmpty())
     {
         std::stringstream ss;
         if (!parts_to_remove_on_rollback.empty())
@@ -2057,14 +2165,19 @@ void MergeTreeData::Transaction::rollback()
 
         /// PreCommitted -> Outdated
         replaceParts(DataPartState::Outdated, DataPartState::Committed, true);
-        clear();
     }
+
+    clear();
 }
 
 void MergeTreeData::Transaction::commit()
 {
-    /// PreCommitted -> Committed, Committed -> Outdated
-    replaceParts(DataPartState::Committed, DataPartState::Outdated, false);
+    if (!isEmpty())
+    {
+        /// PreCommitted -> Committed, Committed -> Outdated
+        replaceParts(DataPartState::Committed, DataPartState::Outdated, false);
+    }
+
     clear();
 }
 
@@ -2088,9 +2201,9 @@ void MergeTreeData::Transaction::replaceParts(MergeTreeData::DataPartState move_
         /// If it is rollback then do nothing, else make it Outdated and remove their size contribution
         if (move_committed_to != DataPartState::Committed)
         {
-            for (auto & part : committed_parts)
+            for (const DataPartPtr & part : committed_parts)
             {
-                part->state = move_committed_to;
+                data->modifyPartState(part, move_committed_to);
                 part->remove_time = remove_time;
                 data->removePartContributionToColumnSizes(part);
             }
@@ -2099,7 +2212,7 @@ void MergeTreeData::Transaction::replaceParts(MergeTreeData::DataPartState move_
         /// If it is rollback just change state to Outdated, else change state to Committed and add their size contribution
         for (auto & part : precommitted_parts)
         {
-            part->state = move_precommitted_to;
+            data->modifyPartState(part, move_precommitted_to);
             if (move_precommitted_to == DataPartState::Committed)
                 data->addPartContributionToColumnSizes(part);
             else
diff --git a/dbms/src/Storages/MergeTree/MergeTreeData.h b/dbms/src/Storages/MergeTree/MergeTreeData.h
index 2235a73dbf1..fe793c5da9c 100644
--- a/dbms/src/Storages/MergeTree/MergeTreeData.h
+++ b/dbms/src/Storages/MergeTree/MergeTreeData.h
@@ -15,7 +15,10 @@
 #include <DataStreams/GraphiteRollupSortedBlockInputStream.h>
 #include <Storages/MergeTree/MergeTreeDataPart.h>
 
-#include <common/RangeFiltered.h>
+#include <boost/multi_index_container.hpp>
+#include <boost/multi_index/ordered_index.hpp>
+#include <boost/multi_index/global_fun.hpp>
+#include <boost/range/iterator_range_core.hpp>
 
 namespace DB
 {
@@ -104,7 +107,16 @@ public:
     using DataPartStates = std::initializer_list<DataPartState>;
     using DataPartStateVector = std::vector<DataPartState>;
 
-    struct DataPartPtrLess
+    /// Auxiliary structure for index comparison. Keep in mind lifetime of MergeTreePartInfo.
+    struct DataPartStateAndInfo
+    {
+        DataPartState state;
+        const MergeTreePartInfo & info;
+
+        DataPartStateAndInfo(DataPartState state, const MergeTreePartInfo & info) : state(state), info(info) {}
+    };
+
+    struct LessDataPart
     {
         using is_transparent = void;
 
@@ -113,11 +125,32 @@ public:
         bool operator()(const DataPartPtr & lhs, const DataPartPtr & rhs) const { return lhs->info < rhs->info; }
     };
 
-    using DataParts = std::set<DataPartPtr, DataPartPtrLess>;
+    struct LessStateDataPart
+    {
+        using is_transparent = void;
+
+        bool operator() (const DataPartStateAndInfo & lhs, const DataPartStateAndInfo & rhs) const
+        {
+            return std::forward_as_tuple(static_cast<UInt8>(lhs.state), lhs.info)
+                   < std::forward_as_tuple(static_cast<UInt8>(rhs.state), rhs.info);
+        }
+
+        bool operator() (DataPartStateAndInfo info, const DataPartState & state) const
+        {
+            return static_cast<size_t>(info.state) < static_cast<size_t>(state);
+        }
+
+        bool operator() (const DataPartState & state, DataPartStateAndInfo info) const
+        {
+            return static_cast<size_t>(state) < static_cast<size_t>(info.state);
+        }
+    };
+
+    using DataParts = std::set<DataPartPtr, LessDataPart>;
     using DataPartsVector = std::vector<DataPartPtr>;
 
     /// For resharding.
-    using MutableDataParts = std::set<MutableDataPartPtr, DataPartPtrLess>;
+    using MutableDataParts = std::set<MutableDataPartPtr, LessDataPart>;
     using PerShardDataParts = std::unordered_map<size_t, MutableDataPartPtr>;
 
     /// Some operations on the set of parts return a Transaction object.
@@ -131,6 +164,11 @@ public:
 
         void rollback();
 
+        bool isEmpty() const
+        {
+            return parts_to_add_on_rollback.empty() && parts_to_remove_on_rollback.empty();
+        }
+
         ~Transaction()
         {
             try
@@ -310,22 +348,17 @@ public:
 
     /// Returns a copy of the list so that the caller shouldn't worry about locks.
     DataParts getDataParts(const DataPartStates & affordable_states) const;
-    DataPartsVector getDataPartsVector(const DataPartStates & affordable_states) const;
-    DataPartsVector getDataPartsVector(const DataPartStates & affordable_states, DataPartStateVector & out_states_snapshot) const;
+    /// Returns sorted list of the parts with specified states
+    ///  out_states will contain snapshot of each part state
+    DataPartsVector getDataPartsVector(const DataPartStates & affordable_states, DataPartStateVector * out_states = nullptr) const;
 
-    /// Returns a virtual container iteration only through parts with specified states
-    decltype(auto) getDataPartsRange(const DataPartStates & affordable_states) const
-    {
-        return createRangeFiltered(DataPart::getStatesFilter(affordable_states), data_parts);
-    }
+    /// Returns absolutely all parts (and snapshot of their states)
+    DataPartsVector getAllDataPartsVector(DataPartStateVector * out_states = nullptr) const;
 
     /// Returns Committed parts
     DataParts getDataParts() const;
     DataPartsVector getDataPartsVector() const;
 
-    /// Returns all parts except Temporary and Deleting ones
-    DataParts getAllDataParts() const;
-
     /// Returns an comitted part with the given name or a part containing it. If there is no such part, returns nullptr.
     DataPartPtr getActiveContainingPart(const String & part_name);
 
@@ -375,8 +408,8 @@ public:
     /// Removes parts from data_parts, they should be in Deleting state
     void removePartsFinally(const DataPartsVector & parts);
 
-    /// Delete irrelevant parts.
-    void clearOldParts();
+    /// Delete irrelevant parts from memory and disk.
+    void clearOldPartsFromFilesystem();
 
     /// Deleate all directories which names begin with "tmp"
     /// Set non-negative parameter value to override MergeTreeSettings temporary_directories_lifetime
@@ -538,15 +571,81 @@ private:
     String log_name;
     Logger * log;
 
-    /// Current set of data parts.
-    DataParts data_parts;
-    mutable std::mutex data_parts_mutex;
 
-    /// The set of all data parts including already merged but not yet deleted. Usually it is small (tens of elements).
-    /// The part is referenced from here, from the list of current parts and from each thread reading from it.
-    /// This means that if reference count is 1 - the part is not used right now and can be deleted.
-//    DataParts all_data_parts;
-//    mutable std::mutex all_data_parts_mutex;
+    /// Work with data parts
+
+    struct TagByName{};
+    struct TagByStateAndName{};
+
+    static const MergeTreePartInfo & dataPartPtrToInfo(const DataPartPtr & part)
+    {
+        return part->info;
+    }
+
+    static DataPartStateAndInfo dataPartPtrToStateAndInfo(const DataPartPtr & part)
+    {
+        return {part->state, part->info};
+    };
+
+    using DataPartsIndexes = boost::multi_index_container<DataPartPtr,
+        boost::multi_index::indexed_by<
+            /// Index by Name
+            boost::multi_index::ordered_unique<
+                boost::multi_index::tag<TagByName>,
+                boost::multi_index::global_fun<const DataPartPtr &, const MergeTreePartInfo &, dataPartPtrToInfo>
+            >,
+            /// Index by (State, Name), is used to obtain ordered slices of parts with the same state
+            boost::multi_index::ordered_unique<
+                boost::multi_index::tag<TagByStateAndName>,
+                boost::multi_index::global_fun<const DataPartPtr &, DataPartStateAndInfo, dataPartPtrToStateAndInfo>,
+                LessStateDataPart
+            >
+        >
+    >;
+
+    /// Current set of data parts.
+    mutable std::mutex data_parts_mutex;
+    DataPartsIndexes data_parts_indexes;
+    DataPartsIndexes::index<TagByName>::type & data_parts_by_name;
+    DataPartsIndexes::index<TagByStateAndName>::type & data_parts_by_state_and_name;
+
+    using DataPartIteratorByAndName = DataPartsIndexes::index<TagByName>::type::iterator;
+    using DataPartIteratorByStateAndName = DataPartsIndexes::index<TagByStateAndName>::type::iterator;
+
+    boost::iterator_range<DataPartIteratorByStateAndName> getDataPartsStateRange(DataPartState state) const
+    {
+        auto begin = data_parts_by_state_and_name.lower_bound(state, LessStateDataPart());
+        auto end = data_parts_by_state_and_name.upper_bound(state, LessStateDataPart());
+        return {begin, end};
+    }
+
+    static decltype(auto) getStateModifier(DataPartState state)
+    {
+        return [state] (const DataPartPtr & part) { part->state = state; };
+    }
+
+    void modifyPartState(DataPartIteratorByStateAndName it, DataPartState state)
+    {
+        if (!data_parts_by_state_and_name.modify(it, getStateModifier(state)))
+            throw Exception("Can't modify " + (*it)->getNameWithState(), ErrorCodes::LOGICAL_ERROR);
+    }
+
+    void modifyPartState(DataPartIteratorByAndName it, DataPartState state)
+    {
+        if (!data_parts_by_state_and_name.modify(data_parts_indexes.project<TagByStateAndName>(it), getStateModifier(state)))
+            throw Exception("Can't modify " + (*it)->getNameWithState(), ErrorCodes::LOGICAL_ERROR);
+    }
+
+    void modifyPartState(const DataPartPtr & part, DataPartState state)
+    {
+        auto it = data_parts_by_name.find(part->info);
+        if (it == data_parts_by_name.end() || (*it).get() != part.get())
+            throw Exception("Part " + part->name + " is not exists", ErrorCodes::LOGICAL_ERROR);
+
+        if (!data_parts_by_state_and_name.modify(data_parts_indexes.project<TagByStateAndName>(it), getStateModifier(state)))
+            throw Exception("Can't modify " + (*it)->getNameWithState(), ErrorCodes::LOGICAL_ERROR);
+    }
+
 
     /// Used to serialize calls to grabOldParts.
     std::mutex grab_old_parts_mutex;
@@ -582,7 +681,7 @@ private:
     void removePartContributionToColumnSizes(const DataPartPtr & part);
 
     /// If there is no part in the partition with ID `partition_id`, returns empty ptr. Should be called under the lock.
-    DataPartPtr getAnyPartInPartition(const String & partition_id, std::lock_guard<std::mutex> & data_parts_lock);
+    DataPartPtr getAnyPartInPartition(const String & partition_id, std::unique_lock<std::mutex> & data_parts_lock);
 };
 
 }
diff --git a/dbms/src/Storages/MergeTree/MergeTreeDataMerger.cpp b/dbms/src/Storages/MergeTree/MergeTreeDataMerger.cpp
index 280e1cc30a6..cc8094b8ee5 100644
--- a/dbms/src/Storages/MergeTree/MergeTreeDataMerger.cpp
+++ b/dbms/src/Storages/MergeTree/MergeTreeDataMerger.cpp
@@ -187,7 +187,7 @@ bool MergeTreeDataMerger::selectPartsToMerge(
         if (prev_part && part->info.partition_id == (*prev_part)->info.partition_id
             && part->info.min_block < (*prev_part)->info.max_block)
         {
-            LOG_ERROR(log, "Part " << part->name << " intersects previous part " << (*prev_part)->name);
+            LOG_ERROR(log, "Part " << part->getNameWithState() << " intersects previous part " << (*prev_part)->getNameWithState());
         }
 
         prev_part = &part;
diff --git a/dbms/src/Storages/MergeTree/MergeTreeDataPart.cpp b/dbms/src/Storages/MergeTree/MergeTreeDataPart.cpp
index a893a8d26d3..d8e35552065 100644
--- a/dbms/src/Storages/MergeTree/MergeTreeDataPart.cpp
+++ b/dbms/src/Storages/MergeTree/MergeTreeDataPart.cpp
@@ -38,6 +38,7 @@ namespace ErrorCodes
     extern const int FORMAT_VERSION_TOO_OLD;
     extern const int UNKNOWN_FORMAT;
     extern const int UNEXPECTED_FILE_IN_DATA_PART;
+    extern const int NOT_FOUND_EXPECTED_DATA_PART;
 }
 
 
@@ -935,4 +936,16 @@ String MergeTreeDataPart::stateString() const
     return stateToString(state);
 }
 
+void MergeTreeDataPart::assertState(const std::initializer_list<MergeTreeDataPart::State> & affordable_states) const
+{
+    if (!checkState(affordable_states))
+    {
+        String states_str;
+        for (auto state : affordable_states)
+            states_str += stateToString(state) + " ";
+
+        throw Exception("Unexpected state of part " + getNameWithState() + ". Expected: " + states_str, ErrorCodes::NOT_FOUND_EXPECTED_DATA_PART);
+    }
+}
+
 }
diff --git a/dbms/src/Storages/MergeTree/MergeTreeDataPart.h b/dbms/src/Storages/MergeTree/MergeTreeDataPart.h
index 1863fcbc0f2..b767eb6414b 100644
--- a/dbms/src/Storages/MergeTree/MergeTreeDataPart.h
+++ b/dbms/src/Storages/MergeTree/MergeTreeDataPart.h
@@ -190,17 +190,7 @@ struct MergeTreeDataPart
     }
 
     /// Throws an exception if state of the part is not in affordable_states
-    void assertState(const std::initializer_list<State> & affordable_states) const
-    {
-        if (!checkState(affordable_states))
-        {
-            String states_str;
-            for (auto state : affordable_states)
-                states_str += stateToString(state) + " ";
-
-            throw Exception("Unexpected state of part " + getNameWithState() + ". Expected: " + states_str);
-        }
-    }
+    void assertState(const std::initializer_list<State> & affordable_states) const;
 
     /// In comparison with lambdas, it is move assignable and could has several overloaded operator()
     struct StatesFilter
@@ -327,4 +317,7 @@ private:
     void checkConsistency(bool require_part_metadata);
 };
 
+
+using MergeTreeDataPartState = MergeTreeDataPart::State;
+
 }
diff --git a/dbms/src/Storages/StorageMergeTree.cpp b/dbms/src/Storages/StorageMergeTree.cpp
index 035d01de38d..c11ee29b10a 100644
--- a/dbms/src/Storages/StorageMergeTree.cpp
+++ b/dbms/src/Storages/StorageMergeTree.cpp
@@ -68,7 +68,7 @@ StorageMergeTree::StorageMergeTree(
     }
     else
     {
-        data.clearOldParts();
+        data.clearOldPartsFromFilesystem();
     }
 
     /// Temporary directories contain incomplete results of merges (after forced restart)
@@ -188,7 +188,7 @@ void StorageMergeTree::alter(
     if (primary_key_is_modified && supportsSampling())
         throw Exception("MODIFY PRIMARY KEY only supported for tables without sampling key", ErrorCodes::BAD_ARGUMENTS);
 
-    MergeTreeData::DataParts parts = data.getAllDataParts();
+    auto parts = data.getDataParts({MergeTreeDataPartState::PreCommitted, MergeTreeDataPartState::Committed, MergeTreeDataPartState::Outdated});
     for (const MergeTreeData::DataPartPtr & part : parts)
     {
         if (auto transaction = data.alterDataPart(part, columns_for_parts, new_primary_key_ast, false))
@@ -291,7 +291,7 @@ bool StorageMergeTree::merge(
     /// Clear old parts. It does not matter to do it more frequently than each second.
     if (auto lock = time_after_previous_cleanup.lockTestAndRestartAfter(1))
     {
-        data.clearOldParts();
+        data.clearOldPartsFromFilesystem();
         data.clearOldTemporaryDirectories();
     }
 
diff --git a/dbms/src/Storages/StorageReplicatedMergeTree.cpp b/dbms/src/Storages/StorageReplicatedMergeTree.cpp
index 8e745721434..55f72ca520b 100644
--- a/dbms/src/Storages/StorageReplicatedMergeTree.cpp
+++ b/dbms/src/Storages/StorageReplicatedMergeTree.cpp
@@ -109,6 +109,7 @@ namespace ErrorCodes
     extern const int RECEIVED_ERROR_TOO_MANY_REQUESTS;
     extern const int TOO_MUCH_FETCHES;
     extern const int BAD_DATA_PART_NAME;
+    extern const int PART_IS_TEMPORARILY_LOCKED;
 }
 
 
@@ -800,7 +801,7 @@ void StorageReplicatedMergeTree::checkParts(bool skip_sanity_checks)
     /// Parts in ZK.
     NameSet expected_parts(expected_parts_vec.begin(), expected_parts_vec.end());
 
-    MergeTreeData::DataParts parts = data.getAllDataParts();
+    auto parts = data.getDataParts({MergeTreeDataPartState::PreCommitted, MergeTreeDataPartState::Committed, MergeTreeDataPartState::Outdated});
 
     /// Local parts that are not in ZK.
     MergeTreeData::DataParts unexpected_parts;
@@ -1179,7 +1180,21 @@ bool StorageReplicatedMergeTree::executeLogEntry(const LogEntry & entry)
             if (!do_fetch)
             {
                 merger.renameMergedTemporaryPart(part, parts, &transaction);
-                getZooKeeper()->multi(ops);        /// After long merge, get fresh ZK handle, because previous session may be expired.
+
+                /// Do not commit if the part is obsolete
+                if (!transaction.isEmpty())
+                {
+                    getZooKeeper()->multi(ops); /// After long merge, get fresh ZK handle, because previous session may be expired.
+                    transaction.commit();
+                }
+
+                /** Removing old chunks from ZK and from the disk is delayed - see ReplicatedMergeTreeCleanupThread, clearOldParts.
+                  */
+
+                /** With `ZCONNECTIONLOSS` or `ZOPERATIONTIMEOUT`, we can inadvertently roll back local changes to the parts.
+                  * This is not a problem, because in this case the merge will remain in the queue, and we will try again.
+                  */
+                merge_selecting_event.set();
 
                 if (auto part_log = context.getPartLog(database_name, table_name))
                 {
@@ -1212,15 +1227,6 @@ bool StorageReplicatedMergeTree::executeLogEntry(const LogEntry & entry)
                     }
                 }
 
-                /** Removing old chunks from ZK and from the disk is delayed - see ReplicatedMergeTreeCleanupThread, clearOldParts.
-                  */
-
-                /** With `ZCONNECTIONLOSS` or `ZOPERATIONTIMEOUT`, we can inadvertently roll back local changes to the parts.
-                  * This is not a problem, because in this case the merge will remain in the queue, and we will try again.
-                  */
-                transaction.commit();
-                merge_selecting_event.set();
-
                 ProfileEvents::increment(ProfileEvents::ReplicatedPartMerges);
             }
         }
@@ -1443,8 +1449,9 @@ void StorageReplicatedMergeTree::executeDropRange(const StorageReplicatedMergeTr
     /// It's important that no old parts remain (after the merge), because otherwise,
     ///  after adding a new replica, this new replica downloads them, but does not delete them.
     /// And, if you do not, the parts will come to life after the server is restarted.
-    /// Therefore, we use getAllDataParts.
-    auto parts = data.getAllDataParts();
+    /// Therefore, we use all data parts.
+    auto parts = data.getDataParts({MergeTreeDataPartState::PreCommitted, MergeTreeDataPartState::Committed, MergeTreeDataPartState::Outdated});
+
     for (const auto & part : parts)
     {
         if (!entry_part_info.contains(part->info))
@@ -1616,6 +1623,11 @@ bool StorageReplicatedMergeTree::queueTask()
                 /// Interrupted merge or downloading a part is not an error.
                 LOG_INFO(log, e.message());
             }
+            else if (e.code() == ErrorCodes::PART_IS_TEMPORARILY_LOCKED)
+            {
+                /// Part cannot be added temporarily
+                LOG_INFO(log, e.displayText());
+            }
             else
                 tryLogCurrentException(__PRETTY_FUNCTION__);
 
@@ -2205,6 +2217,13 @@ bool StorageReplicatedMergeTree::fetchPart(const String & part_name, const Strin
         MergeTreeData::Transaction transaction;
         auto removed_parts = data.renameTempPartAndReplace(part, nullptr, &transaction);
 
+        /// Do not commit if the part is obsolete
+        if (!transaction.isEmpty())
+        {
+            getZooKeeper()->multi(ops);
+            transaction.commit();
+        }
+
         if (auto part_log = context.getPartLog(database_name, table_name))
         {
             PartLogElement elem;
@@ -2236,10 +2255,6 @@ bool StorageReplicatedMergeTree::fetchPart(const String & part_name, const Strin
             }
         }
 
-
-        getZooKeeper()->multi(ops);
-        transaction.commit();
-
         /** If a quorum is tracked for this part, you must update it.
           * If you do not have time, in case of losing the session, when you restart the server - see the `ReplicatedMergeTreeRestartingThread::updateQuorumIfWeHavePart` method.
           */
diff --git a/dbms/src/Storages/System/StorageSystemParts.cpp b/dbms/src/Storages/System/StorageSystemParts.cpp
index aba6db5fbbc..02cad078f02 100644
--- a/dbms/src/Storages/System/StorageSystemParts.cpp
+++ b/dbms/src/Storages/System/StorageSystemParts.cpp
@@ -39,7 +39,7 @@ StorageSystemParts::StorageSystemParts(const std::string & name_)
 
         {"database",            std::make_shared<DataTypeString>()},
         {"table",               std::make_shared<DataTypeString>()},
-        {"engine",              std::make_shared<DataTypeString>()},
+        {"engine",              std::make_shared<DataTypeString>()}
     }
 {
 }
@@ -53,9 +53,12 @@ BlockInputStreams StorageSystemParts::read(
     const size_t max_block_size,
     const unsigned num_streams)
 {
-    check(column_names);
+    //check(column_names);
     processed_stage = QueryProcessingStage::FetchColumns;
 
+    auto it_state_column = std::find(column_names.begin(), column_names.end(), "_state");
+    bool has_state_column = it_state_column != column_names.end();
+
     /// Will apply WHERE to subset of columns and then add more columns.
     /// This is kind of complicated, but we use WHERE to do less work.
 
@@ -142,6 +145,8 @@ BlockInputStreams StorageSystemParts::read(
     /// Finally, create the result.
 
     Block block = getSampleBlock();
+    if (has_state_column)
+        block.insert(ColumnWithTypeAndName(std::make_shared<DataTypeString>(), "_state"));
 
     for (size_t i = 0; i < filtered_database_column->size();)
     {
@@ -198,10 +203,18 @@ BlockInputStreams StorageSystemParts::read(
         using State = MergeTreeDataPart::State;
         MergeTreeData::DataPartStateVector all_parts_state;
         MergeTreeData::DataPartsVector all_parts;
+
         if (need[0])
-            all_parts = data->getDataPartsVector({State::Committed, State::Outdated}, all_parts_state);
+        {
+            /// If has_state_column is requested, return all states
+            if (!has_state_column)
+                all_parts = data->getDataPartsVector({State::Committed, State::Outdated}, &all_parts_state);
+            else
+                all_parts = data->getAllDataPartsVector(&all_parts_state);
+        }
         else
-            all_parts = data->getDataPartsVector({State::Committed}, all_parts_state);
+            all_parts = data->getDataPartsVector({State::Committed}, &all_parts_state);
+
 
         /// Finally, we'll go through the list of parts.
         for (size_t part_number = 0; part_number < all_parts.size(); ++part_number)
@@ -248,11 +261,30 @@ BlockInputStreams StorageSystemParts::read(
             block.getByPosition(i++).column->insert(database);
             block.getByPosition(i++).column->insert(table);
             block.getByPosition(i++).column->insert(engine);
+
+            if (has_state_column)
+                block.getByPosition(i++).column->insert(part->stateString());
         }
     }
 
     return BlockInputStreams(1, std::make_shared<OneBlockInputStream>(block));
 }
 
+NameAndTypePair StorageSystemParts::getColumn(const String & column_name) const
+{
+    if (column_name == "_state")
+        return NameAndTypePair("_state", std::make_shared<DataTypeString>());
+
+    return ITableDeclaration::getColumn(column_name);
+}
+
+bool StorageSystemParts::hasColumn(const String & column_name) const
+{
+    if (column_name == "_state")
+        return true;
+
+    return ITableDeclaration::hasColumn(column_name);
+}
+
 
 }
diff --git a/dbms/src/Storages/System/StorageSystemParts.h b/dbms/src/Storages/System/StorageSystemParts.h
index 17c6a7f4e5c..09b14d72e56 100644
--- a/dbms/src/Storages/System/StorageSystemParts.h
+++ b/dbms/src/Storages/System/StorageSystemParts.h
@@ -21,6 +21,10 @@ public:
 
     const NamesAndTypesList & getColumnsListImpl() const override { return columns; }
 
+    NameAndTypePair getColumn(const String & column_name) const override;
+
+    bool hasColumn(const String & column_name) const override;
+
     BlockInputStreams read(
         const Names & column_names,
         const SelectQueryInfo & query_info,
diff --git a/dbms/src/Storages/tests/gtest_range_filtered.cpp b/dbms/src/Storages/tests/gtest_range_filtered.cpp
deleted file mode 100644
index 1a3b82f1a68..00000000000
--- a/dbms/src/Storages/tests/gtest_range_filtered.cpp
+++ /dev/null
@@ -1,44 +0,0 @@
-#include <gtest/gtest.h>
-#include <common/RangeFiltered.h>
-#include <vector>
-#include <set>
-
-
-TEST(RangeFiltered, simple)
-{
-    std::vector<int> v;
-
-    for (int i = 0; i < 10; ++i)
-        v.push_back(i);
-
-    auto v30 = createRangeFiltered([] (int i) { return i % 3 == 0; }, v);
-    auto v31 = createRangeFiltered([] (int i) { return i % 3 != 0; }, v);
-
-    for (const int & i : v30)
-        ASSERT_EQ(i % 3, 0);
-
-    for (const int & i : v31)
-        ASSERT_NE(i % 3, 0);
-
-    {
-        auto it = v30.begin();
-        ASSERT_EQ(*it, 0);
-
-        auto it2 = std::next(it);
-        ASSERT_EQ(*it2, 3);
-
-        it = std::next(it2);
-        ASSERT_EQ(*it, 6);
-    }
-
-    {
-        auto it = std::next(v30.begin());
-        ASSERT_EQ(*it, 3);
-
-        *it = 2; /// it becomes invalid
-        ASSERT_EQ(*(++it), 6); /// but iteration is sucessfull
-
-        *v30.begin() = 1;
-        ASSERT_EQ(*v30.begin(), 6);
-    }
-}
diff --git a/dbms/tests/integration/test_random_inserts/test.py b/dbms/tests/integration/test_random_inserts/test.py
index d9325c91191..bfa5c451f44 100644
--- a/dbms/tests/integration/test_random_inserts/test.py
+++ b/dbms/tests/integration/test_random_inserts/test.py
@@ -26,6 +26,7 @@ def started_cluster():
         pass
         cluster.shutdown()
 
+
 def test_random_inserts(started_cluster):
     # Duration of the test, reduce it if don't want to wait
     DURATION_SECONDS = 10# * 60
@@ -55,7 +56,9 @@ def test_random_inserts(started_cluster):
             inserter.get_answer()
 
     answer="{}\t{}\t{}\t{}\n".format(num_timestamps, num_timestamps, min_timestamp, max_timestamp)
+
     for node in nodes:
-        assert TSV(node.query("SELECT count(), uniqExact(i), min(i), max(i) FROM simple")) == TSV(answer), node.name + " : " + node.query("SELECT groupArray(_part), i, count() AS c FROM simple GROUP BY i ORDER BY c DESC LIMIT 1")
+        res = node.query("SELECT count(), uniqExact(i), min(i), max(i) FROM simple")
+        assert TSV(res) == TSV(answer), node.name + " : " + node.query("SELECT groupArray(_part), i, count() AS c FROM simple GROUP BY i ORDER BY c DESC LIMIT 1")
 
     node1.query("""DROP TABLE simple ON CLUSTER test_cluster""")
diff --git a/dbms/tests/integration/test_random_inserts/test.sh b/dbms/tests/integration/test_random_inserts/test.sh
index d743ffe4e91..006ee673fe9 100755
--- a/dbms/tests/integration/test_random_inserts/test.sh
+++ b/dbms/tests/integration/test_random_inserts/test.sh
@@ -4,6 +4,7 @@
 [[ -n "$1" ]] && host="$1" || host="127.0.0.1"
 [[ -n "$2" ]] && min_timestamp="$2" || min_timestamp=$(( $(date +%s) - 10 ))
 [[ -n "$3" ]] && max_timestamp="$3" || max_timestamp=$(( $(date +%s) + 10 ))
+[[ -n "$4" ]] && iters_per_timestamp="$4" || iters_per_timestamp=1
 
 timestamps=`seq $min_timestamp $max_timestamp`
 
@@ -40,6 +41,6 @@ for i in $timestamps; do
         cur_timestamp=$(date +%s)
     done
 
-    #echo $i >> $host".txt"
     reliable_insert "$i"
-done
\ No newline at end of file
+done
+sleep 1
diff --git a/libs/libcommon/include/common/RangeFiltered.h b/libs/libcommon/include/common/RangeFiltered.h
deleted file mode 100644
index cdb8f902409..00000000000
--- a/libs/libcommon/include/common/RangeFiltered.h
+++ /dev/null
@@ -1,127 +0,0 @@
-#pragma once
-#include <type_traits>
-
-
-/// Similar to boost::filtered_range but a little bit easier and allows to convert ordinary iterators to filtered
-template <typename F, typename C>
-struct RangeFiltered
-{
-    /// Template parameter C may be const. Then const_iterator is used.
-    using RawIterator = decltype(std::declval<C>().begin());
-    class Iterator;
-
-    /// Will iterate over elements for which filter(*it) == true
-    template <typename F_, typename C_> /// Another template for universal references to work.
-    RangeFiltered(F_ && filter, C_ && container)
-        : filter(std::move(filter)), container(container) {}
-
-    Iterator begin() const
-    {
-        return Iterator{*this, std::begin(container)};
-    }
-
-    Iterator end() const
-    {
-        return Iterator{*this, std::end(container)};
-    }
-
-    /// Convert ordinary iterator to filtered one
-    /// Real position will be in range [ordinary_iterator; end()], so it is suitable to use with lower[upper]_bound()
-    inline Iterator convert(RawIterator ordinary_iterator) const
-    {
-        return Iterator{*this, ordinary_iterator};
-    }
-
-
-    /// It is similar to boost::filtered_iterator, but has additional features:
-    ///  it doesn't store end() iterator
-    ///  it doesn't store predicate, so it allows to implement operator=()
-    ///  it guarantees that operator++() works properly in case of filter(*it) == false
-    class Iterator
-    {
-    public:
-        using Range = RangeFiltered<F, C>;
-
-        typedef Iterator self_type;
-        typedef typename std::iterator_traits<RawIterator>::value_type value_type;
-        typedef typename std::iterator_traits<RawIterator>::reference reference;
-        typedef const value_type & const_reference;
-        typedef typename std::iterator_traits<RawIterator>::pointer pointer;
-        typedef const value_type * const_pointer;
-        typedef typename std::iterator_traits<RawIterator>::difference_type difference_type;
-        typedef std::bidirectional_iterator_tag iterator_category;
-
-        Iterator(const Range & range_, RawIterator iter_)
-        : range(&range_), iter(iter_)
-        {
-            for (; iter != std::end(range->container) && !range->filter(*iter); ++iter);
-        }
-
-        Iterator(const Iterator & rhs) = default;
-        Iterator(Iterator && rhs) noexcept = default;
-
-        Iterator operator++()
-        {
-            ++iter;
-            for (; iter != std::end(range->container) && !range->filter(*iter); ++iter);
-            return *this;
-        }
-
-        Iterator operator--()
-        {
-            --iter;
-            for (; !range->filter(*iter); --iter); /// Don't check std::begin() bound
-            return *this;
-        }
-
-        pointer operator->()
-        {
-            return iter.operator->();
-        }
-
-        const_pointer operator->() const
-        {
-            return iter.operator->();
-        }
-
-        reference operator*()
-        {
-            return *iter;
-        }
-
-        const_reference operator*() const
-        {
-            return *iter;
-        }
-
-        bool operator==(const self_type & rhs) const
-        {
-            return iter == rhs.iter;
-        }
-
-        bool operator!=(const self_type & rhs) const
-        {
-            return iter != rhs.iter;
-        }
-
-        self_type & operator=(const self_type & rhs) = default;
-        self_type & operator=(self_type && rhs) noexcept = default;
-
-        ~Iterator() = default;
-
-    private:
-        const Range * range = nullptr;
-        RawIterator iter;
-    };
-
-protected:
-    F filter;
-    C & container;
-};
-
-
-template <typename F, typename C>
-inline RangeFiltered<std::decay_t<F>, std::remove_reference_t<C>> createRangeFiltered(F && filter, C && container)
-{
-    return {std::forward<F>(filter), std::forward<C>(container)};
-};

From 2afbd8bceebeb4422009e4f48b3e6581a2737b3c Mon Sep 17 00:00:00 2001
From: Vitaliy Lyudvichenko <vludv@yandex-team.ru>
Date: Wed, 29 Nov 2017 14:54:37 +0300
Subject: [PATCH 005/107] Small enhancements. [#CLICKHOUSE-3452]

---
 .../MergeTree/MergeTreeDataMerger.cpp         |  2 +-
 .../Storages/System/StorageSystemParts.cpp    | 19 +++++++++++++++----
 2 files changed, 16 insertions(+), 5 deletions(-)

diff --git a/dbms/src/Storages/MergeTree/MergeTreeDataMerger.cpp b/dbms/src/Storages/MergeTree/MergeTreeDataMerger.cpp
index cc8094b8ee5..280e1cc30a6 100644
--- a/dbms/src/Storages/MergeTree/MergeTreeDataMerger.cpp
+++ b/dbms/src/Storages/MergeTree/MergeTreeDataMerger.cpp
@@ -187,7 +187,7 @@ bool MergeTreeDataMerger::selectPartsToMerge(
         if (prev_part && part->info.partition_id == (*prev_part)->info.partition_id
             && part->info.min_block < (*prev_part)->info.max_block)
         {
-            LOG_ERROR(log, "Part " << part->getNameWithState() << " intersects previous part " << (*prev_part)->getNameWithState());
+            LOG_ERROR(log, "Part " << part->name << " intersects previous part " << (*prev_part)->name);
         }
 
         prev_part = &part;
diff --git a/dbms/src/Storages/System/StorageSystemParts.cpp b/dbms/src/Storages/System/StorageSystemParts.cpp
index 02cad078f02..91c03f58b4b 100644
--- a/dbms/src/Storages/System/StorageSystemParts.cpp
+++ b/dbms/src/Storages/System/StorageSystemParts.cpp
@@ -53,11 +53,22 @@ BlockInputStreams StorageSystemParts::read(
     const size_t max_block_size,
     const unsigned num_streams)
 {
-    //check(column_names);
-    processed_stage = QueryProcessingStage::FetchColumns;
+    bool has_state_column = false;
+    Names real_column_names;
 
-    auto it_state_column = std::find(column_names.begin(), column_names.end(), "_state");
-    bool has_state_column = it_state_column != column_names.end();
+    for (const String & column_name : column_names)
+    {
+        if (column_name == "_state")
+            has_state_column = true;
+        else
+            real_column_names.emplace_back(column_name);
+    }
+
+    /// Do not check if only _state column is requested
+    if (!(has_state_column && real_column_names.empty()))
+        check(real_column_names);
+
+    processed_stage = QueryProcessingStage::FetchColumns;
 
     /// Will apply WHERE to subset of columns and then add more columns.
     /// This is kind of complicated, but we use WHERE to do less work.

From 616697f14f404e119aff317680ed57d144aed741 Mon Sep 17 00:00:00 2001
From: proller <proller@github.com>
Date: Tue, 21 Nov 2017 19:18:18 +0300
Subject: [PATCH 006/107] Zlib-ng: enable zlib compat mode (this fixes log
 compression) (#CLICKHOUSE-3447)

---
 cmake/find_zlib.cmake | 1 +
 1 file changed, 1 insertion(+)

diff --git a/cmake/find_zlib.cmake b/cmake/find_zlib.cmake
index bbfc75e5e24..93e62497c25 100644
--- a/cmake/find_zlib.cmake
+++ b/cmake/find_zlib.cmake
@@ -6,6 +6,7 @@ endif ()
 
 if (NOT ZLIB_FOUND)
     set (USE_INTERNAL_ZLIB_LIBRARY 1)
+    set (ZLIB_COMPAT 1) # for zlib-ng, also enables WITH_GZFILEOP
     set (ZLIB_INCLUDE_DIR "${ClickHouse_SOURCE_DIR}/contrib/libzlib-ng" "${ClickHouse_BINARY_DIR}/contrib/libzlib-ng") # generated zconf.h
     set (ZLIB_INCLUDE_DIRS ${ZLIB_INCLUDE_DIR}) # for poco
     set (ZLIB_FOUND 1) # for poco

From 8d3bc22fed080e20474df0e65c75fd0cad6deaa0 Mon Sep 17 00:00:00 2001
From: proller <proller@github.com>
Date: Tue, 21 Nov 2017 20:46:28 +0300
Subject: [PATCH 007/107] Zlib: as submodule, fix compile options; config: add
 logger options: logger.flush logger.rotateOnOpen

Conflicts:
	.gitmodules
	dbms/src/Common/BackgroundSchedulePool.h
---
 .gitmodules                       |  3 +++
 contrib/CMakeLists.txt            |  6 +++++-
 contrib/zlib-ng                   |  1 +
 libs/libdaemon/src/BaseDaemon.cpp | 24 ++++++++++++++----------
 4 files changed, 23 insertions(+), 11 deletions(-)
 create mode 160000 contrib/zlib-ng

diff --git a/.gitmodules b/.gitmodules
index 87f07998f35..fc08ca60275 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -13,3 +13,6 @@
 [submodule "contrib/librdkafka"]
 	path = contrib/librdkafka
 	url = https://github.com/edenhill/librdkafka.git
+[submodule "contrib/zlib-ng"]
+	path = contrib/zlib-ng
+	url = https://github.com/Dead2/zlib-ng.git
diff --git a/contrib/CMakeLists.txt b/contrib/CMakeLists.txt
index f21bee5d979..137eea988bc 100644
--- a/contrib/CMakeLists.txt
+++ b/contrib/CMakeLists.txt
@@ -45,7 +45,11 @@ if (USE_INTERNAL_UNWIND_LIBRARY)
 endif ()
 
 if (USE_INTERNAL_ZLIB_LIBRARY)
-    add_subdirectory (libzlib-ng)
+    add_subdirectory (zlib-ng)
+    # todo: make pull to Dead2/zlib-ng and remove:
+    # We should use same defines when including zlib.h as used when zlib compiled
+    target_compile_definitions (zlib PUBLIC ZLIB_COMPAT WITH_GZFILEOP)
+    target_compile_definitions (zlibstatic PUBLIC ZLIB_COMPAT WITH_GZFILEOP)
 endif ()
 
 if (USE_INTERNAL_CCTZ_LIBRARY)
diff --git a/contrib/zlib-ng b/contrib/zlib-ng
new file mode 160000
index 00000000000..e07a52dbaa3
--- /dev/null
+++ b/contrib/zlib-ng
@@ -0,0 +1 @@
+Subproject commit e07a52dbaa35d003f5659b221b29d220c091667b
diff --git a/libs/libdaemon/src/BaseDaemon.cpp b/libs/libdaemon/src/BaseDaemon.cpp
index bf6a0a778de..4b8f1e8d766 100644
--- a/libs/libdaemon/src/BaseDaemon.cpp
+++ b/libs/libdaemon/src/BaseDaemon.cpp
@@ -604,11 +604,13 @@ void BaseDaemon::buildLoggers()
         pf->setProperty("times", "local");
         Poco::AutoPtr<FormattingChannel> log = new FormattingChannel(pf);
         log_file = new FileChannel;
-        log_file->setProperty("path", Poco::Path(config().getString("logger.log")).absolute().toString());
-        log_file->setProperty("rotation", config().getRawString("logger.size", "100M"));
-        log_file->setProperty("archive", "number");
-        log_file->setProperty("compress", config().getRawString("logger.compress", "true"));
-        log_file->setProperty("purgeCount", config().getRawString("logger.count", "1"));
+        log_file->setProperty(Poco::FileChannel::PROP_PATH, Poco::Path(config().getString("logger.log")).absolute().toString());
+        log_file->setProperty(Poco::FileChannel::PROP_ROTATION, config().getRawString("logger.size", "100M"));
+        log_file->setProperty(Poco::FileChannel::PROP_ARCHIVE, "number");
+        log_file->setProperty(Poco::FileChannel::PROP_COMPRESS, config().getRawString("logger.compress", "true"));
+        log_file->setProperty(Poco::FileChannel::PROP_PURGECOUNT, config().getRawString("logger.count", "1"));
+        log_file->setProperty(Poco::FileChannel::PROP_FLUSH, config().getRawString("logger.flush", "true"));
+        log_file->setProperty(Poco::FileChannel::PROP_ROTATEONOPEN, config().getRawString("logger.rotateOnOpen", "false"));
         log->setChannel(log_file);
         split->addChannel(log);
         log_file->open();
@@ -622,11 +624,13 @@ void BaseDaemon::buildLoggers()
             pf->setProperty("times", "local");
             Poco::AutoPtr<FormattingChannel> errorlog = new FormattingChannel(pf);
             error_log_file = new FileChannel;
-            error_log_file->setProperty("path", Poco::Path(config().getString("logger.errorlog")).absolute().toString());
-            error_log_file->setProperty("rotation", config().getRawString("logger.size", "100M"));
-            error_log_file->setProperty("archive", "number");
-            error_log_file->setProperty("compress", config().getRawString("logger.compress", "true"));
-            error_log_file->setProperty("purgeCount", config().getRawString("logger.count", "1"));
+            error_log_file->setProperty(Poco::FileChannel::PROP_PATH, Poco::Path(config().getString("logger.errorlog")).absolute().toString());
+            error_log_file->setProperty(Poco::FileChannel::PROP_ROTATION, config().getRawString("logger.size", "100M"));
+            error_log_file->setProperty(Poco::FileChannel::PROP_ARCHIVE, "number");
+            error_log_file->setProperty(Poco::FileChannel::PROP_COMPRESS, config().getRawString("logger.compress", "true"));
+            error_log_file->setProperty(Poco::FileChannel::PROP_PURGECOUNT, config().getRawString("logger.count", "1"));
+            error_log_file->setProperty(Poco::FileChannel::PROP_FLUSH, config().getRawString("logger.flush", "true"));
+            error_log_file->setProperty(Poco::FileChannel::PROP_ROTATEONOPEN, config().getRawString("logger.rotateOnOpen", "false"));
             errorlog->setChannel(error_log_file);
             level->setChannel(errorlog);
             split->addChannel(level);

From 00d8ff3ced8d4f723ae1196b36f95b7dd16ecada Mon Sep 17 00:00:00 2001
From: proller <proller@github.com>
Date: Wed, 22 Nov 2017 00:21:22 +0300
Subject: [PATCH 008/107] Remove old contrib/libzlib-ng

---
 contrib/libzlib-ng/.gitignore                 |   52 -
 contrib/libzlib-ng/.travis.yml                |   12 -
 contrib/libzlib-ng/CMakeLists.txt             |  563 ----
 contrib/libzlib-ng/ChangeLog.zlib             | 1478 ----------
 contrib/libzlib-ng/FAQ.zlib                   |  374 ---
 contrib/libzlib-ng/INDEX                      |   55 -
 contrib/libzlib-ng/LICENSE.md                 |   19 -
 contrib/libzlib-ng/Makefile.in                |  329 ---
 contrib/libzlib-ng/README                     |   63 -
 contrib/libzlib-ng/README.clickhouse          |   12 -
 contrib/libzlib-ng/README.md                  |   65 -
 contrib/libzlib-ng/README.zlib                |  121 -
 contrib/libzlib-ng/adler32.c                  |  177 --
 contrib/libzlib-ng/arch/.gitignore            |    2 -
 contrib/libzlib-ng/arch/arm/Makefile.in       |   20 -
 contrib/libzlib-ng/arch/generic/Makefile.in   |   20 -
 contrib/libzlib-ng/arch/x86/INDEX             |    3 -
 contrib/libzlib-ng/arch/x86/Makefile.in       |   53 -
 contrib/libzlib-ng/arch/x86/crc_folding.c     |  465 ----
 contrib/libzlib-ng/arch/x86/deflate_quick.c   | 2371 -----------------
 contrib/libzlib-ng/arch/x86/fill_window_sse.c |  165 --
 .../libzlib-ng/arch/x86/insert_string_sse.c   |   50 -
 contrib/libzlib-ng/arch/x86/x86.c             |   53 -
 contrib/libzlib-ng/arch/x86/x86.h             |   23 -
 contrib/libzlib-ng/compress.c                 |   74 -
 contrib/libzlib-ng/configure                  |  923 -------
 contrib/libzlib-ng/crc32.c                    |  458 ----
 contrib/libzlib-ng/crc32.h                    |  444 ---
 contrib/libzlib-ng/deflate.c                  | 1407 ----------
 contrib/libzlib-ng/deflate.h                  |  459 ----
 contrib/libzlib-ng/deflate_fast.c             |  114 -
 contrib/libzlib-ng/deflate_medium.c           |  322 ---
 contrib/libzlib-ng/deflate_p.h                |   96 -
 contrib/libzlib-ng/deflate_slow.c             |  160 --
 contrib/libzlib-ng/doc/algorithm.txt          |  209 --
 contrib/libzlib-ng/doc/rfc1950.txt            |  619 -----
 contrib/libzlib-ng/doc/rfc1951.txt            |  955 -------
 contrib/libzlib-ng/doc/rfc1952.txt            |  675 -----
 contrib/libzlib-ng/doc/txtvsbin.txt           |  107 -
 contrib/libzlib-ng/gzclose.c                  |   23 -
 contrib/libzlib-ng/gzguts.h                   |  158 --
 contrib/libzlib-ng/gzlib.c                    |  518 ----
 contrib/libzlib-ng/gzread.c                   |  538 ----
 contrib/libzlib-ng/gzwrite.c                  |  457 ----
 contrib/libzlib-ng/infback.c                  |  612 -----
 contrib/libzlib-ng/inffast.c                  |  328 ---
 contrib/libzlib-ng/inffast.h                  |   15 -
 contrib/libzlib-ng/inffixed.h                 |   94 -
 contrib/libzlib-ng/inflate.c                  | 1467 ----------
 contrib/libzlib-ng/inflate.h                  |  127 -
 contrib/libzlib-ng/inftrees.c                 |  298 ---
 contrib/libzlib-ng/inftrees.h                 |   66 -
 contrib/libzlib-ng/match.c                    |  471 ----
 contrib/libzlib-ng/match.h                    |    6 -
 contrib/libzlib-ng/test/.gitignore            |    2 -
 contrib/libzlib-ng/test/CVE-2002-0059/test.gz |  Bin 4610 -> 0 bytes
 contrib/libzlib-ng/test/CVE-2003-0107.c       |   20 -
 contrib/libzlib-ng/test/CVE-2004-0797/test.gz |  Bin 52 -> 0 bytes
 contrib/libzlib-ng/test/CVE-2005-1849/test.gz |  Bin 52 -> 0 bytes
 contrib/libzlib-ng/test/CVE-2005-2096/test.gz |  Bin 52 -> 0 bytes
 contrib/libzlib-ng/test/INDEX                 |   10 -
 contrib/libzlib-ng/test/Makefile.in           |   77 -
 contrib/libzlib-ng/test/example.c             |  544 ----
 contrib/libzlib-ng/test/infcover.c            |  668 -----
 contrib/libzlib-ng/test/minigzip.c            |  530 ----
 contrib/libzlib-ng/test/testCVEinputs.sh      |   22 -
 contrib/libzlib-ng/treebuild.xml              |  116 -
 contrib/libzlib-ng/trees.c                    | 1119 --------
 contrib/libzlib-ng/trees.h                    |  132 -
 contrib/libzlib-ng/uncompr.c                  |   75 -
 contrib/libzlib-ng/win32/DLL_FAQ.txt          |  397 ---
 contrib/libzlib-ng/win32/Makefile.msc         |  154 --
 contrib/libzlib-ng/win32/README-WIN32.txt     |  103 -
 contrib/libzlib-ng/win32/VisualC.txt          |    3 -
 contrib/libzlib-ng/win32/zlib.def             |   55 -
 contrib/libzlib-ng/win32/zlib1.rc             |   40 -
 contrib/libzlib-ng/win32/zlibcompat.def       |   86 -
 contrib/libzlib-ng/zconf.h.in                 |  176 --
 contrib/libzlib-ng/zlib.3                     |  169 --
 contrib/libzlib-ng/zlib.3.pdf                 |  Bin 8734 -> 0 bytes
 contrib/libzlib-ng/zlib.h                     | 1728 ------------
 contrib/libzlib-ng/zlib.map                   |   83 -
 contrib/libzlib-ng/zlib.pc.cmakein            |   13 -
 contrib/libzlib-ng/zlib.pc.in                 |   13 -
 contrib/libzlib-ng/zutil.c                    |  124 -
 contrib/libzlib-ng/zutil.h                    |  185 --
 86 files changed, 25389 deletions(-)
 delete mode 100644 contrib/libzlib-ng/.gitignore
 delete mode 100644 contrib/libzlib-ng/.travis.yml
 delete mode 100644 contrib/libzlib-ng/CMakeLists.txt
 delete mode 100644 contrib/libzlib-ng/ChangeLog.zlib
 delete mode 100644 contrib/libzlib-ng/FAQ.zlib
 delete mode 100644 contrib/libzlib-ng/INDEX
 delete mode 100644 contrib/libzlib-ng/LICENSE.md
 delete mode 100644 contrib/libzlib-ng/Makefile.in
 delete mode 100644 contrib/libzlib-ng/README
 delete mode 100644 contrib/libzlib-ng/README.clickhouse
 delete mode 100644 contrib/libzlib-ng/README.md
 delete mode 100644 contrib/libzlib-ng/README.zlib
 delete mode 100644 contrib/libzlib-ng/adler32.c
 delete mode 100644 contrib/libzlib-ng/arch/.gitignore
 delete mode 100644 contrib/libzlib-ng/arch/arm/Makefile.in
 delete mode 100644 contrib/libzlib-ng/arch/generic/Makefile.in
 delete mode 100644 contrib/libzlib-ng/arch/x86/INDEX
 delete mode 100644 contrib/libzlib-ng/arch/x86/Makefile.in
 delete mode 100644 contrib/libzlib-ng/arch/x86/crc_folding.c
 delete mode 100644 contrib/libzlib-ng/arch/x86/deflate_quick.c
 delete mode 100644 contrib/libzlib-ng/arch/x86/fill_window_sse.c
 delete mode 100644 contrib/libzlib-ng/arch/x86/insert_string_sse.c
 delete mode 100644 contrib/libzlib-ng/arch/x86/x86.c
 delete mode 100644 contrib/libzlib-ng/arch/x86/x86.h
 delete mode 100644 contrib/libzlib-ng/compress.c
 delete mode 100755 contrib/libzlib-ng/configure
 delete mode 100644 contrib/libzlib-ng/crc32.c
 delete mode 100644 contrib/libzlib-ng/crc32.h
 delete mode 100644 contrib/libzlib-ng/deflate.c
 delete mode 100644 contrib/libzlib-ng/deflate.h
 delete mode 100644 contrib/libzlib-ng/deflate_fast.c
 delete mode 100644 contrib/libzlib-ng/deflate_medium.c
 delete mode 100644 contrib/libzlib-ng/deflate_p.h
 delete mode 100644 contrib/libzlib-ng/deflate_slow.c
 delete mode 100644 contrib/libzlib-ng/doc/algorithm.txt
 delete mode 100644 contrib/libzlib-ng/doc/rfc1950.txt
 delete mode 100644 contrib/libzlib-ng/doc/rfc1951.txt
 delete mode 100644 contrib/libzlib-ng/doc/rfc1952.txt
 delete mode 100644 contrib/libzlib-ng/doc/txtvsbin.txt
 delete mode 100644 contrib/libzlib-ng/gzclose.c
 delete mode 100644 contrib/libzlib-ng/gzguts.h
 delete mode 100644 contrib/libzlib-ng/gzlib.c
 delete mode 100644 contrib/libzlib-ng/gzread.c
 delete mode 100644 contrib/libzlib-ng/gzwrite.c
 delete mode 100644 contrib/libzlib-ng/infback.c
 delete mode 100644 contrib/libzlib-ng/inffast.c
 delete mode 100644 contrib/libzlib-ng/inffast.h
 delete mode 100644 contrib/libzlib-ng/inffixed.h
 delete mode 100644 contrib/libzlib-ng/inflate.c
 delete mode 100644 contrib/libzlib-ng/inflate.h
 delete mode 100644 contrib/libzlib-ng/inftrees.c
 delete mode 100644 contrib/libzlib-ng/inftrees.h
 delete mode 100644 contrib/libzlib-ng/match.c
 delete mode 100644 contrib/libzlib-ng/match.h
 delete mode 100644 contrib/libzlib-ng/test/.gitignore
 delete mode 100644 contrib/libzlib-ng/test/CVE-2002-0059/test.gz
 delete mode 100644 contrib/libzlib-ng/test/CVE-2003-0107.c
 delete mode 100644 contrib/libzlib-ng/test/CVE-2004-0797/test.gz
 delete mode 100644 contrib/libzlib-ng/test/CVE-2005-1849/test.gz
 delete mode 100644 contrib/libzlib-ng/test/CVE-2005-2096/test.gz
 delete mode 100644 contrib/libzlib-ng/test/INDEX
 delete mode 100644 contrib/libzlib-ng/test/Makefile.in
 delete mode 100644 contrib/libzlib-ng/test/example.c
 delete mode 100644 contrib/libzlib-ng/test/infcover.c
 delete mode 100644 contrib/libzlib-ng/test/minigzip.c
 delete mode 100755 contrib/libzlib-ng/test/testCVEinputs.sh
 delete mode 100644 contrib/libzlib-ng/treebuild.xml
 delete mode 100644 contrib/libzlib-ng/trees.c
 delete mode 100644 contrib/libzlib-ng/trees.h
 delete mode 100644 contrib/libzlib-ng/uncompr.c
 delete mode 100644 contrib/libzlib-ng/win32/DLL_FAQ.txt
 delete mode 100644 contrib/libzlib-ng/win32/Makefile.msc
 delete mode 100644 contrib/libzlib-ng/win32/README-WIN32.txt
 delete mode 100644 contrib/libzlib-ng/win32/VisualC.txt
 delete mode 100644 contrib/libzlib-ng/win32/zlib.def
 delete mode 100644 contrib/libzlib-ng/win32/zlib1.rc
 delete mode 100644 contrib/libzlib-ng/win32/zlibcompat.def
 delete mode 100644 contrib/libzlib-ng/zconf.h.in
 delete mode 100644 contrib/libzlib-ng/zlib.3
 delete mode 100644 contrib/libzlib-ng/zlib.3.pdf
 delete mode 100644 contrib/libzlib-ng/zlib.h
 delete mode 100644 contrib/libzlib-ng/zlib.map
 delete mode 100644 contrib/libzlib-ng/zlib.pc.cmakein
 delete mode 100644 contrib/libzlib-ng/zlib.pc.in
 delete mode 100644 contrib/libzlib-ng/zutil.c
 delete mode 100644 contrib/libzlib-ng/zutil.h

diff --git a/contrib/libzlib-ng/.gitignore b/contrib/libzlib-ng/.gitignore
deleted file mode 100644
index 0beb44b722a..00000000000
--- a/contrib/libzlib-ng/.gitignore
+++ /dev/null
@@ -1,52 +0,0 @@
-*.diff
-*.patch
-*.orig
-*.rej
-
-*~
-*.a
-*.lo
-*.o
-*.dylib
-
-*.gcda
-*.gcno
-*.gcov
-
-/example
-/example64
-/examplesh
-/libz.so*
-/minigzip
-/minigzip64
-/minigzipsh
-/zlib.pc
-/CVE-2003-0107
-
-.DS_Store
-*.obj
-*.exe
-*.pdb
-*.exp
-*.lib
-*.dll
-*.res
-foo.gz
-*.manifest
-
-CMakeCache.txt
-CMakeFiles
-Testing
-*.cmake
-*.stackdump
-zconf.h
-zconf.h.cmakein
-zconf.h.included
-ztest*
-
-configure.log
-a.out
-
-/arch/arm/Makefile
-/arch/generic/Makefile
-/arch/x86/Makefile
diff --git a/contrib/libzlib-ng/.travis.yml b/contrib/libzlib-ng/.travis.yml
deleted file mode 100644
index 6080169cf68..00000000000
--- a/contrib/libzlib-ng/.travis.yml
+++ /dev/null
@@ -1,12 +0,0 @@
-language: c
-compiler:
-  - gcc
-  - clang
-env:
-  - BUILDDIR=. TOOL="./configure --zlib-compat"
-  - BUILDDIR=../build TOOL="../zlib-ng/configure --zlib-compat"
-  - BUILDDIR=. TOOL="./configure --zlib-compat --without-optimizations --without-new-strategies"
-  - BUILDDIR=. TOOL="cmake ."
-  - BUILDDIR=../build TOOL="cmake ../zlib-ng"
-script: mkdir -p $BUILDDIR && cd $BUILDDIR &&
-        $TOOL && make && make test
diff --git a/contrib/libzlib-ng/CMakeLists.txt b/contrib/libzlib-ng/CMakeLists.txt
deleted file mode 100644
index 3d5be9eabf2..00000000000
--- a/contrib/libzlib-ng/CMakeLists.txt
+++ /dev/null
@@ -1,563 +0,0 @@
-cmake_minimum_required(VERSION 2.8.4)
-set(CMAKE_ALLOW_LOOSE_LOOP_CONSTRUCTS ON)
-
-project(zlib C)
-
-set(VERSION "1.2.8")
-
-set(INSTALL_BIN_DIR "${CMAKE_INSTALL_PREFIX}/bin" CACHE PATH "Installation directory for executables")
-set(INSTALL_LIB_DIR "${CMAKE_INSTALL_PREFIX}/lib" CACHE PATH "Installation directory for libraries")
-set(INSTALL_INC_DIR "${CMAKE_INSTALL_PREFIX}/include" CACHE PATH "Installation directory for headers")
-set(INSTALL_MAN_DIR "${CMAKE_INSTALL_PREFIX}/share/man" CACHE PATH "Installation directory for manual pages")
-set(INSTALL_PKGCONFIG_DIR "${CMAKE_INSTALL_PREFIX}/share/pkgconfig" CACHE PATH "Installation directory for pkgconfig (.pc) files")
-
-include(CheckTypeSize)
-include(CheckSymbolExists)
-include(CheckFunctionExists)
-include(CheckIncludeFile)
-include(CheckCSourceCompiles)
-include(CheckCSourceRuns)
-include(CheckLibraryExists)
-include(FeatureSummary)
-
-# make sure we use an appropriate BUILD_TYPE by default, "Release" to be exact
-# this should select the maximum generic optimisation on the current platform (i.e. -O3 for gcc/clang)
-if(NOT CMAKE_BUILD_TYPE)
-    set(CMAKE_BUILD_TYPE "Release" CACHE STRING
-        "Choose the type of build, standard options are: Debug Release RelWithDebInfo MinSizeRel."
-        FORCE)
-    add_feature_info(CMAKE_BUILD_TYPE 1 "Build type: ${CMAKE_BUILD_TYPE} (default)")
-else()
-    add_feature_info(CMAKE_BUILD_TYPE 1 "Build type: ${CMAKE_BUILD_TYPE} (selected)")
-endif()
-
-enable_testing()
-
-check_include_file(sys/types.h HAVE_SYS_TYPES_H)
-check_include_file(stdint.h    HAVE_STDINT_H)
-check_include_file(stddef.h    HAVE_STDDEF_H)
-
-#
-# Options parsing
-#
-set(ARCH ${CMAKE_HOST_SYSTEM_PROCESSOR})
-message(STATUS "Architecture: ${ARCH}")
-
-option (ZLIB_COMPAT "Compile with zlib compatible API" OFF)
-if (ZLIB_COMPAT)
-    add_definitions(-DZLIB_COMPAT)
-    set (WITH_GZFILEOP ON)
-endif (ZLIB_COMPAT)
-
-option (WITH_GZFILEOP "Compile with support for gzFile related functions" OFF)
-if (WITH_GZFILEOP)
-    add_definitions(-DWITH_GZFILEOP)
-endif (WITH_GZFILEOP)
-
-option(WITH_OPTIM "Build with optimisation" ON)
-option(WITH_NEW_QUICK_STRATEGY "Use new quick strategy for compression level 1" OFF) # this option produces corrupt gzip stream so turn it off for now.
-option(WITH_NEW_MEDIUM_STRATEGY "Use new medium strategy for compression levels 4-6" ON)
-option(WITH_NATIVE_INSTRUCTIONS
-    "Instruct the compiler to use the full instruction set on this host (gcc/clang -march=native)" OFF)
-
-if(${CMAKE_C_COMPILER} MATCHES "icc" OR ${CMAKE_C_COMPILER} MATCHES "icpc" OR ${CMAKE_C_COMPILER} MATCHES "icl")
-    if(WITH_NATIVE_INSTRUCTIONS)
-        message(STATUS "Ignoring WITH_NATIVE_INSTRUCTIONS; not supported on this configuration")
-    endif()
-    if(CMAKE_HOST_UNIX)
-        if(NOT SSE2FLAG)
-            set(SSE2FLAG "-msse2")
-        endif()
-        if(NOT SSE4FLAG)
-            set(SSE4FLAG "-msse4.2")
-        endif()
-    else()
-        if(NOT SSE2FLAG)
-            set(SSE2FLAG "/arch:SSE2")
-        endif()
-        if(NOT SSE4FLAG)
-            set(SSE4FLAG "/arch:SSE4.2")
-        endif()
-    endif()
-elseif(MSVC)
-    # TODO. ICC can be used through MSVC. I'm not sure if we'd ever see that combination
-    # (who'd use cmake from an IDE...) but checking for ICC before checking for MSVC should
-    # avoid mistakes.
-    # /Oi ?
-    if(NOT ${ARCH} MATCHES "AMD64")
-        set(SSE2FLAG "/arch:SSE2")
-    endif()
-    if(WITH_NATIVE_INSTRUCTIONS)
-        message(STATUS "Ignoring WITH_NATIVE_INSTRUCTIONS; not supported on this configuration")
-    endif()
-else()
-    execute_process(COMMAND ${CMAKE_C_COMPILER} --version OUTPUT_VARIABLE COMPILER_VERSION)
-    if("${COMPILER_VERSION}" MATCHES "gcc" OR "${COMPILER_VERSION}" MATCHES "clang")
-        set(__GNUC__ ON)
-    endif()
-    if(WITH_NATIVE_INSTRUCTIONS)
-        if(__GNUC__)
-            set(NATIVEFLAG "-march=native")
-        else()
-            message(STATUS "Ignoring WITH_NATIVE_INSTRUCTIONS; not implemented yet on this configuration")
-        endif()
-    endif()
-    if(NOT NATIVEFLAG)
-        if(NOT SSE2FLAG)
-            if(__GNUC__)
-                set(SSE2FLAG "-msse2")
-            endif()
-        endif()
-        if(NOT SSE4FLAG)
-            if(__GNUC__)
-                set(SSE4FLAG "-msse4")
-            endif()
-        endif()
-        if(NOT PCLMULFLAG)
-            if(__GNUC__)
-                set(PCLMULFLAG "-mpclmul")
-            endif()
-        endif()
-    else(NOT NATIVEFLAG)
-        set(SSE2FLAG ${NATIVEFLAG})
-        set(SSE4FLAG ${NATIVEFLAG})
-        set(PCLMULFLAG ${NATIVEFLAG})
-    endif(NOT NATIVEFLAG)
-endif()
-
-add_feature_info(ZLIB_COMPAT ZLIB_COMPAT "Provide a zlib-compatible API")
-add_feature_info(WITH_GZFILEOP WITH_GZFILEOP "Compile with support for gzFile-related functions")
-add_feature_info(WITH_OPTIM WITH_OPTIM "Build with optimisation")
-add_feature_info(WITH_NEW_QUICK_STRATEGY WITH_NEW_QUICK_STRATEGY "Use new quick strategy for compression level 1")
-add_feature_info(WITH_NEW_MEDIUM_STRATEGY WITH_NEW_MEDIUM_STRATEGY "Use new medium strategy for compression levels 4-6")
-
-#
-# Check to see if we have large file support
-#
-set(CMAKE_REQUIRED_DEFINITIONS -D_LARGEFILE64_SOURCE=1)
-# We add these other definitions here because CheckTypeSize.cmake
-# in CMake 2.4.x does not automatically do so and we want
-# compatibility with CMake 2.4.x.
-if(HAVE_SYS_TYPES_H)
-    list(APPEND CMAKE_REQUIRED_DEFINITIONS -DHAVE_SYS_TYPES_H)
-endif()
-if(HAVE_STDINT_H)
-    list(APPEND CMAKE_REQUIRED_DEFINITIONS -DHAVE_STDINT_H)
-endif()
-if(HAVE_STDDEF_H)
-    list(APPEND CMAKE_REQUIRED_DEFINITIONS -DHAVE_STDDEF_H)
-endif()
-check_type_size(off64_t OFF64_T)
-if(HAVE_OFF64_T)
-   add_definitions(-D_LARGEFILE64_SOURCE=1)
-else()
-   check_type_size(_off64_t _OFF64_T)
-   if (HAVE__OFF64_T)
-      add_definitions(-D_LARGEFILE64_SOURCE=1)
-   endif()
-endif()
-set(CMAKE_REQUIRED_DEFINITIONS) # clear variable
-
-#
-# Check for fseeko and other optional functions
-#
-check_function_exists(fseeko HAVE_FSEEKO)
-if(NOT HAVE_FSEEKO)
-    add_definitions(-DNO_FSEEKO)
-endif()
-check_function_exists(strerror HAVE_STRERROR)
-if(NOT HAVE_STRERROR)
-    add_definitions(-DNO_STRERROR)
-endif()
-
-#
-# Check for unistd.h and stdarg.h
-#
-check_include_file(unistd.h Z_HAVE_UNISTD_H)
-check_include_file(stdarg.h Z_HAVE_STDARG_H)
-
-#
-# Check if we can hide zlib internal symbols that are linked between separate source files using hidden
-#
-check_c_source_compiles(
-    "#define ZLIB_INTERNAL __attribute__((visibility (\"hidden\")))
-    int ZLIB_INTERNAL foo;
-    int main()
-    {
-      return 0;
-    }"
-    HAVE_ATTRIBUTE_VISIBILITY_HIDDEN FAIL_REGEX "not supported")
-if(HAVE_ATTRIBUTE_VISIBILITY_HIDDEN)
-    add_definitions(-DHAVE_HIDDEN)
-endif()
-
-#
-# Check if we can hide zlib internal symbols that are linked between separate source files using internal
-#
-check_c_source_compiles(
-    "#define ZLIB_INTERNAL __attribute__((visibility (\"internal\")))
-    int ZLIB_INTERNAL foo;
-    int main()
-    {
-      return 0;
-    }"
-    HAVE_ATTRIBUTE_VISIBILITY_INTERNAL FAIL_REGEX "not supported")
-if(HAVE_ATTRIBUTE_VISIBILITY_INTERNAL)
-    add_definitions(-DHAVE_INTERNAL)
-endif()
-
-#
-# check for __builtin_ctzl() support in the compiler
-#
-check_c_source_compiles(
-    "int main(void)
-    {
-        unsigned int zero = 0;
-        long test = __builtin_ctzl(zero);
-        (void)test;
-        return 0;
-    }"
-    HAVE_BUILTIN_CTZL
-)
-if(HAVE_BUILTIN_CTZL)
-    add_definitions(-DHAVE_BUILTIN_CTZL)
-endif()
-
-# Macro to check if source compiles when cross-compiling
-# or runs when compiling natively
-macro(check_c_source_compile_or_run source flag)
-    if(CMAKE_CROSSCOMPILING)
-        check_c_source_compiles("${source}" ${flag})
-    else()
-        check_c_source_runs("${source}" ${flag})
-    endif()
-endmacro(check_c_source_compile_or_run)
-if(MSVC)
-    set(CMAKE_DEBUG_POSTFIX "d")
-    add_definitions(-D_CRT_SECURE_NO_DEPRECATE)
-    add_definitions(-D_CRT_NONSTDC_NO_DEPRECATE)
-    include_directories(${CMAKE_CURRENT_SOURCE_DIR})
-else()
-    #
-    # not MSVC, so we need to check if we have the MS-style SSE etc. intrinsics
-    #
-    if(WITH_NATIVE_INSTRUCTIONS)
-        set(CMAKE_REQUIRED_FLAGS "${NATIVEFLAG}")
-    else()
-        set(CMAKE_REQUIRED_FLAGS "${SSE2FLAG}")
-    endif()
-    check_c_source_compile_or_run(
-        "#include <immintrin.h>
-        int main(void)
-        {
-            __m128i zero = _mm_setzero_si128();
-            (void)zero;
-            return 0;
-        }"
-        HAVE_SSE2_INTRIN
-    )
-    if(WITH_NATIVE_INSTRUCTIONS)
-        set(CMAKE_REQUIRED_FLAGS "${NATIVEFLAG}")
-    else()
-        # use the generic SSE4 enabler option to check for the SSE4.2 instruction we require:
-        set(CMAKE_REQUIRED_FLAGS "${SSE4FLAG}")
-    endif()
-    check_c_source_compile_or_run(
-        "int main(void)
-        {
-            unsigned val = 0, h = 0;
-            __asm__ __volatile__ ( \"crc32 %1,%0\" : \"+r\" (h) : \"r\" (val) );
-            return (int) h;
-        }"
-        HAVE_SSE42_INTRIN
-    )
-    if(WITH_NATIVE_INSTRUCTIONS)
-        set(CMAKE_REQUIRED_FLAGS "${NATIVEFLAG}")
-    else()
-        # the PCLMUL instruction we use also requires an SSE4.1 instruction check for both
-        set(CMAKE_REQUIRED_FLAGS "${SSE4FLAG} ${PCLMULFLAG}")
-    endif()
-    check_c_source_compile_or_run(
-        "#include <immintrin.h>
-        #include <smmintrin.h>
-        #include <wmmintrin.h>
-        int main(void)
-        {
-            __m128i a = _mm_setzero_si128();
-            __m128i b = _mm_setzero_si128();
-            __m128i c = _mm_clmulepi64_si128(a, b, 0x10);
-            int d = _mm_extract_epi32(c, 2);
-            return d;
-        }"
-        HAVE_PCLMULQDQ_INTRIN
-    )
-endif()
-
-#
-# Enable deflate_medium at level 4-6
-#
-if(WITH_NEW_MEDIUM_STRATEGY)
-    add_definitions(-DMEDIUM_STRATEGY)
-endif()
-
-#
-# macro to add either the given intrinsics option to the global compiler options,
-# or ${NATIVEFLAG} (-march=native) if that is appropriate and possible.
-# An alternative version of this macro would take a file argument, and set ${flag}
-# only for that file as opposed to ${NATIVEFLAG} globally, to limit side-effect of
-# using ${flag} globally.
-#
-macro(add_intrinsics_option flag)
-    if(WITH_NATIVE_INSTRUCTIONS AND NATIVEFLAG)
-        if (NOT "${CMAKE_C_FLAGS} " MATCHES ".*${NATIVEFLAG} .*")
-            set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${NATIVEFLAG}")
-        endif()
-    else()
-        if (NOT "${CMAKE_C_FLAGS} " MATCHES ".*${flag} .*")
-            set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${flag}")
-        endif()
-    endif()
-endmacro(add_intrinsics_option)
-
-set(ZLIB_ARCH_SRCS)
-set(ARCHDIR "arch/generic")
-if("${ARCH}" MATCHES "x86_64" OR "${ARCH}" MATCHES "AMD64")
-    set(ARCHDIR "arch/x86")
-    add_definitions(-DX86_64 -DX86_NOCHECK_SSE2 -DUNALIGNED_OK -DUNROLL_LESS -DX86_CPUID)
-    add_feature_info(SSE2 1 "Use the SSE2 instruction set, using \"${SSE2FLAG}\"")
-elseif("${ARCH}" MATCHES "arm" OR "${ARCH}" MATCHES "aarch64")
-    set(ARCHDIR "arch/arm")
-    add_definitions(-DUNALIGNED_OK -DUNROLL_LESS)
-else()
-    set(ARCHDIR "arch/x86")
-    add_definitions(-DX86 -DUNALIGNED_OK -DUNROLL_LESS -DX86_CPUID)
-    add_feature_info(SSE2 1 "Support the SSE2 instruction set, using \"${SSE2FLAG}\"")
-endif()
-if(WITH_OPTIM)
-    if(NOT CMAKE_SYSTEM_PROCESSOR MATCHES "arm" AND NOT CMAKE_SYSTEM_PROCESSOR MATCHES "aarch64")
-        set(ZLIB_ARCH_SRCS ${ZLIB_ARCH_SRCS} ${ARCHDIR}/x86.c)
-    endif()
-    if(HAVE_SSE42_INTRIN)
-        add_definitions(-DX86_SSE4_2_CRC_HASH)
-        set(ZLIB_ARCH_SRCS ${ZLIB_ARCH_SRCS} ${ARCHDIR}/insert_string_sse.c)
-        add_feature_info(SSE4_CRC 1 "Support CRC hash generation using the SSE4.2 instruction set, using \"${SSE4FLAG}\"")
-        add_intrinsics_option("${SSE4FLAG}")
-        if(WITH_NEW_QUICK_STRATEGY)
-            add_definitions(-DX86_QUICK_STRATEGY)
-            set(ZLIB_ARCH_SRCS ${ZLIB_ARCH_SRCS} ${ARCHDIR}/deflate_quick.c)
-            add_feature_info(SSE4DEFLATE 1 "Support SSE4.2-accelerated quick decompression")
-        endif()
-    endif()
-    if(HAVE_SSE2_INTRIN)
-        add_definitions(-DX86_SSE2_FILL_WINDOW)
-        set(ZLIB_ARCH_SRCS ${ZLIB_ARCH_SRCS} ${ARCHDIR}/fill_window_sse.c)
-        if(NOT ${ARCH} MATCHES "x86_64")
-            add_intrinsics_option("${SSE2FLAG}")
-        endif()
-    endif()
-    if(HAVE_PCLMULQDQ_INTRIN)
-        if (CMAKE_SYSTEM_PROCESSOR MATCHES "^x86")
-            add_definitions(-DX86_PCLMULQDQ_CRC)
-        endif()
-        set(ZLIB_ARCH_SRCS ${ZLIB_ARCH_SRCS} ${ARCHDIR}/crc_folding.c)
-        add_feature_info(PCLMUL_CRC 1 "Support CRC hash generation using PCLMULQDQ, using \"${SSE4FLAG} ${PCLMULFLAG}\"")
-        add_intrinsics_option("${PCLMULFLAG}")
-        if(NOT HAVE_SSE42_INTRIN)
-            add_intrinsics_option("${SSE4FLAG}")
-        endif()
-    endif()
-endif()
-message(STATUS "Architecture-specific source files: ${ZLIB_ARCH_SRCS}")
-
-#============================================================================
-# zconf.h
-#============================================================================
-
-macro(generate_cmakein input output)
-    execute_process(COMMAND sed "/#define ZCONF_H/ a\\\n#cmakedefine Z_HAVE_UNISTD_H\\\n#cmakedefine Z_HAVE_STDARG_H\n"
-                    INPUT_FILE ${input}
-                    OUTPUT_FILE ${output}
-)
-
-endmacro(generate_cmakein)
-
-generate_cmakein( ${CMAKE_CURRENT_SOURCE_DIR}/zconf.h.in ${CMAKE_CURRENT_BINARY_DIR}/zconf.h.cmakein )
-
-if(NOT CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_CURRENT_BINARY_DIR)
-    # If we're doing an out of source build and the user has a zconf.h
-    # in their source tree...
-    if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/zconf.h)
-        message(STATUS "Renaming")
-        message(STATUS "    ${CMAKE_CURRENT_SOURCE_DIR}/zconf.h")
-        message(STATUS "to 'zconf.h.included' because this file is included with zlib")
-        message(STATUS "but CMake generates it automatically in the build directory.")
-        file(RENAME ${CMAKE_CURRENT_SOURCE_DIR}/zconf.h ${CMAKE_CURRENT_SOURCE_DIR}/zconf.h.included)
-    endif()
-
-    # If we're doing an out of source build and the user has a zconf.h.cmakein
-    # in their source tree...
-    if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/zconf.h.cmakein)
-        message(STATUS "Renaming")
-        message(STATUS "    ${CMAKE_CURRENT_SOURCE_DIR}/zconf.h.cmakein")
-        message(STATUS "to 'zconf.h.cmakeincluded' because this file is included with zlib")
-        message(STATUS "but CMake generates it automatically in the build directory.")
-        file(RENAME ${CMAKE_CURRENT_SOURCE_DIR}/zconf.h.cmakein ${CMAKE_CURRENT_SOURCE_DIR}/zconf.h.cmakeincluded)
-    endif()
-endif()
-
-set(ZLIB_PC ${CMAKE_CURRENT_BINARY_DIR}/zlib.pc)
-configure_file( ${CMAKE_CURRENT_SOURCE_DIR}/zlib.pc.cmakein
-		${ZLIB_PC} @ONLY)
-configure_file(	${CMAKE_CURRENT_BINARY_DIR}/zconf.h.cmakein
-		${CMAKE_CURRENT_BINARY_DIR}/zconf.h @ONLY)
-include_directories(${CMAKE_CURRENT_BINARY_DIR} ${CMAKE_CURRENT_SOURCE_DIR})
-
-
-#============================================================================
-# zlib
-#============================================================================
-
-set(ZLIB_PUBLIC_HDRS
-    ${CMAKE_CURRENT_BINARY_DIR}/zconf.h
-    zlib.h
-)
-set(ZLIB_PRIVATE_HDRS
-    crc32.h
-    deflate.h
-    gzguts.h
-    inffast.h
-    inffixed.h
-    inflate.h
-    inftrees.h
-    trees.h
-    zutil.h
-)
-set(ZLIB_SRCS
-    adler32.c
-    compress.c
-    crc32.c
-    deflate.c
-    deflate_fast.c
-    deflate_medium.c
-    deflate_slow.c
-    inflate.c
-    infback.c
-    inftrees.c
-    inffast.c
-    match.c
-    trees.c
-    uncompr.c
-    zutil.c
-)
-if (WITH_GZFILEOP)
-    set(ZLIB_GZFILE_SRCS
-        gzclose.c
-        gzlib.c
-        gzread.c
-        gzwrite.c
-    )
-else (WITH_GZFILEOP)
-    set(ZLIB_GZFILE_SRCS
-    )
-endif (WITH_GZFILEOP)
-
-
-if(NOT MINGW AND NOT MSYS)
-    set(ZLIB_DLL_SRCS
-        win32/zlib1.rc # If present will override custom build rule below.
-    )
-endif()
-
-# parse the full version number from zlib.h and include in ZLIB_FULL_VERSION
-file(READ ${CMAKE_CURRENT_SOURCE_DIR}/zlib.h _zlib_h_contents)
-string(REGEX REPLACE ".*#define[ \t]+ZLIB_VERSION[ \t]+\"([-0-9A-Za-z.]+)\".*"
-    "\\1" ZLIB_FULL_VERSION ${_zlib_h_contents})
-
-if(MINGW OR MSYS)
-    # This gets us DLL resource information when compiling on MinGW.
-    if(NOT CMAKE_RC_COMPILER)
-        set(CMAKE_RC_COMPILER windres.exe)
-    endif()
-
-    add_custom_command(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/zlib1rc.obj
-                       COMMAND ${CMAKE_RC_COMPILER}
-                            -D GCC_WINDRES
-                            -I ${CMAKE_CURRENT_SOURCE_DIR}
-                            -I ${CMAKE_CURRENT_BINARY_DIR}
-                            -o ${CMAKE_CURRENT_BINARY_DIR}/zlib1rc.obj
-                            -i ${CMAKE_CURRENT_SOURCE_DIR}/win32/zlib1.rc)
-    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")
-endif()
-
-if(NOT SKIP_INSTALL_LIBRARIES AND NOT SKIP_INSTALL_ALL )
-    install(TARGETS zlib zlibstatic
-        RUNTIME DESTINATION "${INSTALL_BIN_DIR}"
-        ARCHIVE DESTINATION "${INSTALL_LIB_DIR}"
-        LIBRARY DESTINATION "${INSTALL_LIB_DIR}" )
-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()
diff --git a/contrib/libzlib-ng/ChangeLog.zlib b/contrib/libzlib-ng/ChangeLog.zlib
deleted file mode 100644
index 909d11f9b47..00000000000
--- a/contrib/libzlib-ng/ChangeLog.zlib
+++ /dev/null
@@ -1,1478 +0,0 @@
-## 
-# THIS IS AN UNMAINTAINED COPY OF THE ORIGINAL FILE DISTRIBUTED WITH ZLIB 1.2.8
-## 
-
-
-
-
-                ChangeLog file for zlib
-
-Changes in 1.2.8 (28 Apr 2013)
-- Update contrib/minizip/iowin32.c for Windows RT [Vollant]
-- Do not force Z_CONST for C++
-- Clean up contrib/vstudio [Roß]
-- Correct spelling error in zlib.h
-- Fix mixed line endings in contrib/vstudio
-
-Changes in 1.2.7.3 (13 Apr 2013)
-- Fix version numbers and DLL names in contrib/vstudio/*/zlib.rc
-
-Changes in 1.2.7.2 (13 Apr 2013)
-- Change check for a four-byte type back to hexadecimal
-- Fix typo in win32/Makefile.msc
-- Add casts in gzwrite.c for pointer differences
-
-Changes in 1.2.7.1 (24 Mar 2013)
-- Replace use of unsafe string functions with snprintf if available
-- Avoid including stddef.h on Windows for Z_SOLO compile [Niessink]
-- Fix gzgetc undefine when Z_PREFIX set [Turk]
-- Eliminate use of mktemp in Makefile (not always available)
-- Fix bug in 'F' mode for gzopen()
-- Add inflateGetDictionary() function
-- Correct comment in deflate.h
-- Use _snprintf for snprintf in Microsoft C
-- On Darwin, only use /usr/bin/libtool if libtool is not Apple
-- Delete "--version" file if created by "ar --version" [Richard G.]
-- Fix configure check for veracity of compiler error return codes
-- Fix CMake compilation of static lib for MSVC2010 x64
-- Remove unused variable in infback9.c
-- Fix argument checks in gzlog_compress() and gzlog_write()
-- Clean up the usage of z_const and respect const usage within zlib
-- Clean up examples/gzlog.[ch] comparisons of different types
-- Avoid shift equal to bits in type (caused endless loop)
-- Fix uninitialized value bug in gzputc() introduced by const patches
-- Fix memory allocation error in examples/zran.c [Nor]
-- Fix bug where gzopen(), gzclose() would write an empty file
-- Fix bug in gzclose() when gzwrite() runs out of memory
-- Check for input buffer malloc failure in examples/gzappend.c
-- Add note to contrib/blast to use binary mode in stdio
-- Fix comparisons of differently signed integers in contrib/blast
-- Check for invalid code length codes in contrib/puff
-- Fix serious but very rare decompression bug in inftrees.c
-- Update inflateBack() comments, since inflate() can be faster
-- Use underscored I/O function names for WINAPI_FAMILY
-- Add _tr_flush_bits to the external symbols prefixed by --zprefix
-- Add contrib/vstudio/vc10 pre-build step for static only
-- Quote --version-script argument in CMakeLists.txt
-- Don't specify --version-script on Apple platforms in CMakeLists.txt
-- Fix casting error in contrib/testzlib/testzlib.c
-- Fix types in contrib/minizip to match result of get_crc_table()
-- Simplify contrib/vstudio/vc10 with 'd' suffix
-- Add TOP support to win32/Makefile.msc
-- Suport i686 and amd64 assembler builds in CMakeLists.txt
-- Fix typos in the use of _LARGEFILE64_SOURCE in zconf.h
-- Add vc11 and vc12 build files to contrib/vstudio
-- Add gzvprintf() as an undocumented function in zlib
-- Fix configure for Sun shell
-- Remove runtime check in configure for four-byte integer type
-- Add casts and consts to ease user conversion to C++
-- Add man pages for minizip and miniunzip
-- In Makefile uninstall, don't rm if preceding cd fails
-- Do not return Z_BUF_ERROR if deflateParam() has nothing to write
-
-Changes in 1.2.7 (2 May 2012)
-- Replace use of memmove() with a simple copy for portability
-- Test for existence of strerror
-- Restore gzgetc_ for backward compatibility with 1.2.6
-- Fix build with non-GNU make on Solaris
-- Require gcc 4.0 or later on Mac OS X to use the hidden attribute
-- Include unistd.h for Watcom C
-- Use __WATCOMC__ instead of __WATCOM__
-- Do not use the visibility attribute if NO_VIZ defined
-- Improve the detection of no hidden visibility attribute
-- Avoid using __int64 for gcc or solo compilation
-- Cast to char * in gzprintf to avoid warnings [Zinser]
-- Fix make_vms.com for VAX [Zinser]
-- Don't use library or built-in byte swaps
-- Simplify test and use of gcc hidden attribute
-- Fix bug in gzclose_w() when gzwrite() fails to allocate memory
-- Add "x" (O_EXCL) and "e" (O_CLOEXEC) modes support to gzopen()
-- Fix bug in test/minigzip.c for configure --solo
-- Fix contrib/vstudio project link errors [Mohanathas]
-- Add ability to choose the builder in make_vms.com [Schweda]
-- Add DESTDIR support to mingw32 win32/Makefile.gcc
-- Fix comments in win32/Makefile.gcc for proper usage
-- Allow overriding the default install locations for cmake
-- Generate and install the pkg-config file with cmake
-- Build both a static and a shared version of zlib with cmake
-- Include version symbols for cmake builds
-- If using cmake with MSVC, add the source directory to the includes
-- Remove unneeded EXTRA_CFLAGS from win32/Makefile.gcc [Truta]
-- Move obsolete emx makefile to old [Truta]
-- Allow the use of -Wundef when compiling or using zlib
-- Avoid the use of the -u option with mktemp
-- Improve inflate() documentation on the use of Z_FINISH
-- Recognize clang as gcc
-- Add gzopen_w() in Windows for wide character path names
-- Rename zconf.h in CMakeLists.txt to move it out of the way
-- Add source directory in CMakeLists.txt for building examples
-- Look in build directory for zlib.pc in CMakeLists.txt
-- Remove gzflags from zlibvc.def in vc9 and vc10
-- Fix contrib/minizip compilation in the MinGW environment
-- Update ./configure for Solaris, support --64 [Mooney]
-- Remove -R. from Solaris shared build (possible security issue)
-- Avoid race condition for parallel make (-j) running example
-- Fix type mismatch between get_crc_table() and crc_table
-- Fix parsing of version with "-" in CMakeLists.txt [Snider, Ziegler]
-- Fix the path to zlib.map in CMakeLists.txt
-- Force the native libtool in Mac OS X to avoid GNU libtool [Beebe]
-- Add instructions to win32/Makefile.gcc for shared install [Torri]
-
-Changes in 1.2.6.1 (12 Feb 2012)
-- Avoid the use of the Objective-C reserved name "id"
-- Include io.h in gzguts.h for Microsoft compilers
-- Fix problem with ./configure --prefix and gzgetc macro
-- Include gz_header definition when compiling zlib solo
-- Put gzflags() functionality back in zutil.c
-- Avoid library header include in crc32.c for Z_SOLO
-- Use name in GCC_CLASSIC as C compiler for coverage testing, if set
-- Minor cleanup in contrib/minizip/zip.c [Vollant]
-- Update make_vms.com [Zinser]
-- Remove unnecessary gzgetc_ function
-- Use optimized byte swap operations for Microsoft and GNU [Snyder]
-- Fix minor typo in zlib.h comments [Rzesniowiecki]
-
-Changes in 1.2.6 (29 Jan 2012)
-- Update the Pascal interface in contrib/pascal
-- Fix function numbers for gzgetc_ in zlibvc.def files
-- Fix configure.ac for contrib/minizip [Schiffer]
-- Fix large-entry detection in minizip on 64-bit systems [Schiffer]
-- Have ./configure use the compiler return code for error indication
-- Fix CMakeLists.txt for cross compilation [McClure]
-- Fix contrib/minizip/zip.c for 64-bit architectures [Dalsnes]
-- Fix compilation of contrib/minizip on FreeBSD [Marquez]
-- Correct suggested usages in win32/Makefile.msc [Shachar, Horvath]
-- Include io.h for Turbo C / Borland C on all platforms [Truta]
-- Make version explicit in contrib/minizip/configure.ac [Bosmans]
-- Avoid warning for no encryption in contrib/minizip/zip.c [Vollant]
-- Minor cleanup up contrib/minizip/unzip.c [Vollant]
-- Fix bug when compiling minizip with C++ [Vollant]
-- Protect for long name and extra fields in contrib/minizip [Vollant]
-- Avoid some warnings in contrib/minizip [Vollant]
-- Add -I../.. -L../.. to CFLAGS for minizip and miniunzip
-- Add missing libs to minizip linker command
-- Add support for VPATH builds in contrib/minizip
-- Add an --enable-demos option to contrib/minizip/configure
-- Add the generation of configure.log by ./configure
-- Exit when required parameters not provided to win32/Makefile.gcc
-- Have gzputc return the character written instead of the argument
-- Use the -m option on ldconfig for BSD systems [Tobias]
-- Correct in zlib.map when deflateResetKeep was added
-
-Changes in 1.2.5.3 (15 Jan 2012)
-- Restore gzgetc function for binary compatibility
-- Do not use _lseeki64 under Borland C++ [Truta]
-- Update win32/Makefile.msc to build test/*.c [Truta]
-- Remove old/visualc6 given CMakefile and other alternatives
-- Update AS400 build files and documentation [Monnerat]
-- Update win32/Makefile.gcc to build test/*.c [Truta]
-- Permit stronger flushes after Z_BLOCK flushes
-- Avoid extraneous empty blocks when doing empty flushes
-- Permit Z_NULL arguments to deflatePending
-- Allow deflatePrime() to insert bits in the middle of a stream
-- Remove second empty static block for Z_PARTIAL_FLUSH
-- Write out all of the available bits when using Z_BLOCK
-- Insert the first two strings in the hash table after a flush
-
-Changes in 1.2.5.2 (17 Dec 2011)
-- fix ld error: unable to find version dependency 'ZLIB_1.2.5'
-- use relative symlinks for shared libs
-- Avoid searching past window for Z_RLE strategy
-- Assure that high-water mark initialization is always applied in deflate
-- Add assertions to fill_window() in deflate.c to match comments
-- Update python link in README
-- Correct spelling error in gzread.c
-- Fix bug in gzgets() for a concatenated empty gzip stream
-- Correct error in comment for gz_make()
-- Change gzread() and related to ignore junk after gzip streams
-- Allow gzread() and related to continue after gzclearerr()
-- Allow gzrewind() and gzseek() after a premature end-of-file
-- Simplify gzseek() now that raw after gzip is ignored
-- Change gzgetc() to a macro for speed (~40% speedup in testing)
-- Fix gzclose() to return the actual error last encountered
-- Always add large file support for windows
-- Include zconf.h for windows large file support
-- Include zconf.h.cmakein for windows large file support
-- Update zconf.h.cmakein on make distclean
-- Merge vestigial vsnprintf determination from zutil.h to gzguts.h
-- Clarify how gzopen() appends in zlib.h comments
-- Correct documentation of gzdirect() since junk at end now ignored
-- Add a transparent write mode to gzopen() when 'T' is in the mode
-- Update python link in zlib man page
-- Get inffixed.h and MAKEFIXED result to match
-- Add a ./config --solo option to make zlib subset with no libary use
-- Add undocumented inflateResetKeep() function for CAB file decoding
-- Add --cover option to ./configure for gcc coverage testing
-- Add #define ZLIB_CONST option to use const in the z_stream interface
-- Add comment to gzdopen() in zlib.h to use dup() when using fileno()
-- Note behavior of uncompress() to provide as much data as it can
-- Add files in contrib/minizip to aid in building libminizip
-- Split off AR options in Makefile.in and configure
-- Change ON macro to Z_ARG to avoid application conflicts
-- Facilitate compilation with Borland C++ for pragmas and vsnprintf
-- Include io.h for Turbo C / Borland C++
-- Move example.c and minigzip.c to test/
-- Simplify incomplete code table filling in inflate_table()
-- Remove code from inflate.c and infback.c that is impossible to execute
-- Test the inflate code with full coverage
-- Allow deflateSetDictionary, inflateSetDictionary at any time (in raw)
-- Add deflateResetKeep and fix inflateResetKeep to retain dictionary
-- Fix gzwrite.c to accommodate reduced memory zlib compilation
-- Have inflate() with Z_FINISH avoid the allocation of a window
-- Do not set strm->adler when doing raw inflate
-- Fix gzeof() to behave just like feof() when read is not past end of file
-- Fix bug in gzread.c when end-of-file is reached
-- Avoid use of Z_BUF_ERROR in gz* functions except for premature EOF
-- Document gzread() capability to read concurrently written files
-- Remove hard-coding of resource compiler in CMakeLists.txt [Blammo]
-
-Changes in 1.2.5.1 (10 Sep 2011)
-- Update FAQ entry on shared builds (#13)
-- Avoid symbolic argument to chmod in Makefile.in
-- Fix bug and add consts in contrib/puff [Oberhumer]
-- Update contrib/puff/zeros.raw test file to have all block types
-- Add full coverage test for puff in contrib/puff/Makefile
-- Fix static-only-build install in Makefile.in
-- Fix bug in unzGetCurrentFileInfo() in contrib/minizip [Kuno]
-- Add libz.a dependency to shared in Makefile.in for parallel builds
-- Spell out "number" (instead of "nb") in zlib.h for total_in, total_out
-- Replace $(...) with `...` in configure for non-bash sh [Bowler]
-- Add darwin* to Darwin* and solaris* to SunOS\ 5* in configure [Groffen]
-- Add solaris* to Linux* in configure to allow gcc use [Groffen]
-- Add *bsd* to Linux* case in configure [Bar-Lev]
-- Add inffast.obj to dependencies in win32/Makefile.msc
-- Correct spelling error in deflate.h [Kohler]
-- Change libzdll.a again to libz.dll.a (!) in win32/Makefile.gcc
-- Add test to configure for GNU C looking for gcc in output of $cc -v
-- Add zlib.pc generation to win32/Makefile.gcc [Weigelt]
-- Fix bug in zlib.h for _FILE_OFFSET_BITS set and _LARGEFILE64_SOURCE not
-- Add comment in zlib.h that adler32_combine with len2 < 0 makes no sense
-- Make NO_DIVIDE option in adler32.c much faster (thanks to John Reiser)
-- Make stronger test in zconf.h to include unistd.h for LFS
-- Apply Darwin patches for 64-bit file offsets to contrib/minizip [Slack]
-- Fix zlib.h LFS support when Z_PREFIX used
-- Add updated as400 support (removed from old) [Monnerat]
-- Avoid deflate sensitivity to volatile input data
-- Avoid division in adler32_combine for NO_DIVIDE
-- Clarify the use of Z_FINISH with deflateBound() amount of space
-- Set binary for output file in puff.c
-- Use u4 type for crc_table to avoid conversion warnings
-- Apply casts in zlib.h to avoid conversion warnings
-- Add OF to prototypes for adler32_combine_ and crc32_combine_ [Miller]
-- Improve inflateSync() documentation to note indeterminancy
-- Add deflatePending() function to return the amount of pending output
-- Correct the spelling of "specification" in FAQ [Randers-Pehrson]
-- Add a check in configure for stdarg.h, use for gzprintf()
-- Check that pointers fit in ints when gzprint() compiled old style
-- Add dummy name before $(SHAREDLIBV) in Makefile [Bar-Lev, Bowler]
-- Delete line in configure that adds -L. libz.a to LDFLAGS [Weigelt]
-- Add debug records in assmebler code [Londer]
-- Update RFC references to use http://tools.ietf.org/html/... [Li]
-- Add --archs option, use of libtool to configure for Mac OS X [Borstel]
-
-Changes in 1.2.5 (19 Apr 2010)
-- Disable visibility attribute in win32/Makefile.gcc [Bar-Lev]
-- Default to libdir as sharedlibdir in configure [Nieder]
-- Update copyright dates on modified source files
-- Update trees.c to be able to generate modified trees.h
-- Exit configure for MinGW, suggesting win32/Makefile.gcc
-- Check for NULL path in gz_open [Homurlu]
-
-Changes in 1.2.4.5 (18 Apr 2010)
-- Set sharedlibdir in configure [Torok]
-- Set LDFLAGS in Makefile.in [Bar-Lev]
-- Avoid mkdir objs race condition in Makefile.in [Bowler]
-- Add ZLIB_INTERNAL in front of internal inter-module functions and arrays
-- Define ZLIB_INTERNAL to hide internal functions and arrays for GNU C
-- Don't use hidden attribute when it is a warning generator (e.g. Solaris)
-
-Changes in 1.2.4.4 (18 Apr 2010)
-- Fix CROSS_PREFIX executable testing, CHOST extract, mingw* [Torok]
-- Undefine _LARGEFILE64_SOURCE in zconf.h if it is zero, but not if empty
-- Try to use bash or ksh regardless of functionality of /bin/sh
-- Fix configure incompatibility with NetBSD sh
-- Remove attempt to run under bash or ksh since have better NetBSD fix
-- Fix win32/Makefile.gcc for MinGW [Bar-Lev]
-- Add diagnostic messages when using CROSS_PREFIX in configure
-- Added --sharedlibdir option to configure [Weigelt]
-- Use hidden visibility attribute when available [Frysinger]
-
-Changes in 1.2.4.3 (10 Apr 2010)
-- Only use CROSS_PREFIX in configure for ar and ranlib if they exist
-- Use CROSS_PREFIX for nm [Bar-Lev]
-- Assume _LARGEFILE64_SOURCE defined is equivalent to true
-- Avoid use of undefined symbols in #if with && and ||
-- Make *64 prototypes in gzguts.h consistent with functions
-- Add -shared load option for MinGW in configure [Bowler]
-- Move z_off64_t to public interface, use instead of off64_t
-- Remove ! from shell test in configure (not portable to Solaris)
-- Change +0 macro tests to -0 for possibly increased portability
-
-Changes in 1.2.4.2 (9 Apr 2010)
-- Add consistent carriage returns to readme.txt's in masmx86 and masmx64
-- Really provide prototypes for *64 functions when building without LFS
-- Only define unlink() in minigzip.c if unistd.h not included
-- Update README to point to contrib/vstudio project files
-- Move projects/vc6 to old/ and remove projects/
-- Include stdlib.h in minigzip.c for setmode() definition under WinCE
-- Clean up assembler builds in win32/Makefile.msc [Rowe]
-- Include sys/types.h for Microsoft for off_t definition
-- Fix memory leak on error in gz_open()
-- Symbolize nm as $NM in configure [Weigelt]
-- Use TEST_LDSHARED instead of LDSHARED to link test programs [Weigelt]
-- Add +0 to _FILE_OFFSET_BITS and _LFS64_LARGEFILE in case not defined
-- Fix bug in gzeof() to take into account unused input data
-- Avoid initialization of structures with variables in puff.c
-- Updated win32/README-WIN32.txt [Rowe]
-
-Changes in 1.2.4.1 (28 Mar 2010)
-- Remove the use of [a-z] constructs for sed in configure [gentoo 310225]
-- Remove $(SHAREDLIB) from LIBS in Makefile.in [Creech]
-- Restore "for debugging" comment on sprintf() in gzlib.c
-- Remove fdopen for MVS from gzguts.h
-- Put new README-WIN32.txt in win32 [Rowe]
-- Add check for shell to configure and invoke another shell if needed
-- Fix big fat stinking bug in gzseek() on uncompressed files
-- Remove vestigial F_OPEN64 define in zutil.h
-- Set and check the value of _LARGEFILE_SOURCE and _LARGEFILE64_SOURCE
-- Avoid errors on non-LFS systems when applications define LFS macros
-- Set EXE to ".exe" in configure for MINGW [Kahle]
-- Match crc32() in crc32.c exactly to the prototype in zlib.h [Sherrill]
-- Add prefix for cross-compilation in win32/makefile.gcc [Bar-Lev]
-- Add DLL install in win32/makefile.gcc [Bar-Lev]
-- Allow Linux* or linux* from uname in configure [Bar-Lev]
-- Allow ldconfig to be redefined in configure and Makefile.in [Bar-Lev]
-- Add cross-compilation prefixes to configure [Bar-Lev]
-- Match type exactly in gz_load() invocation in gzread.c
-- Match type exactly of zcalloc() in zutil.c to zlib.h alloc_func
-- Provide prototypes for *64 functions when building zlib without LFS
-- Don't use -lc when linking shared library on MinGW
-- Remove errno.h check in configure and vestigial errno code in zutil.h
-
-Changes in 1.2.4 (14 Mar 2010)
-- Fix VER3 extraction in configure for no fourth subversion
-- Update zlib.3, add docs to Makefile.in to make .pdf out of it
-- Add zlib.3.pdf to distribution
-- Don't set error code in gzerror() if passed pointer is NULL
-- Apply destination directory fixes to CMakeLists.txt [Lowman]
-- Move #cmakedefine's to a new zconf.in.cmakein
-- Restore zconf.h for builds that don't use configure or cmake
-- Add distclean to dummy Makefile for convenience
-- Update and improve INDEX, README, and FAQ
-- Update CMakeLists.txt for the return of zconf.h [Lowman]
-- Update contrib/vstudio/vc9 and vc10 [Vollant]
-- Change libz.dll.a back to libzdll.a in win32/Makefile.gcc
-- Apply license and readme changes to contrib/asm686 [Raiter]
-- Check file name lengths and add -c option in minigzip.c [Li]
-- Update contrib/amd64 and contrib/masmx86/ [Vollant]
-- Avoid use of "eof" parameter in trees.c to not shadow library variable
-- Update make_vms.com for removal of zlibdefs.h [Zinser]
-- Update assembler code and vstudio projects in contrib [Vollant]
-- Remove outdated assembler code contrib/masm686 and contrib/asm586
-- Remove old vc7 and vc8 from contrib/vstudio
-- Update win32/Makefile.msc, add ZLIB_VER_SUBREVISION [Rowe]
-- Fix memory leaks in gzclose_r() and gzclose_w(), file leak in gz_open()
-- Add contrib/gcc_gvmat64 for longest_match and inflate_fast [Vollant]
-- Remove *64 functions from win32/zlib.def (they're not 64-bit yet)
-- Fix bug in void-returning vsprintf() case in gzwrite.c
-- Fix name change from inflate.h in contrib/inflate86/inffas86.c
-- Check if temporary file exists before removing in make_vms.com [Zinser]
-- Fix make install and uninstall for --static option
-- Fix usage of _MSC_VER in gzguts.h and zutil.h [Truta]
-- Update readme.txt in contrib/masmx64 and masmx86 to assemble
-
-Changes in 1.2.3.9 (21 Feb 2010)
-- Expunge gzio.c
-- Move as400 build information to old
-- Fix updates in contrib/minizip and contrib/vstudio
-- Add const to vsnprintf test in configure to avoid warnings [Weigelt]
-- Delete zconf.h (made by configure) [Weigelt]
-- Change zconf.in.h to zconf.h.in per convention [Weigelt]
-- Check for NULL buf in gzgets()
-- Return empty string for gzgets() with len == 1 (like fgets())
-- Fix description of gzgets() in zlib.h for end-of-file, NULL return
-- Update minizip to 1.1 [Vollant]
-- Avoid MSVC loss of data warnings in gzread.c, gzwrite.c
-- Note in zlib.h that gzerror() should be used to distinguish from EOF
-- Remove use of snprintf() from gzlib.c
-- Fix bug in gzseek()
-- Update contrib/vstudio, adding vc9 and vc10 [Kuno, Vollant]
-- Fix zconf.h generation in CMakeLists.txt [Lowman]
-- Improve comments in zconf.h where modified by configure
-
-Changes in 1.2.3.8 (13 Feb 2010)
-- Clean up text files (tabs, trailing whitespace, etc.) [Oberhumer]
-- Use z_off64_t in gz_zero() and gz_skip() to match state->skip
-- Avoid comparison problem when sizeof(int) == sizeof(z_off64_t)
-- Revert to Makefile.in from 1.2.3.6 (live with the clutter)
-- Fix missing error return in gzflush(), add zlib.h note
-- Add *64 functions to zlib.map [Levin]
-- Fix signed/unsigned comparison in gz_comp()
-- Use SFLAGS when testing shared linking in configure
-- Add --64 option to ./configure to use -m64 with gcc
-- Fix ./configure --help to correctly name options
-- Have make fail if a test fails [Levin]
-- Avoid buffer overrun in contrib/masmx64/gvmat64.asm [Simpson]
-- Remove assembler object files from contrib
-
-Changes in 1.2.3.7 (24 Jan 2010)
-- Always gzopen() with O_LARGEFILE if available
-- Fix gzdirect() to work immediately after gzopen() or gzdopen()
-- Make gzdirect() more precise when the state changes while reading
-- Improve zlib.h documentation in many places
-- Catch memory allocation failure in gz_open()
-- Complete close operation if seek forward in gzclose_w() fails
-- Return Z_ERRNO from gzclose_r() if close() fails
-- Return Z_STREAM_ERROR instead of EOF for gzclose() being passed NULL
-- Return zero for gzwrite() errors to match zlib.h description
-- Return -1 on gzputs() error to match zlib.h description
-- Add zconf.in.h to allow recovery from configure modification [Weigelt]
-- Fix static library permissions in Makefile.in [Weigelt]
-- Avoid warnings in configure tests that hide functionality [Weigelt]
-- Add *BSD and DragonFly to Linux case in configure [gentoo 123571]
-- Change libzdll.a to libz.dll.a in win32/Makefile.gcc [gentoo 288212]
-- Avoid access of uninitialized data for first inflateReset2 call [Gomes]
-- Keep object files in subdirectories to reduce the clutter somewhat
-- Remove default Makefile and zlibdefs.h, add dummy Makefile
-- Add new external functions to Z_PREFIX, remove duplicates, z_z_ -> z_
-- Remove zlibdefs.h completely -- modify zconf.h instead
-
-Changes in 1.2.3.6 (17 Jan 2010)
-- Avoid void * arithmetic in gzread.c and gzwrite.c
-- Make compilers happier with const char * for gz_error message
-- Avoid unused parameter warning in inflate.c
-- Avoid signed-unsigned comparison warning in inflate.c
-- Indent #pragma's for traditional C
-- Fix usage of strwinerror() in glib.c, change to gz_strwinerror()
-- Correct email address in configure for system options
-- Update make_vms.com and add make_vms.com to contrib/minizip [Zinser]
-- Update zlib.map [Brown]
-- Fix Makefile.in for Solaris 10 make of example64 and minizip64 [Torok]
-- Apply various fixes to CMakeLists.txt [Lowman]
-- Add checks on len in gzread() and gzwrite()
-- Add error message for no more room for gzungetc()
-- Remove zlib version check in gzwrite()
-- Defer compression of gzprintf() result until need to
-- Use snprintf() in gzdopen() if available
-- Remove USE_MMAP configuration determination (only used by minigzip)
-- Remove examples/pigz.c (available separately)
-- Update examples/gun.c to 1.6
-
-Changes in 1.2.3.5 (8 Jan 2010)
-- Add space after #if in zutil.h for some compilers
-- Fix relatively harmless bug in deflate_fast() [Exarevsky]
-- Fix same problem in deflate_slow()
-- Add $(SHAREDLIBV) to LIBS in Makefile.in [Brown]
-- Add deflate_rle() for faster Z_RLE strategy run-length encoding
-- Add deflate_huff() for faster Z_HUFFMAN_ONLY encoding
-- Change name of "write" variable in inffast.c to avoid library collisions
-- Fix premature EOF from gzread() in gzio.c [Brown]
-- Use zlib header window size if windowBits is 0 in inflateInit2()
-- Remove compressBound() call in deflate.c to avoid linking compress.o
-- Replace use of errno in gz* with functions, support WinCE [Alves]
-- Provide alternative to perror() in minigzip.c for WinCE [Alves]
-- Don't use _vsnprintf on later versions of MSVC [Lowman]
-- Add CMake build script and input file [Lowman]
-- Update contrib/minizip to 1.1 [Svensson, Vollant]
-- Moved nintendods directory from contrib to .
-- Replace gzio.c with a new set of routines with the same functionality
-- Add gzbuffer(), gzoffset(), gzclose_r(), gzclose_w() as part of above
-- Update contrib/minizip to 1.1b
-- Change gzeof() to return 0 on error instead of -1 to agree with zlib.h
-
-Changes in 1.2.3.4 (21 Dec 2009)
-- Use old school .SUFFIXES in Makefile.in for FreeBSD compatibility
-- Update comments in configure and Makefile.in for default --shared
-- Fix test -z's in configure [Marquess]
-- Build examplesh and minigzipsh when not testing
-- Change NULL's to Z_NULL's in deflate.c and in comments in zlib.h
-- Import LDFLAGS from the environment in configure
-- Fix configure to populate SFLAGS with discovered CFLAGS options
-- Adapt make_vms.com to the new Makefile.in [Zinser]
-- Add zlib2ansi script for C++ compilation [Marquess]
-- Add _FILE_OFFSET_BITS=64 test to make test (when applicable)
-- Add AMD64 assembler code for longest match to contrib [Teterin]
-- Include options from $SFLAGS when doing $LDSHARED
-- Simplify 64-bit file support by introducing z_off64_t type
-- Make shared object files in objs directory to work around old Sun cc
-- Use only three-part version number for Darwin shared compiles
-- Add rc option to ar in Makefile.in for when ./configure not run
-- Add -WI,-rpath,. to LDFLAGS for OSF 1 V4*
-- Set LD_LIBRARYN32_PATH for SGI IRIX shared compile
-- Protect against _FILE_OFFSET_BITS being defined when compiling zlib
-- Rename Makefile.in targets allstatic to static and allshared to shared
-- Fix static and shared Makefile.in targets to be independent
-- Correct error return bug in gz_open() by setting state [Brown]
-- Put spaces before ;;'s in configure for better sh compatibility
-- Add pigz.c (parallel implementation of gzip) to examples/
-- Correct constant in crc32.c to UL [Leventhal]
-- Reject negative lengths in crc32_combine()
-- Add inflateReset2() function to work like inflateEnd()/inflateInit2()
-- Include sys/types.h for _LARGEFILE64_SOURCE [Brown]
-- Correct typo in doc/algorithm.txt [Janik]
-- Fix bug in adler32_combine() [Zhu]
-- Catch missing-end-of-block-code error in all inflates and in puff
-    Assures that random input to inflate eventually results in an error
-- Added enough.c (calculation of ENOUGH for inftrees.h) to examples/
-- Update ENOUGH and its usage to reflect discovered bounds
-- Fix gzerror() error report on empty input file [Brown]
-- Add ush casts in trees.c to avoid pedantic runtime errors
-- Fix typo in zlib.h uncompress() description [Reiss]
-- Correct inflate() comments with regard to automatic header detection
-- Remove deprecation comment on Z_PARTIAL_FLUSH (it stays)
-- Put new version of gzlog (2.0) in examples with interruption recovery
-- Add puff compile option to permit invalid distance-too-far streams
-- Add puff TEST command options, ability to read piped input
-- Prototype the *64 functions in zlib.h when _FILE_OFFSET_BITS == 64, but
-  _LARGEFILE64_SOURCE not defined
-- Fix Z_FULL_FLUSH to truly erase the past by resetting s->strstart
-- Fix deflateSetDictionary() to use all 32K for output consistency
-- Remove extraneous #define MIN_LOOKAHEAD in deflate.c (in deflate.h)
-- Clear bytes after deflate lookahead to avoid use of uninitialized data
-- Change a limit in inftrees.c to be more transparent to Coverity Prevent
-- Update win32/zlib.def with exported symbols from zlib.h
-- Correct spelling errors in zlib.h [Willem, Sobrado]
-- Allow Z_BLOCK for deflate() to force a new block
-- Allow negative bits in inflatePrime() to delete existing bit buffer
-- Add Z_TREES flush option to inflate() to return at end of trees
-- Add inflateMark() to return current state information for random access
-- Add Makefile for NintendoDS to contrib [Costa]
-- Add -w in configure compile tests to avoid spurious warnings [Beucler]
-- Fix typos in zlib.h comments for deflateSetDictionary()
-- Fix EOF detection in transparent gzread() [Maier]
-
-Changes in 1.2.3.3 (2 October 2006)
-- Make --shared the default for configure, add a --static option
-- Add compile option to permit invalid distance-too-far streams
-- Add inflateUndermine() function which is required to enable above
-- Remove use of "this" variable name for C++ compatibility [Marquess]
-- Add testing of shared library in make test, if shared library built
-- Use ftello() and fseeko() if available instead of ftell() and fseek()
-- Provide two versions of all functions that use the z_off_t type for
-  binary compatibility -- a normal version and a 64-bit offset version,
-  per the Large File Support Extension when _LARGEFILE64_SOURCE is
-  defined; use the 64-bit versions by default when _FILE_OFFSET_BITS
-  is defined to be 64
-- Add a --uname= option to configure to perhaps help with cross-compiling
-
-Changes in 1.2.3.2 (3 September 2006)
-- Turn off silly Borland warnings [Hay]
-- Use off64_t and define _LARGEFILE64_SOURCE when present
-- Fix missing dependency on inffixed.h in Makefile.in
-- Rig configure --shared to build both shared and static [Teredesai, Truta]
-- Remove zconf.in.h and instead create a new zlibdefs.h file
-- Fix contrib/minizip/unzip.c non-encrypted after encrypted [Vollant]
-- Add treebuild.xml (see http://treebuild.metux.de/) [Weigelt]
-
-Changes in 1.2.3.1 (16 August 2006)
-- Add watcom directory with OpenWatcom make files [Daniel]
-- Remove #undef of FAR in zconf.in.h for MVS [Fedtke]
-- Update make_vms.com [Zinser]
-- Use -fPIC for shared build in configure [Teredesai, Nicholson]
-- Use only major version number for libz.so on IRIX and OSF1 [Reinholdtsen]
-- Use fdopen() (not _fdopen()) for Interix in zutil.h [Bäck]
-- Add some FAQ entries about the contrib directory
-- Update the MVS question in the FAQ
-- Avoid extraneous reads after EOF in gzio.c [Brown]
-- Correct spelling of "successfully" in gzio.c [Randers-Pehrson]
-- Add comments to zlib.h about gzerror() usage [Brown]
-- Set extra flags in gzip header in gzopen() like deflate() does
-- Make configure options more compatible with double-dash conventions
-  [Weigelt]
-- Clean up compilation under Solaris SunStudio cc [Rowe, Reinholdtsen]
-- Fix uninstall target in Makefile.in [Truta]
-- Add pkgconfig support [Weigelt]
-- Use $(DESTDIR) macro in Makefile.in [Reinholdtsen, Weigelt]
-- Replace set_data_type() with a more accurate detect_data_type() in
-  trees.c, according to the txtvsbin.txt document [Truta]
-- Swap the order of #include <stdio.h> and #include "zlib.h" in
-  gzio.c, example.c and minigzip.c [Truta]
-- Shut up annoying VS2005 warnings about standard C deprecation [Rowe,
-  Truta] (where?)
-- Fix target "clean" from win32/Makefile.bor [Truta]
-- Create .pdb and .manifest files in win32/makefile.msc [Ziegler, Rowe]
-- Update zlib www home address in win32/DLL_FAQ.txt [Truta]
-- Update contrib/masmx86/inffas32.asm for VS2005 [Vollant, Van Wassenhove]
-- Enable browse info in the "Debug" and "ASM Debug" configurations in
-  the Visual C++ 6 project, and set (non-ASM) "Debug" as default [Truta]
-- Add pkgconfig support [Weigelt]
-- Add ZLIB_VER_MAJOR, ZLIB_VER_MINOR and ZLIB_VER_REVISION in zlib.h,
-  for use in win32/zlib1.rc [Polushin, Rowe, Truta]
-- Add a document that explains the new text detection scheme to
-  doc/txtvsbin.txt [Truta]
-- Add rfc1950.txt, rfc1951.txt and rfc1952.txt to doc/ [Truta]
-- Move algorithm.txt into doc/ [Truta]
-- Synchronize FAQ with website
-- Fix compressBound(), was low for some pathological cases [Fearnley]
-- Take into account wrapper variations in deflateBound()
-- Set examples/zpipe.c input and output to binary mode for Windows
-- Update examples/zlib_how.html with new zpipe.c (also web site)
-- Fix some warnings in examples/gzlog.c and examples/zran.c (it seems
-  that gcc became pickier in 4.0)
-- Add zlib.map for Linux: "All symbols from zlib-1.1.4 remain
-  un-versioned, the patch adds versioning only for symbols introduced in
-  zlib-1.2.0 or later.  It also declares as local those symbols which are
-  not designed to be exported." [Levin]
-- Update Z_PREFIX list in zconf.in.h, add --zprefix option to configure
-- Do not initialize global static by default in trees.c, add a response
-  NO_INIT_GLOBAL_POINTERS to initialize them if needed [Marquess]
-- Don't use strerror() in gzio.c under WinCE [Yakimov]
-- Don't use errno.h in zutil.h under WinCE [Yakimov]
-- Move arguments for AR to its usage to allow replacing ar [Marot]
-- Add HAVE_VISIBILITY_PRAGMA in zconf.in.h for Mozilla [Randers-Pehrson]
-- Improve inflateInit() and inflateInit2() documentation
-- Fix structure size comment in inflate.h
-- Change configure help option from --h* to --help [Santos]
-
-Changes in 1.2.3 (18 July 2005)
-- Apply security vulnerability fixes to contrib/infback9 as well
-- Clean up some text files (carriage returns, trailing space)
-- Update testzlib, vstudio, masmx64, and masmx86 in contrib [Vollant]
-
-Changes in 1.2.2.4 (11 July 2005)
-- Add inflatePrime() function for starting inflation at bit boundary
-- Avoid some Visual C warnings in deflate.c
-- Avoid more silly Visual C warnings in inflate.c and inftrees.c for 64-bit
-  compile
-- Fix some spelling errors in comments [Betts]
-- Correct inflateInit2() error return documentation in zlib.h
-- Add zran.c example of compressed data random access to examples
-  directory, shows use of inflatePrime()
-- Fix cast for assignments to strm->state in inflate.c and infback.c
-- Fix zlibCompileFlags() in zutil.c to use 1L for long shifts [Oberhumer]
-- Move declarations of gf2 functions to right place in crc32.c [Oberhumer]
-- Add cast in trees.c t avoid a warning [Oberhumer]
-- Avoid some warnings in fitblk.c, gun.c, gzjoin.c in examples [Oberhumer]
-- Update make_vms.com [Zinser]
-- Initialize state->write in inflateReset() since copied in inflate_fast()
-- Be more strict on incomplete code sets in inflate_table() and increase
-  ENOUGH and MAXD -- this repairs a possible security vulnerability for
-  invalid inflate input.  Thanks to Tavis Ormandy and Markus Oberhumer for
-  discovering the vulnerability and providing test cases.
-- Add ia64 support to configure for HP-UX [Smith]
-- Add error return to gzread() for format or i/o error [Levin]
-- Use malloc.h for OS/2 [Necasek]
-
-Changes in 1.2.2.3 (27 May 2005)
-- Replace 1U constants in inflate.c and inftrees.c for 64-bit compile
-- Typecast fread() return values in gzio.c [Vollant]
-- Remove trailing space in minigzip.c outmode (VC++ can't deal with it)
-- Fix crc check bug in gzread() after gzungetc() [Heiner]
-- Add the deflateTune() function to adjust internal compression parameters
-- Add a fast gzip decompressor, gun.c, to examples (use of inflateBack)
-- Remove an incorrect assertion in examples/zpipe.c
-- Add C++ wrapper in infback9.h [Donais]
-- Fix bug in inflateCopy() when decoding fixed codes
-- Note in zlib.h how much deflateSetDictionary() actually uses
-- Remove USE_DICT_HEAD in deflate.c (would mess up inflate if used)
-- Add _WIN32_WCE to define WIN32 in zconf.in.h [Spencer]
-- Don't include stderr.h or errno.h for _WIN32_WCE in zutil.h [Spencer]
-- Add gzdirect() function to indicate transparent reads
-- Update contrib/minizip [Vollant]
-- Fix compilation of deflate.c when both ASMV and FASTEST [Oberhumer]
-- Add casts in crc32.c to avoid warnings [Oberhumer]
-- Add contrib/masmx64 [Vollant]
-- Update contrib/asm586, asm686, masmx86, testzlib, vstudio [Vollant]
-
-Changes in 1.2.2.2 (30 December 2004)
-- Replace structure assignments in deflate.c and inflate.c with zmemcpy to
-  avoid implicit memcpy calls (portability for no-library compilation)
-- Increase sprintf() buffer size in gzdopen() to allow for large numbers
-- Add INFLATE_STRICT to check distances against zlib header
-- Improve WinCE errno handling and comments [Chang]
-- Remove comment about no gzip header processing in FAQ
-- Add Z_FIXED strategy option to deflateInit2() to force fixed trees
-- Add updated make_vms.com [Coghlan], update README
-- Create a new "examples" directory, move gzappend.c there, add zpipe.c,
-  fitblk.c, gzlog.[ch], gzjoin.c, and zlib_how.html.
-- Add FAQ entry and comments in deflate.c on uninitialized memory access
-- Add Solaris 9 make options in configure [Gilbert]
-- Allow strerror() usage in gzio.c for STDC
-- Fix DecompressBuf in contrib/delphi/ZLib.pas [ManChesTer]
-- Update contrib/masmx86/inffas32.asm and gvmat32.asm [Vollant]
-- Use z_off_t for adler32_combine() and crc32_combine() lengths
-- Make adler32() much faster for small len
-- Use OS_CODE in deflate() default gzip header
-
-Changes in 1.2.2.1 (31 October 2004)
-- Allow inflateSetDictionary() call for raw inflate
-- Fix inflate header crc check bug for file names and comments
-- Add deflateSetHeader() and gz_header structure for custom gzip headers
-- Add inflateGetheader() to retrieve gzip headers
-- Add crc32_combine() and adler32_combine() functions
-- Add alloc_func, free_func, in_func, out_func to Z_PREFIX list
-- Use zstreamp consistently in zlib.h (inflate_back functions)
-- Remove GUNZIP condition from definition of inflate_mode in inflate.h
-  and in contrib/inflate86/inffast.S [Truta, Anderson]
-- Add support for AMD64 in contrib/inflate86/inffas86.c [Anderson]
-- Update projects/README.projects and projects/visualc6 [Truta]
-- Update win32/DLL_FAQ.txt [Truta]
-- Avoid warning under NO_GZCOMPRESS in gzio.c; fix typo [Truta]
-- Deprecate Z_ASCII; use Z_TEXT instead [Truta]
-- Use a new algorithm for setting strm->data_type in trees.c [Truta]
-- Do not define an exit() prototype in zutil.c unless DEBUG defined
-- Remove prototype of exit() from zutil.c, example.c, minigzip.c [Truta]
-- Add comment in zlib.h for Z_NO_FLUSH parameter to deflate()
-- Fix Darwin build version identification [Peterson]
-
-Changes in 1.2.2 (3 October 2004)
-- Update zlib.h comments on gzip in-memory processing
-- Set adler to 1 in inflateReset() to support Java test suite [Walles]
-- Add contrib/dotzlib [Ravn]
-- Update win32/DLL_FAQ.txt [Truta]
-- Update contrib/minizip [Vollant]
-- Move contrib/visual-basic.txt to old/ [Truta]
-- Fix assembler builds in projects/visualc6/ [Truta]
-
-Changes in 1.2.1.2 (9 September 2004)
-- Update INDEX file
-- Fix trees.c to update strm->data_type (no one ever noticed!)
-- Fix bug in error case in inflate.c, infback.c, and infback9.c [Brown]
-- Add "volatile" to crc table flag declaration (for DYNAMIC_CRC_TABLE)
-- Add limited multitasking protection to DYNAMIC_CRC_TABLE
-- Add NO_vsnprintf for VMS in zutil.h [Mozilla]
-- Don't declare strerror() under VMS [Mozilla]
-- Add comment to DYNAMIC_CRC_TABLE to use get_crc_table() to initialize
-- Update contrib/ada [Anisimkov]
-- Update contrib/minizip [Vollant]
-- Fix configure to not hardcode directories for Darwin [Peterson]
-- Fix gzio.c to not return error on empty files [Brown]
-- Fix indentation; update version in contrib/delphi/ZLib.pas and
-  contrib/pascal/zlibpas.pas [Truta]
-- Update mkasm.bat in contrib/masmx86 [Truta]
-- Update contrib/untgz [Truta]
-- Add projects/README.projects [Truta]
-- Add project for MS Visual C++ 6.0 in projects/visualc6 [Cadieux, Truta]
-- Update win32/DLL_FAQ.txt [Truta]
-- Update list of Z_PREFIX symbols in zconf.h [Randers-Pehrson, Truta]
-- Remove an unnecessary assignment to curr in inftrees.c [Truta]
-- Add OS/2 to exe builds in configure [Poltorak]
-- Remove err dummy parameter in zlib.h [Kientzle]
-
-Changes in 1.2.1.1 (9 January 2004)
-- Update email address in README
-- Several FAQ updates
-- Fix a big fat bug in inftrees.c that prevented decoding valid
-  dynamic blocks with only literals and no distance codes --
-  Thanks to "Hot Emu" for the bug report and sample file
-- Add a note to puff.c on no distance codes case.
-
-Changes in 1.2.1 (17 November 2003)
-- Remove a tab in contrib/gzappend/gzappend.c
-- Update some interfaces in contrib for new zlib functions
-- Update zlib version number in some contrib entries
-- Add Windows CE definition for ptrdiff_t in zutil.h [Mai, Truta]
-- Support shared libraries on Hurd and KFreeBSD [Brown]
-- Fix error in NO_DIVIDE option of adler32.c
-
-Changes in 1.2.0.8 (4 November 2003)
-- Update version in contrib/delphi/ZLib.pas and contrib/pascal/zlibpas.pas
-- Add experimental NO_DIVIDE #define in adler32.c
-    - Possibly faster on some processors (let me know if it is)
-- Correct Z_BLOCK to not return on first inflate call if no wrap
-- Fix strm->data_type on inflate() return to correctly indicate EOB
-- Add deflatePrime() function for appending in the middle of a byte
-- Add contrib/gzappend for an example of appending to a stream
-- Update win32/DLL_FAQ.txt [Truta]
-- Delete Turbo C comment in README [Truta]
-- Improve some indentation in zconf.h [Truta]
-- Fix infinite loop on bad input in configure script [Church]
-- Fix gzeof() for concatenated gzip files [Johnson]
-- Add example to contrib/visual-basic.txt [Michael B.]
-- Add -p to mkdir's in Makefile.in [vda]
-- Fix configure to properly detect presence or lack of printf functions
-- Add AS400 support [Monnerat]
-- Add a little Cygwin support [Wilson]
-
-Changes in 1.2.0.7 (21 September 2003)
-- Correct some debug formats in contrib/infback9
-- Cast a type in a debug statement in trees.c
-- Change search and replace delimiter in configure from % to # [Beebe]
-- Update contrib/untgz to 0.2 with various fixes [Truta]
-- Add build support for Amiga [Nikl]
-- Remove some directories in old that have been updated to 1.2
-- Add dylib building for Mac OS X in configure and Makefile.in
-- Remove old distribution stuff from Makefile
-- Update README to point to DLL_FAQ.txt, and add comment on Mac OS X
-- Update links in README
-
-Changes in 1.2.0.6 (13 September 2003)
-- Minor FAQ updates
-- Update contrib/minizip to 1.00 [Vollant]
-- Remove test of gz functions in example.c when GZ_COMPRESS defined [Truta]
-- Update POSTINC comment for 68060 [Nikl]
-- Add contrib/infback9 with deflate64 decoding (unsupported)
-- For MVS define NO_vsnprintf and undefine FAR [van Burik]
-- Add pragma for fdopen on MVS [van Burik]
-
-Changes in 1.2.0.5 (8 September 2003)
-- Add OF to inflateBackEnd() declaration in zlib.h
-- Remember start when using gzdopen in the middle of a file
-- Use internal off_t counters in gz* functions to properly handle seeks
-- Perform more rigorous check for distance-too-far in inffast.c
-- Add Z_BLOCK flush option to return from inflate at block boundary
-- Set strm->data_type on return from inflate
-    - Indicate bits unused, if at block boundary, and if in last block
-- Replace size_t with ptrdiff_t in crc32.c, and check for correct size
-- Add condition so old NO_DEFLATE define still works for compatibility
-- FAQ update regarding the Windows DLL [Truta]
-- INDEX update: add qnx entry, remove aix entry [Truta]
-- Install zlib.3 into mandir [Wilson]
-- Move contrib/zlib_dll_FAQ.txt to win32/DLL_FAQ.txt; update [Truta]
-- Adapt the zlib interface to the new DLL convention guidelines [Truta]
-- Introduce ZLIB_WINAPI macro to allow the export of functions using
-  the WINAPI calling convention, for Visual Basic [Vollant, Truta]
-- Update msdos and win32 scripts and makefiles [Truta]
-- Export symbols by name, not by ordinal, in win32/zlib.def [Truta]
-- Add contrib/ada [Anisimkov]
-- Move asm files from contrib/vstudio/vc70_32 to contrib/asm386 [Truta]
-- Rename contrib/asm386 to contrib/masmx86 [Truta, Vollant]
-- Add contrib/masm686 [Truta]
-- Fix offsets in contrib/inflate86 and contrib/masmx86/inffas32.asm
-  [Truta, Vollant]
-- Update contrib/delphi; rename to contrib/pascal; add example [Truta]
-- Remove contrib/delphi2; add a new contrib/delphi [Truta]
-- Avoid inclusion of the nonstandard <memory.h> in contrib/iostream,
-  and fix some method prototypes [Truta]
-- Fix the ZCR_SEED2 constant to avoid warnings in contrib/minizip
-  [Truta]
-- Avoid the use of backslash (\) in contrib/minizip [Vollant]
-- Fix file time handling in contrib/untgz; update makefiles [Truta]
-- Update contrib/vstudio/vc70_32 to comply with the new DLL guidelines
-  [Vollant]
-- Remove contrib/vstudio/vc15_16 [Vollant]
-- Rename contrib/vstudio/vc70_32 to contrib/vstudio/vc7 [Truta]
-- Update README.contrib [Truta]
-- Invert the assignment order of match_head and s->prev[...] in
-  INSERT_STRING [Truta]
-- Compare TOO_FAR with 32767 instead of 32768, to avoid 16-bit warnings
-  [Truta]
-- Compare function pointers with 0, not with NULL or Z_NULL [Truta]
-- Fix prototype of syncsearch in inflate.c [Truta]
-- Introduce ASMINF macro to be enabled when using an ASM implementation
-  of inflate_fast [Truta]
-- Change NO_DEFLATE to NO_GZCOMPRESS [Truta]
-- Modify test_gzio in example.c to take a single file name as a
-  parameter [Truta]
-- Exit the example.c program if gzopen fails [Truta]
-- Add type casts around strlen in example.c [Truta]
-- Remove casting to sizeof in minigzip.c; give a proper type
-  to the variable compared with SUFFIX_LEN [Truta]
-- Update definitions of STDC and STDC99 in zconf.h [Truta]
-- Synchronize zconf.h with the new Windows DLL interface [Truta]
-- Use SYS16BIT instead of __32BIT__ to distinguish between
-  16- and 32-bit platforms [Truta]
-- Use far memory allocators in small 16-bit memory models for
-  Turbo C [Truta]
-- Add info about the use of ASMV, ASMINF and ZLIB_WINAPI in
-  zlibCompileFlags [Truta]
-- Cygwin has vsnprintf [Wilson]
-- In Windows16, OS_CODE is 0, as in MSDOS [Truta]
-- In Cygwin, OS_CODE is 3 (Unix), not 11 (Windows32) [Wilson]
-
-Changes in 1.2.0.4 (10 August 2003)
-- Minor FAQ updates
-- Be more strict when checking inflateInit2's windowBits parameter
-- Change NO_GUNZIP compile option to NO_GZIP to cover deflate as well
-- Add gzip wrapper option to deflateInit2 using windowBits
-- Add updated QNX rule in configure and qnx directory [Bonnefoy]
-- Make inflate distance-too-far checks more rigorous
-- Clean up FAR usage in inflate
-- Add casting to sizeof() in gzio.c and minigzip.c
-
-Changes in 1.2.0.3 (19 July 2003)
-- Fix silly error in gzungetc() implementation [Vollant]
-- Update contrib/minizip and contrib/vstudio [Vollant]
-- Fix printf format in example.c
-- Correct cdecl support in zconf.in.h [Anisimkov]
-- Minor FAQ updates
-
-Changes in 1.2.0.2 (13 July 2003)
-- Add ZLIB_VERNUM in zlib.h for numerical preprocessor comparisons
-- Attempt to avoid warnings in crc32.c for pointer-int conversion
-- Add AIX to configure, remove aix directory [Bakker]
-- Add some casts to minigzip.c
-- Improve checking after insecure sprintf() or vsprintf() calls
-- Remove #elif's from crc32.c
-- Change leave label to inf_leave in inflate.c and infback.c to avoid
-  library conflicts
-- Remove inflate gzip decoding by default--only enable gzip decoding by
-  special request for stricter backward compatibility
-- Add zlibCompileFlags() function to return compilation information
-- More typecasting in deflate.c to avoid warnings
-- Remove leading underscore from _Capital #defines [Truta]
-- Fix configure to link shared library when testing
-- Add some Windows CE target adjustments [Mai]
-- Remove #define ZLIB_DLL in zconf.h [Vollant]
-- Add zlib.3 [Rodgers]
-- Update RFC URL in deflate.c and algorithm.txt [Mai]
-- Add zlib_dll_FAQ.txt to contrib [Truta]
-- Add UL to some constants [Truta]
-- Update minizip and vstudio [Vollant]
-- Remove vestigial NEED_DUMMY_RETURN from zconf.in.h
-- Expand use of NO_DUMMY_DECL to avoid all dummy structures
-- Added iostream3 to contrib [Schwardt]
-- Replace rewind() with fseek() for WinCE [Truta]
-- Improve setting of zlib format compression level flags
-    - Report 0 for huffman and rle strategies and for level == 0 or 1
-    - Report 2 only for level == 6
-- Only deal with 64K limit when necessary at compile time [Truta]
-- Allow TOO_FAR check to be turned off at compile time [Truta]
-- Add gzclearerr() function [Souza]
-- Add gzungetc() function
-
-Changes in 1.2.0.1 (17 March 2003)
-- Add Z_RLE strategy for run-length encoding [Truta]
-    - When Z_RLE requested, restrict matches to distance one
-    - Update zlib.h, minigzip.c, gzopen(), gzdopen() for Z_RLE
-- Correct FASTEST compilation to allow level == 0
-- Clean up what gets compiled for FASTEST
-- Incorporate changes to zconf.in.h [Vollant]
-    - Refine detection of Turbo C need for dummy returns
-    - Refine ZLIB_DLL compilation
-    - Include additional header file on VMS for off_t typedef
-- Try to use _vsnprintf where it supplants vsprintf [Vollant]
-- Add some casts in inffast.c
-- Enchance comments in zlib.h on what happens if gzprintf() tries to
-  write more than 4095 bytes before compression
-- Remove unused state from inflateBackEnd()
-- Remove exit(0) from minigzip.c, example.c
-- Get rid of all those darn tabs
-- Add "check" target to Makefile.in that does the same thing as "test"
-- Add "mostlyclean" and "maintainer-clean" targets to Makefile.in
-- Update contrib/inflate86 [Anderson]
-- Update contrib/testzlib, contrib/vstudio, contrib/minizip [Vollant]
-- Add msdos and win32 directories with makefiles [Truta]
-- More additions and improvements to the FAQ
-
-Changes in 1.2.0 (9 March 2003)
-- New and improved inflate code
-    - About 20% faster
-    - Does not allocate 32K window unless and until needed
-    - Automatically detects and decompresses gzip streams
-    - Raw inflate no longer needs an extra dummy byte at end
-    - Added inflateBack functions using a callback interface--even faster
-      than inflate, useful for file utilities (gzip, zip)
-    - Added inflateCopy() function to record state for random access on
-      externally generated deflate streams (e.g. in gzip files)
-    - More readable code (I hope)
-- New and improved crc32()
-    - About 50% faster, thanks to suggestions from Rodney Brown
-- Add deflateBound() and compressBound() functions
-- Fix memory leak in deflateInit2()
-- Permit setting dictionary for raw deflate (for parallel deflate)
-- Fix const declaration for gzwrite()
-- Check for some malloc() failures in gzio.c
-- Fix bug in gzopen() on single-byte file 0x1f
-- Fix bug in gzread() on concatenated file with 0x1f at end of buffer
-  and next buffer doesn't start with 0x8b
-- Fix uncompress() to return Z_DATA_ERROR on truncated input
-- Free memory at end of example.c
-- Remove MAX #define in trees.c (conflicted with some libraries)
-- Fix static const's in deflate.c, gzio.c, and zutil.[ch]
-- Declare malloc() and free() in gzio.c if STDC not defined
-- Use malloc() instead of calloc() in zutil.c if int big enough
-- Define STDC for AIX
-- Add aix/ with approach for compiling shared library on AIX
-- Add HP-UX support for shared libraries in configure
-- Add OpenUNIX support for shared libraries in configure
-- Use $cc instead of gcc to build shared library
-- Make prefix directory if needed when installing
-- Correct Macintosh avoidance of typedef Byte in zconf.h
-- Correct Turbo C memory allocation when under Linux
-- Use libz.a instead of -lz in Makefile (assure use of compiled library)
-- Update configure to check for snprintf or vsnprintf functions and their
-  return value, warn during make if using an insecure function
-- Fix configure problem with compile-time knowledge of HAVE_UNISTD_H that
-  is lost when library is used--resolution is to build new zconf.h
-- Documentation improvements (in zlib.h):
-    - Document raw deflate and inflate
-    - Update RFCs URL
-    - Point out that zlib and gzip formats are different
-    - Note that Z_BUF_ERROR is not fatal
-    - Document string limit for gzprintf() and possible buffer overflow
-    - Note requirement on avail_out when flushing
-    - Note permitted values of flush parameter of inflate()
-- Add some FAQs (and even answers) to the FAQ
-- Add contrib/inflate86/ for x86 faster inflate
-- Add contrib/blast/ for PKWare Data Compression Library decompression
-- Add contrib/puff/ simple inflate for deflate format description
-
-Changes in 1.1.4 (11 March 2002)
-- ZFREE was repeated on same allocation on some error conditions.
-  This creates a security problem described in
-  http://www.zlib.org/advisory-2002-03-11.txt
-- Returned incorrect error (Z_MEM_ERROR) on some invalid data
-- Avoid accesses before window for invalid distances with inflate window
-  less than 32K.
-- force windowBits > 8 to avoid a bug in the encoder for a window size
-  of 256 bytes. (A complete fix will be available in 1.1.5).
-
-Changes in 1.1.3 (9 July 1998)
-- fix "an inflate input buffer bug that shows up on rare but persistent
-  occasions" (Mark)
-- fix gzread and gztell for concatenated .gz files (Didier Le Botlan)
-- fix gzseek(..., SEEK_SET) in write mode
-- fix crc check after a gzeek (Frank Faubert)
-- fix miniunzip when the last entry in a zip file is itself a zip file
-  (J Lillge)
-- add contrib/asm586 and contrib/asm686 (Brian Raiter)
-  See http://www.muppetlabs.com/~breadbox/software/assembly.html
-- add support for Delphi 3 in contrib/delphi (Bob Dellaca)
-- add support for C++Builder 3 and Delphi 3 in contrib/delphi2 (Davide Moretti)
-- do not exit prematurely in untgz if 0 at start of block (Magnus Holmgren)
-- use macro EXTERN instead of extern to support DLL for BeOS (Sander Stoks)
-- added a FAQ file
-
-- Support gzdopen on Mac with Metrowerks (Jason Linhart)
-- Do not redefine Byte on Mac (Brad Pettit & Jason Linhart)
-- define SEEK_END too if SEEK_SET is not defined (Albert Chin-A-Young)
-- avoid some warnings with Borland C (Tom Tanner)
-- fix a problem in contrib/minizip/zip.c for 16-bit MSDOS (Gilles Vollant)
-- emulate utime() for WIN32 in contrib/untgz  (Gilles Vollant)
-- allow several arguments to configure (Tim Mooney, Frodo Looijaard)
-- use libdir and includedir in Makefile.in (Tim Mooney)
-- support shared libraries on OSF1 V4 (Tim Mooney)
-- remove so_locations in "make clean"  (Tim Mooney)
-- fix maketree.c compilation error (Glenn, Mark)
-- Python interface to zlib now in Python 1.5 (Jeremy Hylton)
-- new Makefile.riscos (Rich Walker)
-- initialize static descriptors in trees.c for embedded targets (Nick Smith)
-- use "foo-gz" in example.c for RISCOS and VMS (Nick Smith)
-- add the OS/2 files in Makefile.in too (Andrew Zabolotny)
-- fix fdopen and halloc macros for Microsoft C 6.0 (Tom Lane)
-- fix maketree.c to allow clean compilation of inffixed.h (Mark)
-- fix parameter check in deflateCopy (Gunther Nikl)
-- cleanup trees.c, use compressed_len only in debug mode (Christian Spieler)
-- Many portability patches by Christian Spieler:
-  . zutil.c, zutil.h: added "const" for zmem*
-  . Make_vms.com: fixed some typos
-  . Make_vms.com: msdos/Makefile.*: removed zutil.h from some dependency lists
-  . msdos/Makefile.msc: remove "default rtl link library" info from obj files
-  . msdos/Makefile.*: use model-dependent name for the built zlib library
-  . msdos/Makefile.emx, nt/Makefile.emx, nt/Makefile.gcc:
-     new makefiles, for emx (DOS/OS2), emx&rsxnt and mingw32 (Windows 9x / NT)
-- use define instead of typedef for Bytef also for MSC small/medium (Tom Lane)
-- replace __far with _far for better portability (Christian Spieler, Tom Lane)
-- fix test for errno.h in configure (Tim Newsham)
-
-Changes in 1.1.2 (19 March 98)
-- added contrib/minzip, mini zip and unzip based on zlib (Gilles Vollant)
-  See http://www.winimage.com/zLibDll/unzip.html
-- preinitialize the inflate tables for fixed codes, to make the code
-  completely thread safe (Mark)
-- some simplifications and slight speed-up to the inflate code (Mark)
-- fix gzeof on non-compressed files (Allan Schrum)
-- add -std1 option in configure for OSF1 to fix gzprintf (Martin Mokrejs)
-- use default value of 4K for Z_BUFSIZE for 16-bit MSDOS (Tim Wegner + Glenn)
-- added os2/Makefile.def and os2/zlib.def (Andrew Zabolotny)
-- add shared lib support for UNIX_SV4.2MP (MATSUURA Takanori)
-- do not wrap extern "C" around system includes (Tom Lane)
-- mention zlib binding for TCL in README (Andreas Kupries)
-- added amiga/Makefile.pup for Amiga powerUP SAS/C PPC (Andreas Kleinert)
-- allow "make install prefix=..." even after configure (Glenn Randers-Pehrson)
-- allow "configure --prefix $HOME" (Tim Mooney)
-- remove warnings in example.c and gzio.c (Glenn Randers-Pehrson)
-- move Makefile.sas to amiga/Makefile.sas
-
-Changes in 1.1.1 (27 Feb 98)
-- fix macros _tr_tally_* in deflate.h for debug mode  (Glenn Randers-Pehrson)
-- remove block truncation heuristic which had very marginal effect for zlib
-  (smaller lit_bufsize than in gzip 1.2.4) and degraded a little the
-  compression ratio on some files. This also allows inlining _tr_tally for
-  matches in deflate_slow.
-- added msdos/Makefile.w32 for WIN32 Microsoft Visual C++ (Bob Frazier)
-
-Changes in 1.1.0 (24 Feb 98)
-- do not return STREAM_END prematurely in inflate (John Bowler)
-- revert to the zlib 1.0.8 inflate to avoid the gcc 2.8.0 bug (Jeremy Buhler)
-- compile with -DFASTEST to get compression code optimized for speed only
-- in minigzip, try mmap'ing the input file first (Miguel Albrecht)
-- increase size of I/O buffers in minigzip.c and gzio.c (not a big gain
-  on Sun but significant on HP)
-
-- add a pointer to experimental unzip library in README (Gilles Vollant)
-- initialize variable gcc in configure (Chris Herborth)
-
-Changes in 1.0.9 (17 Feb 1998)
-- added gzputs and gzgets functions
-- do not clear eof flag in gzseek (Mark Diekhans)
-- fix gzseek for files in transparent mode (Mark Diekhans)
-- do not assume that vsprintf returns the number of bytes written (Jens Krinke)
-- replace EXPORT with ZEXPORT to avoid conflict with other programs
-- added compress2 in zconf.h, zlib.def, zlib.dnt
-- new asm code from Gilles Vollant in contrib/asm386
-- simplify the inflate code (Mark):
- . Replace ZALLOC's in huft_build() with single ZALLOC in inflate_blocks_new()
- . ZALLOC the length list in inflate_trees_fixed() instead of using stack
- . ZALLOC the value area for huft_build() instead of using stack
- . Simplify Z_FINISH check in inflate()
-
-- Avoid gcc 2.8.0 comparison bug a little differently than zlib 1.0.8
-- in inftrees.c, avoid cc -O bug on HP (Farshid Elahi)
-- in zconf.h move the ZLIB_DLL stuff earlier to avoid problems with
-  the declaration of FAR (Gilles VOllant)
-- install libz.so* with mode 755 (executable) instead of 644 (Marc Lehmann)
-- read_buf buf parameter of type Bytef* instead of charf*
-- zmemcpy parameters are of type Bytef*, not charf* (Joseph Strout)
-- do not redeclare unlink in minigzip.c for WIN32 (John Bowler)
-- fix check for presence of directories in "make install" (Ian Willis)
-
-Changes in 1.0.8 (27 Jan 1998)
-- fixed offsets in contrib/asm386/gvmat32.asm (Gilles Vollant)
-- fix gzgetc and gzputc for big endian systems (Markus Oberhumer)
-- added compress2() to allow setting the compression level
-- include sys/types.h to get off_t on some systems (Marc Lehmann & QingLong)
-- use constant arrays for the static trees in trees.c instead of computing
-  them at run time (thanks to Ken Raeburn for this suggestion). To create
-  trees.h, compile with GEN_TREES_H and run "make test".
-- check return code of example in "make test" and display result
-- pass minigzip command line options to file_compress
-- simplifying code of inflateSync to avoid gcc 2.8 bug
-
-- support CC="gcc -Wall" in configure -s (QingLong)
-- avoid a flush caused by ftell in gzopen for write mode (Ken Raeburn)
-- fix test for shared library support to avoid compiler warnings
-- zlib.lib -> zlib.dll in msdos/zlib.rc (Gilles Vollant)
-- check for TARGET_OS_MAC in addition to MACOS (Brad Pettit)
-- do not use fdopen for Metrowerks on Mac (Brad Pettit))
-- add checks for gzputc and gzputc in example.c
-- avoid warnings in gzio.c and deflate.c (Andreas Kleinert)
-- use const for the CRC table (Ken Raeburn)
-- fixed "make uninstall" for shared libraries
-- use Tracev instead of Trace in infblock.c
-- in example.c use correct compressed length for test_sync
-- suppress +vnocompatwarnings in configure for HPUX (not always supported)
-
-Changes in 1.0.7 (20 Jan 1998)
-- fix gzseek which was broken in write mode
-- return error for gzseek to negative absolute position
-- fix configure for Linux (Chun-Chung Chen)
-- increase stack space for MSC (Tim Wegner)
-- get_crc_table and inflateSyncPoint are EXPORTed (Gilles Vollant)
-- define EXPORTVA for gzprintf (Gilles Vollant)
-- added man page zlib.3 (Rick Rodgers)
-- for contrib/untgz, fix makedir() and improve Makefile
-
-- check gzseek in write mode in example.c
-- allocate extra buffer for seeks only if gzseek is actually called
-- avoid signed/unsigned comparisons (Tim Wegner, Gilles Vollant)
-- add inflateSyncPoint in zconf.h
-- fix list of exported functions in nt/zlib.dnt and mdsos/zlib.def
-
-Changes in 1.0.6 (19 Jan 1998)
-- add functions gzprintf, gzputc, gzgetc, gztell, gzeof, gzseek, gzrewind and
-  gzsetparams (thanks to Roland Giersig and Kevin Ruland for some of this code)
-- Fix a deflate bug occurring only with compression level 0 (thanks to
-  Andy Buckler for finding this one).
-- In minigzip, pass transparently also the first byte for .Z files.
-- return Z_BUF_ERROR instead of Z_OK if output buffer full in uncompress()
-- check Z_FINISH in inflate (thanks to Marc Schluper)
-- Implement deflateCopy (thanks to Adam Costello)
-- make static libraries by default in configure, add --shared option.
-- move MSDOS or Windows specific files to directory msdos
-- suppress the notion of partial flush to simplify the interface
-  (but the symbol Z_PARTIAL_FLUSH is kept for compatibility with 1.0.4)
-- suppress history buffer provided by application to simplify the interface
-  (this feature was not implemented anyway in 1.0.4)
-- next_in and avail_in must be initialized before calling inflateInit or
-  inflateInit2
-- add EXPORT in all exported functions (for Windows DLL)
-- added Makefile.nt (thanks to Stephen Williams)
-- added the unsupported "contrib" directory:
-   contrib/asm386/ by Gilles Vollant <info@winimage.com>
-        386 asm code replacing longest_match().
-   contrib/iostream/ by Kevin Ruland <kevin@rodin.wustl.edu>
-        A C++ I/O streams interface to the zlib gz* functions
-   contrib/iostream2/  by Tyge Løvset <Tyge.Lovset@cmr.no>
-        Another C++ I/O streams interface
-   contrib/untgz/  by "Pedro A. Aranda Guti\irrez" <paag@tid.es>
-        A very simple tar.gz file extractor using zlib
-   contrib/visual-basic.txt by Carlos Rios <c_rios@sonda.cl>
-        How to use compress(), uncompress() and the gz* functions from VB.
-- pass params -f (filtered data), -h (huffman only), -1 to -9 (compression
-  level) in minigzip (thanks to Tom Lane)
-
-- use const for rommable constants in deflate
-- added test for gzseek and gztell in example.c
-- add undocumented function inflateSyncPoint() (hack for Paul Mackerras)
-- add undocumented function zError to convert error code to string
-  (for Tim Smithers)
-- Allow compilation of gzio with -DNO_DEFLATE to avoid the compression code.
-- Use default memcpy for Symantec MSDOS compiler.
-- Add EXPORT keyword for check_func (needed for Windows DLL)
-- add current directory to LD_LIBRARY_PATH for "make test"
-- create also a link for libz.so.1
-- added support for FUJITSU UXP/DS (thanks to Toshiaki Nomura)
-- use $(SHAREDLIB) instead of libz.so in Makefile.in (for HPUX)
-- added -soname for Linux in configure (Chun-Chung Chen,
-- assign numbers to the exported functions in zlib.def (for Windows DLL)
-- add advice in zlib.h for best usage of deflateSetDictionary
-- work around compiler bug on Atari (cast Z_NULL in call of s->checkfn)
-- allow compilation with ANSI keywords only enabled for TurboC in large model
-- avoid "versionString"[0] (Borland bug)
-- add NEED_DUMMY_RETURN for Borland
-- use variable z_verbose for tracing in debug mode (L. Peter Deutsch).
-- allow compilation with CC
-- defined STDC for OS/2 (David Charlap)
-- limit external names to 8 chars for MVS (Thomas Lund)
-- in minigzip.c, use static buffers only for 16-bit systems
-- fix suffix check for "minigzip -d foo.gz"
-- do not return an error for the 2nd of two consecutive gzflush() (Felix Lee)
-- use _fdopen instead of fdopen for MSC >= 6.0 (Thomas Fanslau)
-- added makelcc.bat for lcc-win32 (Tom St Denis)
-- in Makefile.dj2, use copy and del instead of install and rm (Frank Donahoe)
-- Avoid expanded $Id$. Use "rcs -kb" or "cvs admin -kb" to avoid Id expansion.
-- check for unistd.h in configure (for off_t)
-- remove useless check parameter in inflate_blocks_free
-- avoid useless assignment of s->check to itself in inflate_blocks_new
-- do not flush twice in gzclose (thanks to Ken Raeburn)
-- rename FOPEN as F_OPEN to avoid clash with /usr/include/sys/file.h
-- use NO_ERRNO_H instead of enumeration of operating systems with errno.h
-- work around buggy fclose on pipes for HP/UX
-- support zlib DLL with BORLAND C++ 5.0 (thanks to Glenn Randers-Pehrson)
-- fix configure if CC is already equal to gcc
-
-Changes in 1.0.5 (3 Jan 98)
-- Fix inflate to terminate gracefully when fed corrupted or invalid data
-- Use const for rommable constants in inflate
-- Eliminate memory leaks on error conditions in inflate
-- Removed some vestigial code in inflate
-- Update web address in README
-
-Changes in 1.0.4 (24 Jul 96)
-- In very rare conditions, deflate(s, Z_FINISH) could fail to produce an EOF
-  bit, so the decompressor could decompress all the correct data but went
-  on to attempt decompressing extra garbage data. This affected minigzip too.
-- zlibVersion and gzerror return const char* (needed for DLL)
-- port to RISCOS (no fdopen, no multiple dots, no unlink, no fileno)
-- use z_error only for DEBUG (avoid problem with DLLs)
-
-Changes in 1.0.3 (2 Jul 96)
-- use z_streamp instead of z_stream *, which is now a far pointer in MSDOS
-  small and medium models; this makes the library incompatible with previous
-  versions for these models. (No effect in large model or on other systems.)
-- return OK instead of BUF_ERROR if previous deflate call returned with
-  avail_out as zero but there is nothing to do
-- added memcmp for non STDC compilers
-- define NO_DUMMY_DECL for more Mac compilers (.h files merged incorrectly)
-- define __32BIT__ if __386__ or i386 is defined (pb. with Watcom and SCO)
-- better check for 16-bit mode MSC (avoids problem with Symantec)
-
-Changes in 1.0.2 (23 May 96)
-- added Windows DLL support
-- added a function zlibVersion (for the DLL support)
-- fixed declarations using Bytef in infutil.c (pb with MSDOS medium model)
-- Bytef is define's instead of typedef'd only for Borland C
-- avoid reading uninitialized memory in example.c
-- mention in README that the zlib format is now RFC1950
-- updated Makefile.dj2
-- added algorithm.doc
-
-Changes in 1.0.1 (20 May 96) [1.0 skipped to avoid confusion]
-- fix array overlay in deflate.c which sometimes caused bad compressed data
-- fix inflate bug with empty stored block
-- fix MSDOS medium model which was broken in 0.99
-- fix deflateParams() which could generated bad compressed data.
-- Bytef is define'd instead of typedef'ed (work around Borland bug)
-- added an INDEX file
-- new makefiles for DJGPP (Makefile.dj2), 32-bit Borland (Makefile.b32),
-  Watcom (Makefile.wat), Amiga SAS/C (Makefile.sas)
-- speed up adler32 for modern machines without auto-increment
-- added -ansi for IRIX in configure
-- static_init_done in trees.c is an int
-- define unlink as delete for VMS
-- fix configure for QNX
-- add configure branch for SCO and HPUX
-- avoid many warnings (unused variables, dead assignments, etc...)
-- no fdopen for BeOS
-- fix the Watcom fix for 32 bit mode (define FAR as empty)
-- removed redefinition of Byte for MKWERKS
-- work around an MWKERKS bug (incorrect merge of all .h files)
-
-Changes in 0.99 (27 Jan 96)
-- allow preset dictionary shared between compressor and decompressor
-- allow compression level 0 (no compression)
-- add deflateParams in zlib.h: allow dynamic change of compression level
-  and compression strategy.
-- test large buffers and deflateParams in example.c
-- add optional "configure" to build zlib as a shared library
-- suppress Makefile.qnx, use configure instead
-- fixed deflate for 64-bit systems (detected on Cray)
-- fixed inflate_blocks for 64-bit systems (detected on Alpha)
-- declare Z_DEFLATED in zlib.h (possible parameter for deflateInit2)
-- always return Z_BUF_ERROR when deflate() has nothing to do
-- deflateInit and inflateInit are now macros to allow version checking
-- prefix all global functions and types with z_ with -DZ_PREFIX
-- make falloc completely reentrant (inftrees.c)
-- fixed very unlikely race condition in ct_static_init
-- free in reverse order of allocation to help memory manager
-- use zlib-1.0/* instead of zlib/* inside the tar.gz
-- make zlib warning-free with "gcc -O3 -Wall -Wwrite-strings -Wpointer-arith
-  -Wconversion -Wstrict-prototypes -Wmissing-prototypes"
-- allow gzread on concatenated .gz files
-- deflateEnd now returns Z_DATA_ERROR if it was premature
-- deflate is finally (?) fully deterministic (no matches beyond end of input)
-- Document Z_SYNC_FLUSH
-- add uninstall in Makefile
-- Check for __cpluplus in zlib.h
-- Better test in ct_align for partial flush
-- avoid harmless warnings for Borland C++
-- initialize hash_head in deflate.c
-- avoid warning on fdopen (gzio.c) for HP cc -Aa
-- include stdlib.h for STDC compilers
-- include errno.h for Cray
-- ignore error if ranlib doesn't exist
-- call ranlib twice for NeXTSTEP
-- use exec_prefix instead of prefix for libz.a
-- renamed ct_* as _tr_* to avoid conflict with applications
-- clear z->msg in inflateInit2 before any error return
-- initialize opaque in example.c, gzio.c, deflate.c and inflate.c
-- fixed typo in zconf.h (_GNUC__ => __GNUC__)
-- check for WIN32 in zconf.h and zutil.c (avoid farmalloc in 32-bit mode)
-- fix typo in Make_vms.com (f$trnlnm -> f$getsyi)
-- in fcalloc, normalize pointer if size > 65520 bytes
-- don't use special fcalloc for 32 bit Borland C++
-- use STDC instead of __GO32__ to avoid redeclaring exit, calloc, etc...
-- use Z_BINARY instead of BINARY
-- document that gzclose after gzdopen will close the file
-- allow "a" as mode in gzopen.
-- fix error checking in gzread
-- allow skipping .gz extra-field on pipes
-- added reference to Perl interface in README
-- put the crc table in FAR data (I dislike more and more the medium model :)
-- added get_crc_table
-- added a dimension to all arrays (Borland C can't count).
-- workaround Borland C bug in declaration of inflate_codes_new & inflate_fast
-- guard against multiple inclusion of *.h (for precompiled header on Mac)
-- Watcom C pretends to be Microsoft C small model even in 32 bit mode.
-- don't use unsized arrays to avoid silly warnings by Visual C++:
-     warning C4746: 'inflate_mask' : unsized array treated as  '__far'
-     (what's wrong with far data in far model?).
-- define enum out of inflate_blocks_state to allow compilation with C++
-
-Changes in 0.95 (16 Aug 95)
-- fix MSDOS small and medium model (now easier to adapt to any compiler)
-- inlined send_bits
-- fix the final (:-) bug for deflate with flush (output was correct but
-  not completely flushed in rare occasions).
-- default window size is same for compression and decompression
-  (it's now sufficient to set MAX_WBITS in zconf.h).
-- voidp -> voidpf and voidnp -> voidp (for consistency with other
-  typedefs and because voidnp was not near in large model).
-
-Changes in 0.94 (13 Aug 95)
-- support MSDOS medium model
-- fix deflate with flush (could sometimes generate bad output)
-- fix deflateReset (zlib header was incorrectly suppressed)
-- added support for VMS
-- allow a compression level in gzopen()
-- gzflush now calls fflush
-- For deflate with flush, flush even if no more input is provided.
-- rename libgz.a as libz.a
-- avoid complex expression in infcodes.c triggering Turbo C bug
-- work around a problem with gcc on Alpha (in INSERT_STRING)
-- don't use inline functions (problem with some gcc versions)
-- allow renaming of Byte, uInt, etc... with #define.
-- avoid warning about (unused) pointer before start of array in deflate.c
-- avoid various warnings in gzio.c, example.c, infblock.c, adler32.c, zutil.c
-- avoid reserved word 'new' in trees.c
-
-Changes in 0.93 (25 June 95)
-- temporarily disable inline functions
-- make deflate deterministic
-- give enough lookahead for PARTIAL_FLUSH
-- Set binary mode for stdin/stdout in minigzip.c for OS/2
-- don't even use signed char in inflate (not portable enough)
-- fix inflate memory leak for segmented architectures
-
-Changes in 0.92 (3 May 95)
-- don't assume that char is signed (problem on SGI)
-- Clear bit buffer when starting a stored block
-- no memcpy on Pyramid
-- suppressed inftest.c
-- optimized fill_window, put longest_match inline for gcc
-- optimized inflate on stored blocks.
-- untabify all sources to simplify patches
-
-Changes in 0.91 (2 May 95)
-- Default MEM_LEVEL is 8 (not 9 for Unix) as documented in zlib.h
-- Document the memory requirements in zconf.h
-- added "make install"
-- fix sync search logic in inflateSync
-- deflate(Z_FULL_FLUSH) now works even if output buffer too short
-- after inflateSync, don't scare people with just "lo world"
-- added support for DJGPP
-
-Changes in 0.9 (1 May 95)
-- don't assume that zalloc clears the allocated memory (the TurboC bug
-  was Mark's bug after all :)
-- let again gzread copy uncompressed data unchanged (was working in 0.71)
-- deflate(Z_FULL_FLUSH), inflateReset and inflateSync are now fully implemented
-- added a test of inflateSync in example.c
-- moved MAX_WBITS to zconf.h because users might want to change that.
-- document explicitly that zalloc(64K) on MSDOS must return a normalized
-  pointer (zero offset)
-- added Makefiles for Microsoft C, Turbo C, Borland C++
-- faster crc32()
-
-Changes in 0.8 (29 April 95)
-- added fast inflate (inffast.c)
-- deflate(Z_FINISH) now returns Z_STREAM_END when done. Warning: this
-  is incompatible with previous versions of zlib which returned Z_OK.
-- work around a TurboC compiler bug (bad code for b << 0, see infutil.h)
-  (actually that was not a compiler bug, see 0.81 above)
-- gzread no longer reads one extra byte in certain cases
-- In gzio destroy(), don't reference a freed structure
-- avoid many warnings for MSDOS
-- avoid the ERROR symbol which is used by MS Windows
-
-Changes in 0.71 (14 April 95)
-- Fixed more MSDOS compilation problems :( There is still a bug with
-  TurboC large model.
-
-Changes in 0.7 (14 April 95)
-- Added full inflate support.
-- Simplified the crc32() interface. The pre- and post-conditioning
-  (one's complement) is now done inside crc32(). WARNING: this is
-  incompatible with previous versions; see zlib.h for the new usage.
-
-Changes in 0.61 (12 April 95)
-- workaround for a bug in TurboC. example and minigzip now work on MSDOS.
-
-Changes in 0.6 (11 April 95)
-- added minigzip.c
-- added gzdopen to reopen a file descriptor as gzFile
-- added transparent reading of non-gziped files in gzread.
-- fixed bug in gzread (don't read crc as data)
-- fixed bug in destroy (gzio.c) (don't return Z_STREAM_END for gzclose).
-- don't allocate big arrays in the stack (for MSDOS)
-- fix some MSDOS compilation problems
-
-Changes in 0.5:
-- do real compression in deflate.c. Z_PARTIAL_FLUSH is supported but
-  not yet Z_FULL_FLUSH.
-- support decompression but only in a single step (forced Z_FINISH)
-- added opaque object for zalloc and zfree.
-- added deflateReset and inflateReset
-- added a variable zlib_version for consistency checking.
-- renamed the 'filter' parameter of deflateInit2 as 'strategy'.
-  Added Z_FILTERED and Z_HUFFMAN_ONLY constants.
-
-Changes in 0.4:
-- avoid "zip" everywhere, use zlib instead of ziplib.
-- suppress Z_BLOCK_FLUSH, interpret Z_PARTIAL_FLUSH as block flush
-  if compression method == 8.
-- added adler32 and crc32
-- renamed deflateOptions as deflateInit2, call one or the other but not both
-- added the method parameter for deflateInit2.
-- added inflateInit2
-- simplied considerably deflateInit and inflateInit by not supporting
-  user-provided history buffer. This is supported only in deflateInit2
-  and inflateInit2.
-
-Changes in 0.3:
-- prefix all macro names with Z_
-- use Z_FINISH instead of deflateEnd to finish compression.
-- added Z_HUFFMAN_ONLY
-- added gzerror()
diff --git a/contrib/libzlib-ng/FAQ.zlib b/contrib/libzlib-ng/FAQ.zlib
deleted file mode 100644
index 8da63b40767..00000000000
--- a/contrib/libzlib-ng/FAQ.zlib
+++ /dev/null
@@ -1,374 +0,0 @@
-##
-# THIS IS AN UNMAINTAINED COPY OF THE ORIGINAL FILE DISTRIBUTED WITH ZLIB 1.2.8
-##
-
-
-
-
-                Frequently Asked Questions about zlib
-
-
-If your question is not there, please check the zlib home page
-http://zlib.net/ which may have more recent information.
-The lastest zlib FAQ is at http://zlib.net/zlib_faq.html
-
-
- 1. Is zlib Y2K-compliant?
-
-    Yes. zlib doesn't handle dates.
-
- 2. Where can I get a Windows DLL version?
-
-    The zlib sources can be compiled without change to produce a DLL.  See the
-    file win32/DLL_FAQ.txt in the zlib distribution.  Pointers to the
-    precompiled DLL are found in the zlib web site at http://zlib.net/ .
-
- 3. Where can I get a Visual Basic interface to zlib?
-
-    See
-        * http://marknelson.us/1997/01/01/zlib-engine/
-        * win32/DLL_FAQ.txt in the zlib distribution
-
- 4. compress() returns Z_BUF_ERROR.
-
-    Make sure that before the call of compress(), the length of the compressed
-    buffer is equal to the available size of the compressed buffer and not
-    zero.  For Visual Basic, check that this parameter is passed by reference
-    ("as any"), not by value ("as long").
-
- 5. deflate() or inflate() returns Z_BUF_ERROR.
-
-    Before making the call, make sure that avail_in and avail_out are not zero.
-    When setting the parameter flush equal to Z_FINISH, also make sure that
-    avail_out is big enough to allow processing all pending input.  Note that a
-    Z_BUF_ERROR is not fatal--another call to deflate() or inflate() can be
-    made with more input or output space.  A Z_BUF_ERROR may in fact be
-    unavoidable depending on how the functions are used, since it is not
-    possible to tell whether or not there is more output pending when
-    strm.avail_out returns with zero.  See http://zlib.net/zlib_how.html for a
-    heavily annotated example.
-
- 6. Where's the zlib documentation (man pages, etc.)?
-
-    It's in zlib.h .  Examples of zlib usage are in the files test/example.c
-    and test/minigzip.c, with more in examples/ .
-
- 7. Why don't you use GNU autoconf or libtool or ...?
-
-    Because we would like to keep zlib as a very small and simple package.
-    zlib is rather portable and doesn't need much configuration.
-
- 8. I found a bug in zlib.
-
-    Most of the time, such problems are due to an incorrect usage of zlib.
-    Please try to reproduce the problem with a small program and send the
-    corresponding source to us at zlib@gzip.org .  Do not send multi-megabyte
-    data files without prior agreement.
-
- 9. Why do I get "undefined reference to gzputc"?
-
-    If "make test" produces something like
-
-       example.o(.text+0x154): undefined reference to `gzputc'
-
-    check that you don't have old files libz.* in /usr/lib, /usr/local/lib or
-    /usr/X11R6/lib. Remove any old versions, then do "make install".
-
-10. I need a Delphi interface to zlib.
-
-    See the contrib/delphi directory in the zlib distribution.
-
-11. Can zlib handle .zip archives?
-
-    Not by itself, no.  See the directory contrib/minizip in the zlib
-    distribution.
-
-12. Can zlib handle .Z files?
-
-    No, sorry.  You have to spawn an uncompress or gunzip subprocess, or adapt
-    the code of uncompress on your own.
-
-13. How can I make a Unix shared library?
-
-    By default a shared (and a static) library is built for Unix.  So:
-
-    make distclean
-    ./configure
-    make
-
-14. How do I install a shared zlib library on Unix?
-
-    After the above, then:
-
-    make install
-
-    However, many flavors of Unix come with a shared zlib already installed.
-    Before going to the trouble of compiling a shared version of zlib and
-    trying to install it, you may want to check if it's already there!  If you
-    can #include <zlib.h>, it's there.  The -lz option will probably link to
-    it.  You can check the version at the top of zlib.h or with the
-    ZLIB_VERSION symbol defined in zlib.h .
-
-15. I have a question about OttoPDF.
-
-    We are not the authors of OttoPDF. The real author is on the OttoPDF web
-    site: Joel Hainley, jhainley@myndkryme.com.
-
-16. Can zlib decode Flate data in an Adobe PDF file?
-
-    Yes. See http://www.pdflib.com/ . To modify PDF forms, see
-    http://sourceforge.net/projects/acroformtool/ .
-
-17. Why am I getting this "register_frame_info not found" error on Solaris?
-
-    After installing zlib 1.1.4 on Solaris 2.6, running applications using zlib
-    generates an error such as:
-
-        ld.so.1: rpm: fatal: relocation error: file /usr/local/lib/libz.so:
-        symbol __register_frame_info: referenced symbol not found
-
-    The symbol __register_frame_info is not part of zlib, it is generated by
-    the C compiler (cc or gcc).  You must recompile applications using zlib
-    which have this problem.  This problem is specific to Solaris.  See
-    http://www.sunfreeware.com for Solaris versions of zlib and applications
-    using zlib.
-
-18. Why does gzip give an error on a file I make with compress/deflate?
-
-    The compress and deflate functions produce data in the zlib format, which
-    is different and incompatible with the gzip format.  The gz* functions in
-    zlib on the other hand use the gzip format.  Both the zlib and gzip formats
-    use the same compressed data format internally, but have different headers
-    and trailers around the compressed data.
-
-19. Ok, so why are there two different formats?
-
-    The gzip format was designed to retain the directory information about a
-    single file, such as the name and last modification date.  The zlib format
-    on the other hand was designed for in-memory and communication channel
-    applications, and has a much more compact header and trailer and uses a
-    faster integrity check than gzip.
-
-20. Well that's nice, but how do I make a gzip file in memory?
-
-    You can request that deflate write the gzip format instead of the zlib
-    format using deflateInit2().  You can also request that inflate decode the
-    gzip format using inflateInit2().  Read zlib.h for more details.
-
-21. Is zlib thread-safe?
-
-    Yes.  However any library routines that zlib uses and any application-
-    provided memory allocation routines must also be thread-safe.  zlib's gz*
-    functions use stdio library routines, and most of zlib's functions use the
-    library memory allocation routines by default.  zlib's *Init* functions
-    allow for the application to provide custom memory allocation routines.
-
-    Of course, you should only operate on any given zlib or gzip stream from a
-    single thread at a time.
-
-22. Can I use zlib in my commercial application?
-
-    Yes.  Please read the license in zlib.h.
-
-23. Is zlib under the GNU license?
-
-    No.  Please read the license in zlib.h.
-
-24. The license says that altered source versions must be "plainly marked". So
-    what exactly do I need to do to meet that requirement?
-
-    You need to change the ZLIB_VERSION and ZLIB_VERNUM #defines in zlib.h.  In
-    particular, the final version number needs to be changed to "f", and an
-    identification string should be appended to ZLIB_VERSION.  Version numbers
-    x.x.x.f are reserved for modifications to zlib by others than the zlib
-    maintainers.  For example, if the version of the base zlib you are altering
-    is "1.2.3.4", then in zlib.h you should change ZLIB_VERNUM to 0x123f, and
-    ZLIB_VERSION to something like "1.2.3.f-zachary-mods-v3".  You can also
-    update the version strings in deflate.c and inftrees.c.
-
-    For altered source distributions, you should also note the origin and
-    nature of the changes in zlib.h, as well as in ChangeLog and README, along
-    with the dates of the alterations.  The origin should include at least your
-    name (or your company's name), and an email address to contact for help or
-    issues with the library.
-
-    Note that distributing a compiled zlib library along with zlib.h and
-    zconf.h is also a source distribution, and so you should change
-    ZLIB_VERSION and ZLIB_VERNUM and note the origin and nature of the changes
-    in zlib.h as you would for a full source distribution.
-
-25. Will zlib work on a big-endian or little-endian architecture, and can I
-    exchange compressed data between them?
-
-    Yes and yes.
-
-26. Will zlib work on a 64-bit machine?
-
-    Yes.  It has been tested on 64-bit machines, and has no dependence on any
-    data types being limited to 32-bits in length.  If you have any
-    difficulties, please provide a complete problem report to zlib@gzip.org
-
-27. Will zlib decompress data from the PKWare Data Compression Library?
-
-    No.  The PKWare DCL uses a completely different compressed data format than
-    does PKZIP and zlib.  However, you can look in zlib's contrib/blast
-    directory for a possible solution to your problem.
-
-28. Can I access data randomly in a compressed stream?
-
-    No, not without some preparation.  If when compressing you periodically use
-    Z_FULL_FLUSH, carefully write all the pending data at those points, and
-    keep an index of those locations, then you can start decompression at those
-    points.  You have to be careful to not use Z_FULL_FLUSH too often, since it
-    can significantly degrade compression.  Alternatively, you can scan a
-    deflate stream once to generate an index, and then use that index for
-    random access.  See examples/zran.c .
-
-29. Does zlib work on MVS, OS/390, CICS, etc.?
-
-    It has in the past, but we have not heard of any recent evidence.  There
-    were working ports of zlib 1.1.4 to MVS, but those links no longer work.
-    If you know of recent, successful applications of zlib on these operating
-    systems, please let us know.  Thanks.
-
-30. Is there some simpler, easier to read version of inflate I can look at to
-    understand the deflate format?
-
-    First off, you should read RFC 1951.  Second, yes.  Look in zlib's
-    contrib/puff directory.
-
-31. Does zlib infringe on any patents?
-
-    As far as we know, no.  In fact, that was originally the whole point behind
-    zlib.  Look here for some more information:
-
-    http://www.gzip.org/#faq11
-
-32. Can zlib work with greater than 4 GB of data?
-
-    Yes.  inflate() and deflate() will process any amount of data correctly.
-    Each call of inflate() or deflate() is limited to input and output chunks
-    of the maximum value that can be stored in the compiler's "unsigned int"
-    type, but there is no limit to the number of chunks.  Note however that the
-    strm.total_in and strm_total_out counters may be limited to 4 GB.  These
-    counters are provided as a convenience and are not used internally by
-    inflate() or deflate().  The application can easily set up its own counters
-    updated after each call of inflate() or deflate() to count beyond 4 GB.
-    compress() and uncompress() may be limited to 4 GB, since they operate in a
-    single call.  gzseek() and gztell() may be limited to 4 GB depending on how
-    zlib is compiled.  See the zlibCompileFlags() function in zlib.h.
-
-    The word "may" appears several times above since there is a 4 GB limit only
-    if the compiler's "long" type is 32 bits.  If the compiler's "long" type is
-    64 bits, then the limit is 16 exabytes.
-
-33. Does zlib have any security vulnerabilities?
-
-    The only one that we are aware of is potentially in gzprintf().  If zlib is
-    compiled to use sprintf() or vsprintf(), then there is no protection
-    against a buffer overflow of an 8K string space (or other value as set by
-    gzbuffer()), other than the caller of gzprintf() assuring that the output
-    will not exceed 8K.  On the other hand, if zlib is compiled to use
-    snprintf() or vsnprintf(), which should normally be the case, then there is
-    no vulnerability.  The ./configure script will display warnings if an
-    insecure variation of sprintf() will be used by gzprintf().  Also the
-    zlibCompileFlags() function will return information on what variant of
-    sprintf() is used by gzprintf().
-
-    If you don't have snprintf() or vsnprintf() and would like one, you can
-    find a portable implementation here:
-
-        http://www.ijs.si/software/snprintf/
-
-    Note that you should be using the most recent version of zlib.  Versions
-    1.1.3 and before were subject to a double-free vulnerability, and versions
-    1.2.1 and 1.2.2 were subject to an access exception when decompressing
-    invalid compressed data.
-
-34. Is there a Java version of zlib?
-
-    Probably what you want is to use zlib in Java. zlib is already included
-    as part of the Java SDK in the java.util.zip package. If you really want
-    a version of zlib written in the Java language, look on the zlib home
-    page for links: http://zlib.net/ .
-
-35. I get this or that compiler or source-code scanner warning when I crank it
-    up to maximally-pedantic. Can't you guys write proper code?
-
-    Many years ago, we gave up attempting to avoid warnings on every compiler
-    in the universe.  It just got to be a waste of time, and some compilers
-    were downright silly as well as contradicted each other.  So now, we simply
-    make sure that the code always works.
-
-36. Valgrind (or some similar memory access checker) says that deflate is
-    performing a conditional jump that depends on an uninitialized value.
-    Isn't that a bug?
-
-    No.  That is intentional for performance reasons, and the output of deflate
-    is not affected.  This only started showing up recently since zlib 1.2.x
-    uses malloc() by default for allocations, whereas earlier versions used
-    calloc(), which zeros out the allocated memory.  Even though the code was
-    correct, versions 1.2.4 and later was changed to not stimulate these
-    checkers.
-
-37. Will zlib read the (insert any ancient or arcane format here) compressed
-    data format?
-
-    Probably not. Look in the comp.compression FAQ for pointers to various
-    formats and associated software.
-
-38. How can I encrypt/decrypt zip files with zlib?
-
-    zlib doesn't support encryption.  The original PKZIP encryption is very
-    weak and can be broken with freely available programs.  To get strong
-    encryption, use GnuPG, http://www.gnupg.org/ , which already includes zlib
-    compression.  For PKZIP compatible "encryption", look at
-    http://www.info-zip.org/
-
-39. What's the difference between the "gzip" and "deflate" HTTP 1.1 encodings?
-
-    "gzip" is the gzip format, and "deflate" is the zlib format.  They should
-    probably have called the second one "zlib" instead to avoid confusion with
-    the raw deflate compressed data format.  While the HTTP 1.1 RFC 2616
-    correctly points to the zlib specification in RFC 1950 for the "deflate"
-    transfer encoding, there have been reports of servers and browsers that
-    incorrectly produce or expect raw deflate data per the deflate
-    specification in RFC 1951, most notably Microsoft.  So even though the
-    "deflate" transfer encoding using the zlib format would be the more
-    efficient approach (and in fact exactly what the zlib format was designed
-    for), using the "gzip" transfer encoding is probably more reliable due to
-    an unfortunate choice of name on the part of the HTTP 1.1 authors.
-
-    Bottom line: use the gzip format for HTTP 1.1 encoding.
-
-40. Does zlib support the new "Deflate64" format introduced by PKWare?
-
-    No.  PKWare has apparently decided to keep that format proprietary, since
-    they have not documented it as they have previous compression formats.  In
-    any case, the compression improvements are so modest compared to other more
-    modern approaches, that it's not worth the effort to implement.
-
-41. I'm having a problem with the zip functions in zlib, can you help?
-
-    There are no zip functions in zlib.  You are probably using minizip by
-    Giles Vollant, which is found in the contrib directory of zlib.  It is not
-    part of zlib.  In fact none of the stuff in contrib is part of zlib.  The
-    files in there are not supported by the zlib authors.  You need to contact
-    the authors of the respective contribution for help.
-
-42. The match.asm code in contrib is under the GNU General Public License.
-    Since it's part of zlib, doesn't that mean that all of zlib falls under the
-    GNU GPL?
-
-    No.  The files in contrib are not part of zlib.  They were contributed by
-    other authors and are provided as a convenience to the user within the zlib
-    distribution.  Each item in contrib has its own license.
-
-43. Is zlib subject to export controls?  What is its ECCN?
-
-    zlib is not subject to export controls, and so is classified as EAR99.
-
-44. Can you please sign these lengthy legal documents and fax them back to us
-    so that we can use your software in our product?
-
-    No. Go away. Shoo.
diff --git a/contrib/libzlib-ng/INDEX b/contrib/libzlib-ng/INDEX
deleted file mode 100644
index acb9aba64c3..00000000000
--- a/contrib/libzlib-ng/INDEX
+++ /dev/null
@@ -1,55 +0,0 @@
-CMakeLists.txt  cmake build file
-ChangeLog.zlib  history of changes up to the fork from zlib 1.2.8
-FAQ.zlib        Frequently Asked Questions about zlib, as distributed in zlib 1.2.8
-INDEX           this file
-Makefile        dummy Makefile that tells you to ./configure
-Makefile.in     template for Unix Makefile
-README          guess what
-README.zlib     Copy of the original README file distributed in zlib 1.2.8
-configure       configure script for Unix
-test/example.c  zlib usages examples for build testing
-test/minigzip.c minimal gzip-like functionality for build testing
-test/infcover.c inf*.c code coverage for build coverage testing
-treebuild.xml   XML description of source file dependencies
-zconf.h.cmakein zconf.h template for cmake
-zconf.h.in      zconf.h template for configure
-zlib.3          Man page for zlib
-zlib.3.pdf      Man page in PDF format
-zlib.map        Linux symbol information
-zlib.pc.in      Template for pkg-config descriptor
-zlib.pc.cmakein zlib.pc template for cmake
-zlib2ansi       perl script to convert source files for C++ compilation
-
-arch/		architecture-specific code
-doc/            documentation for formats and algorithms
-win32/          makefiles for Windows
-
-                zlib public header files (required for library use):
-zconf.h
-zlib.h
-
-                private source files used to build the zlib library:
-adler32.c
-compress.c
-crc32.c
-crc32.h
-deflate.c
-deflate.h
-gzclose.c
-gzguts.h
-gzlib.c
-gzread.c
-gzwrite.c
-infback.c
-inffast.c
-inffast.h
-inffixed.h
-inflate.c
-inflate.h
-inftrees.c
-inftrees.h
-trees.c
-trees.h
-uncompr.c
-zutil.c
-zutil.h
diff --git a/contrib/libzlib-ng/LICENSE.md b/contrib/libzlib-ng/LICENSE.md
deleted file mode 100644
index adb48d47296..00000000000
--- a/contrib/libzlib-ng/LICENSE.md
+++ /dev/null
@@ -1,19 +0,0 @@
-(C) 1995-2013 Jean-loup Gailly and Mark Adler
-
-This software is provided 'as-is', without any express or implied
-warranty. In no event will the authors be held liable for any damages
-arising from the use of this software.
-
-Permission is granted to anyone to use this software for any purpose,
-including commercial applications, and to alter it and redistribute it
-freely, subject to the following restrictions:
-
-1. The origin of this software must not be misrepresented; you must not
-   claim that you wrote the original software. If you use this software
-   in a product, an acknowledgment in the product documentation would be
-   appreciated but is not required.
-
-2. Altered source versions must be plainly marked as such, and must not be
-   misrepresented as being the original software.
-
-3. This notice may not be removed or altered from any source distribution.
diff --git a/contrib/libzlib-ng/Makefile.in b/contrib/libzlib-ng/Makefile.in
deleted file mode 100644
index c69175e2d9a..00000000000
--- a/contrib/libzlib-ng/Makefile.in
+++ /dev/null
@@ -1,329 +0,0 @@
-# Makefile for zlib
-# Copyright (C) 1995-2013 Jean-loup Gailly, Mark Adler
-# For conditions of distribution and use, see copyright notice in zlib.h
-
-# To compile and test, type:
-#    ./configure; make test
-# Normally configure builds both a static and a shared library.
-# If you want to build just a static library, use: ./configure --static
-
-# To install /usr/local/lib/libz.* and /usr/local/include/zlib.h, type:
-#    make install
-# To install in $HOME instead of /usr/local, use:
-#    make install prefix=$HOME
-
-CC=cc
-
-CFLAGS=-O
-#CFLAGS=-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7
-#CFLAGS=-g -DDEBUG
-#CFLAGS=-O3 -Wall -Wwrite-strings -Wpointer-arith -Wconversion \
-#           -Wstrict-prototypes -Wmissing-prototypes
-
-SFLAGS=-O
-LDFLAGS=
-TEST_LDFLAGS=-L. libz.a
-LDSHARED=$(CC)
-
-STATICLIB=libz.a
-SHAREDLIB=libz.so
-SHAREDLIBV=libz.so.1.2.8
-SHAREDLIBM=libz.so.1
-IMPORTLIB=
-SHAREDTARGET=libz.so.1.2.8
-
-LIBS=$(STATICLIB) $(SHAREDTARGET)
-
-AR=ar
-ARFLAGS=rc
-DEFFILE=
-RC=
-RCFLAGS=
-RCOBJS=
-STRIP=
-RANLIB=ranlib
-LDCONFIG=ldconfig
-LDSHAREDLIBC=-lc
-TAR=tar
-SHELL=/bin/sh
-EXE=
-
-SRCDIR=.
-INCLUDES=-I$(SRCDIR)
-
-ARCHDIR=arch/generic
-ARCH_STATIC_OBJS=
-ARCH_SHARED_OBJS=
-
-prefix = /usr/local
-exec_prefix = ${prefix}
-bindir = ${exec_prefix}/bin
-libdir = ${exec_prefix}/lib
-sharedlibdir = ${libdir}
-includedir = ${prefix}/include
-mandir = ${prefix}/share/man
-man3dir = ${mandir}/man3
-pkgconfigdir = ${libdir}/pkgconfig
-
-OBJZ = adler32.o compress.o crc32.o deflate.o deflate_fast.o deflate_medium.o deflate_slow.o match.o infback.o inffast.o inflate.o inftrees.o trees.o uncompr.o zutil.o $(ARCH_STATIC_OBJS)
-OBJG = gzclose.o gzlib.o gzread.o gzwrite.o
-OBJC = $(OBJZ) $(OBJG)
-
-PIC_OBJZ = adler32.lo compress.lo crc32.lo deflate.lo deflate_fast.lo deflate_medium.lo deflate_slow.lo match.lo infback.lo inffast.lo inflate.lo inftrees.lo trees.lo uncompr.lo zutil.lo $(ARCH_SHARED_OBJS)
-PIC_OBJG = gzclose.lo gzlib.lo gzread.lo gzwrite.lo
-PIC_OBJC = $(PIC_OBJZ) $(PIC_OBJG)
-
-OBJS = $(OBJC)
-
-PIC_OBJS = $(PIC_OBJC)
-
-all: static shared
-
-static: example$(EXE) minigzip$(EXE)
-
-shared: examplesh$(EXE) minigzipsh$(EXE)
-
-all64: example64$(EXE) minigzip64$(EXE)
-
-check: test
-
-$(ARCHDIR)/%.o: $(SRCDIR)/$(ARCHDIR)/%.c
-	$(MAKE) -C $(ARCHDIR) $(notdir $@)
-
-$(ARCHDIR)/%.lo: $(SRCDIR)/$(ARCHDIR)/%.c
-	$(MAKE) -C $(ARCHDIR) $(notdir $@)
-
-%.o: $(ARCHDIR)/%.o
-	-cp $< $@
-
-%.lo: $(ARCHDIR)/%.lo
-	-cp $< $@
-
-test: all
-	$(MAKE) -C test
-
-infcover.o: $(SRCDIR)/test/infcover.c $(SRCDIR)/zlib.h zconf.h
-	$(CC) $(CFLAGS) $(INCLUDES) -c -o $@ $(SRCDIR)/test/infcover.c
-
-infcover$(EXE): infcover.o $(STATICLIB)
-	$(CC) $(CFLAGS) -o $@ infcover.o $(STATICLIB)
-ifneq ($(STRIP),)
-	$(STRIP) $@
-endif
-
-cover: infcover$(EXE)
-	rm -f *.gcda
-	./infcover
-	gcov inf*.c
-
-$(STATICLIB): $(OBJS)
-	$(AR) $(ARFLAGS) $@ $(OBJS)
-	-@ ($(RANLIB) $@ || true) >/dev/null 2>&1
-
-example.o: $(SRCDIR)/test/example.c $(SRCDIR)/zlib.h zconf.h
-	$(CC) $(CFLAGS) $(INCLUDES) -c -o $@ $(SRCDIR)/test/example.c
-
-minigzip.o: $(SRCDIR)/test/minigzip.c $(SRCDIR)/zlib.h zconf.h
-	$(CC) $(CFLAGS) $(INCLUDES) -c -o $@ $(SRCDIR)/test/minigzip.c
-
-example64.o: $(SRCDIR)/test/example.c $(SRCDIR)/zlib.h zconf.h
-	$(CC) $(CFLAGS) $(INCLUDES) -D_FILE_OFFSET_BITS=64 -c -o $@ $(SRCDIR)/test/example.c
-
-minigzip64.o: $(SRCDIR)/test/minigzip.c $(SRCDIR)/zlib.h zconf.h
-	$(CC) $(CFLAGS) $(INCLUDES) -D_FILE_OFFSET_BITS=64 -c -o $@ $(SRCDIR)/test/minigzip.c
-
-zlibrc.o: win32/zlib1.rc
-	$(RC) $(RCFLAGS) -o $@ win32/zlib1.rc
-
-.SUFFIXES: .lo
-
-%.o: $(SRCDIR)/%.c
-	$(CC) $(INCLUDES) $(CFLAGS) -c -o $@ $<
-
-%.lo: $(SRCDIR)/%.c
-	$(CC) $(INCLUDES) $(SFLAGS) -DPIC -c -o $@ $<
-
-$(SHAREDTARGET): $(PIC_OBJS) $(DEFFILE) $(RCOBJS)
-ifneq ($(SHAREDTARGET),)
-	$(LDSHARED) $(SFLAGS) -o $@ $(DEFFILE) $(PIC_OBJS) $(RCOBJS) $(LDSHAREDLIBC) $(LDFLAGS)
-ifneq ($(STRIP),)
-	$(STRIP) $@
-endif
-ifneq ($(SHAREDLIB),$(SHAREDTARGET))
-	rm -f $(SHAREDLIB) $(SHAREDLIBM)
-	ln -s $@ $(SHAREDLIB)
-	ln -s $@ $(SHAREDLIBM)
-endif
-endif
-
-example$(EXE): example.o $(STATICLIB)
-	$(CC) $(CFLAGS) -o $@ example.o $(TEST_LDFLAGS)
-ifneq ($(STRIP),)
-	$(STRIP) $@
-endif
-
-minigzip$(EXE): minigzip.o $(STATICLIB)
-	$(CC) $(CFLAGS) -o $@ minigzip.o $(TEST_LDFLAGS)
-ifneq ($(STRIP),)
-	$(STRIP) $@
-endif
-
-examplesh$(EXE): example.o $(SHAREDTARGET)
-	$(CC) $(CFLAGS) -o $@ example.o -L. $(SHAREDTARGET)
-ifneq ($(STRIP),)
-	$(STRIP) $@
-endif
-
-minigzipsh$(EXE): minigzip.o $(SHAREDTARGET)
-	$(CC) $(CFLAGS) -o $@ minigzip.o -L. $(SHAREDTARGET)
-ifneq ($(STRIP),)
-	$(STRIP) $@
-endif
-
-example64$(EXE): example64.o $(STATICLIB)
-	$(CC) $(CFLAGS) -o $@ example64.o $(TEST_LDFLAGS)
-ifneq ($(STRIP),)
-	$(STRIP) $@
-endif
-
-minigzip64$(EXE): minigzip64.o $(STATICLIB)
-	$(CC) $(CFLAGS) -o $@ minigzip64.o $(TEST_LDFLAGS)
-ifneq ($(STRIP),)
-	$(STRIP) $@
-endif
-
-install-shared: $(SHAREDTARGET)
-ifneq ($(SHAREDTARGET),)
-	-@if [ ! -d $(DESTDIR)$(sharedlibdir) ]; then mkdir -p $(DESTDIR)$(sharedlibdir); fi
-	cp $(SHAREDTARGET) $(DESTDIR)$(sharedlibdir)
-	chmod 644 $(DESTDIR)$(sharedlibdir)/$(SHAREDTARGET)
-ifneq ($(SHAREDLIB),$(SHAREDTARGET))
-	rm -f $(DESTDIR)$(sharedlibdir)/$(SHAREDLIB) $(DESTDIR)$(sharedlibdir)/$(SHAREDLIBM)
-	ln -s $(SHAREDLIBV) $(DESTDIR)$(sharedlibdir)/$(SHAREDLIB)
-	ln -s $(SHAREDLIBV) $(DESTDIR)$(sharedlibdir)/$(SHAREDLIBM)
-	($(LDCONFIG) || true)  >/dev/null 2>&1
-# ldconfig is for Linux
-endif
-ifneq ($(IMPORTLIB),)
-	cp $(IMPORTLIB) $(DESTDIR)$(sharedlibdir)
-	chmod 644 $(DESTDIR)$(sharedlibdir)/$(IMPORTLIB)
-endif
-endif
-
-install-static: $(STATICLIB)
-	-@if [ ! -d $(DESTDIR)$(libdir)       ]; then mkdir -p $(DESTDIR)$(libdir); fi
-	cp $(STATICLIB) $(DESTDIR)$(libdir)
-	chmod 644 $(DESTDIR)$(libdir)/$(STATICLIB)
-	-@($(RANLIB) $(DESTDIR)$(libdir)/$(STATICLIB) || true) >/dev/null 2>&1
-# The ranlib in install-static is needed on NeXTSTEP which checks file times
-
-install-libs: install-shared install-static
-	-@if [ ! -d $(DESTDIR)$(man3dir)      ]; then mkdir -p $(DESTDIR)$(man3dir); fi
-	-@if [ ! -d $(DESTDIR)$(pkgconfigdir) ]; then mkdir -p $(DESTDIR)$(pkgconfigdir); fi
-	cp $(SRCDIR)/zlib.3 $(DESTDIR)$(man3dir)
-	chmod 644 $(DESTDIR)$(man3dir)/zlib.3
-	cp zlib.pc $(DESTDIR)$(pkgconfigdir)
-	chmod 644 $(DESTDIR)$(pkgconfigdir)/zlib.pc
-
-install: install-libs
-	-@if [ ! -d $(DESTDIR)$(includedir)   ]; then mkdir -p $(DESTDIR)$(includedir); fi
-	cp $(SRCDIR)/zlib.h zconf.h $(DESTDIR)$(includedir)
-	chmod 644 $(DESTDIR)$(includedir)/zlib.h $(DESTDIR)$(includedir)/zconf.h
-
-uninstall-static:
-	cd $(DESTDIR)$(libdir) && rm -f $(STATICLIB)
-
-uninstall-shared:
-ifneq ($(SHAREDLIB),)
-	cd $(DESTDIR)$(sharedlibdir) && rm -f $(SHAREDLIBV) $(SHAREDLIB) $(SHAREDLIBM)
-endif
-ifneq ($(IMPORTLIB),)
-	cd $(DESTDIR)$(sharedlibdir) && rm -f $(IMPORTLIB)
-endif
-
-uninstall: uninstall-static uninstall-shared
-	cd $(DESTDIR)$(includedir) && rm -f zlib.h zconf.h
-	cd $(DESTDIR)$(man3dir) && rm -f zlib.3
-	cd $(DESTDIR)$(pkgconfigdir) && rm -f zlib.pc
-
-docs: zlib.3.pdf
-
-zlib.3.pdf: $(SRCDIR)/zlib.3
-	groff -mandoc -f H -T ps $(SRCDIR)/zlib.3 | ps2pdf - zlib.3.pdf
-
-mostlyclean: clean
-clean:
-	@if [ -f $(ARCHDIR)/Makefile ]; then $(MAKE) -C $(ARCHDIR) clean; fi
-	@if [ -f test/Makefile ]; then $(MAKE) -C test clean; fi
-	rm -f *.o *.lo *~ \
-	   example$(EXE) minigzip$(EXE) examplesh$(EXE) minigzipsh$(EXE) \
-	   example64$(EXE) minigzip64$(EXE) \
-	   infcover \
-	   $(STATICLIB) $(IMPORTLIB) $(SHAREDLIB) $(SHAREDLIBV) $(SHAREDLIBM) \
-	   foo.gz so_locations \
-	   _match.s maketree
-	rm -rf objs
-	rm -f *.gcda *.gcno *.gcov
-	rm -f a.out
-
-maintainer-clean: distclean
-distclean: clean
-	@if [ -f $(ARCHDIR)/Makefile ]; then $(MAKE) -C $(ARCHDIR) distclean; fi
-	@if [ -f test/Makefile ]; then $(MAKE) -C test distclean; fi
-	rm -f zlib.pc configure.log zconf.h zconf.h.cmakein
-	-@rm -f .DS_Store
-# Reset Makefile if building inside source tree
-	@if [ -f Makefile.in ]; then \
-	printf 'all:\n\t-@echo "Please use ./configure first.  Thank you."\n' > Makefile ; \
-	printf '\ndistclean:\n\tmake -f Makefile.in distclean\n' >> Makefile ; \
-	touch -r $(SRCDIR)/Makefile.in Makefile ; fi
-# Reset zconf.h and zconf.h.cmakein if building inside source tree
-	@if [ -f zconf.h.in ]; then \
-	cp -p $(SRCDIR)/zconf.h.in zconf.h ; \
-	TEMPFILE=zconfh_$$ ; \
-	echo "/#define ZCONF_H/ a\\\\\n#cmakedefine Z_HAVE_UNISTD_H\n" >> $$TEMPFILE &&\
-	sed -f $$TEMPFILE $(SRCDIR)/zconf.h.in > zconf.h.cmakein &&\
-	touch -r $(SRCDIR)/zconf.h.in zconf.h.cmakein &&\
-	rm $$TEMPFILE ; fi
-# Cleanup these files if building outside source tree
-	@if [ ! -f zlib.3 ]; then rm -f zlib.3.pdf Makefile; fi
-# Remove arch and test directory if building outside source tree
-	@if [ ! -f $(ARCHDIR)/Makefile.in ]; then rm -rf arch; fi
-	@if [ ! -f test/Makefile.in ]; then rm -rf test; fi
-
-tags:
-	etags $(SRCDIR)/*.[ch]
-
-depend:
-	makedepend -- $(CFLAGS) -- $(SRCDIR)/*.[ch]
-	makedepend -a -o.lo -- $(SFLAGS) -- $(SRCDIR)/*.[ch]
-	@sed "s=^$(SRCDIR)/\([a-zA-Z0-9_]*\.\(lo\|o\):\)=\1=g" < Makefile > Makefile.tmp
-	@mv -f Makefile.tmp Makefile
-
-# DO NOT DELETE THIS LINE -- make depend depends on it.
-
-adler32.o zutil.o: $(SRCDIR)/zutil.h $(SRCDIR)/zlib.h zconf.h
-gzclose.o gzlib.o gzread.o gzwrite.o: $(SRCDIR)/zlib.h zconf.h $(SRCDIR)/gzguts.h
-compress.o example.o minigzip.o uncompr.o: $(SRCDIR)/zlib.h zconf.h
-crc32.o: $(SRCDIR)/zutil.h $(SRCDIR)/zlib.h zconf.h $(SRCDIR)/crc32.h
-deflate.o: $(SRCDIR)/deflate.h $(SRCDIR)/deflate_p.h $(SRCDIR)/match.h $(SRCDIR)/zutil.h $(SRCDIR)/zlib.h zconf.h
-deflate_fast.o: $(SRCDIR)/deflate.h $(SRCDIR)/deflate_p.h $(SRCDIR)/match.h
-deflate_medium.o: $(SRCDIR)/deflate.h $(SRCDIR)/deflate_p.h $(SRCDIR)/match.h
-deflate_slow.o: $(SRCDIR)/deflate.h $(SRCDIR)/deflate_p.h $(SRCDIR)/match.h
-infback.o inflate.o: $(SRCDIR)/zutil.h $(SRCDIR)/zlib.h zconf.h $(SRCDIR)/inftrees.h $(SRCDIR)/inflate.h $(SRCDIR)/inffast.h $(SRCDIR)/inffixed.h
-inffast.o: $(SRCDIR)/zutil.h $(SRCDIR)/zlib.h zconf.h $(SRCDIR)/inftrees.h $(SRCDIR)/inflate.h $(SRCDIR)/inffast.h
-inftrees.o: $(SRCDIR)/zutil.h $(SRCDIR)/zlib.h zconf.h $(SRCDIR)/inftrees.h
-trees.o: $(SRCDIR)/deflate.h $(SRCDIR)/zutil.h $(SRCDIR)/zlib.h zconf.h $(SRCDIR)/trees.h
-
-adler32.lo zutil.lo: $(SRCDIR)/zutil.h $(SRCDIR)/zlib.h zconf.h
-gzclose.lo gzlib.lo gzread.lo gzwrite.lo: $(SRCDIR)/zlib.h zconf.h $(SRCDIR)/gzguts.h
-compress.lo example.lo minigzip.lo uncompr.lo: $(SRCDIR)/zlib.h zconf.h
-crc32.lo: $(SRCDIR)/zutil.h $(SRCDIR)/zlib.h zconf.h $(SRCDIR)/crc32.h
-deflate.lo: $(SRCDIR)/deflate.h $(SRCDIR)/deflate_p.h $(SRCDIR)/match.h $(SRCDIR)/zutil.h $(SRCDIR)/zlib.h zconf.h
-deflate_fast.lo: $(SRCDIR)/deflate.h $(SRCDIR)/deflate_p.h $(SRCDIR)/match.h
-deflate_medium.lo: $(SRCDIR)/deflate.h $(SRCDIR)/deflate_p.h $(SRCDIR)/match.h
-deflate_slow.lo: $(SRCDIR)/deflate.h $(SRCDIR)/deflate_p.h $(SRCDIR)/match.h
-infback.lo inflate.lo: $(SRCDIR)/zutil.h $(SRCDIR)/zlib.h zconf.h $(SRCDIR)/inftrees.h $(SRCDIR)/inflate.h $(SRCDIR)/inffast.h $(SRCDIR)/inffixed.h
-inffast.lo: $(SRCDIR)/zutil.h $(SRCDIR)/zlib.h zconf.h $(SRCDIR)/inftrees.h $(SRCDIR)/inflate.h $(SRCDIR)/inffast.h
-inftrees.lo: $(SRCDIR)/zutil.h $(SRCDIR)/zlib.h zconf.h $(SRCDIR)/inftrees.h
-trees.lo: $(SRCDIR)/deflate.h $(SRCDIR)/zutil.h $(SRCDIR)/zlib.h zconf.h $(SRCDIR)/trees.h
diff --git a/contrib/libzlib-ng/README b/contrib/libzlib-ng/README
deleted file mode 100644
index db98f1112fb..00000000000
--- a/contrib/libzlib-ng/README
+++ /dev/null
@@ -1,63 +0,0 @@
-zlib-ng - zlib for the next generation systems
-
-Maintained by Hans Kristian Rosbach
-          aka Dead2 (zlib-ng àt circlestorm dót org)
-
-
-Fork Motivation and History
----------------------------
-
-The motivation for this fork was due to seeing several 3rd party
-contributions containing new optimizations not getting implemented
-into the official zlib repository.
-
-Mark Adler has been maintaining zlib for a very long time, and he has
-done a great job and hopefully he will continue for a long time yet.
-The idea of zlib-ng is not to replace zlib, but to co-exist as a
-drop-in replacement with a lower threshold for code change.
-
-zlib has a long history and is incredibly portable, even supporting
-lots of systems that predate the Internet. This is great, but it does
-complicate further development and maintainability.
-The zlib code has to make numerous workarounds for old compilers that
-do not understand ANSI-C or to accommodate systems with limitations
-such as operating in a 16-bit environment.
-
-Many of these workarounds are only maintenance burdens, some of them
-are pretty huge code-wise. For example, the [v]s[n]printf workaround
-code has a whopping 8 different implementations just to cater to
-various old compilers. With this many workarounds cluttered throughout
-the code, new programmers with an idea/interest for zlib will need
-to take some time to figure out why all of these seemingly strange
-things are used, and how to work within those confines.
-
-So I decided to make a fork, merge all the Intel optimizations, merge
-the Cloudflare optimizations that did not conflict, plus a couple
-of other smaller patches. Then I started cleaning out workarounds,
-various dead code, all contrib and example code as there is little
-point in having those in this fork for different reasons.
-
-Lastly I have been cleaning up the handling of different arches,
-so that it will be easier to implement arch-specific code without
-cluttering up the main code too much.
-
-Now, there is still a lot to do and I am sure there are better ways
-of doing several of the changes I have done. And I would be delighted
-to receive patches, preferably as pull requests on github.
-Just remember that any code you submit must be your own and it must
-be zlib licensed.
-
-Please read LICENSE.md, it is very simple and very liberal.
-
-
-Acknowledgments
-----------------
-
-Big thanks to Raske Sider AS / raskesider.no for sponsoring my
-maintainership of zlib-ng.
-
-The deflate format used by zlib was defined by Phil Katz.
-The deflate and zlib specifications were written by L. Peter Deutsch.
-
-zlib was originally created by Jean-loup Gailly (compression)
-and Mark Adler (decompression).
diff --git a/contrib/libzlib-ng/README.clickhouse b/contrib/libzlib-ng/README.clickhouse
deleted file mode 100644
index 82f318a88ee..00000000000
--- a/contrib/libzlib-ng/README.clickhouse
+++ /dev/null
@@ -1,12 +0,0 @@
-Sources imported from https://github.com/Dead2/zlib-ng/tree/343c4c549107d31f6eeabfb4b31bec4502a2ea0e
-CMakeLists.txt taken from https://github.com/mtl1979/zlib-ng/tree/ad8868ab0e78a87fb0485d4bc67b8cfe96e00891
-
-Zlib with CloudFlare patches provides slightly better performance for decompression and compression
-with level > 1. Unfortunately, we can't use that version due to GPL-licensed code. If you still
-want to use it, replace contents of this directory with contents of https://github.com/cloudflare/zlib
-and add the following lines at the beginning of CMakeLists.txt:
-
-set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wno-unused-variable -DHAS_PCLMUL")
-set (ZLIB_ASMS
-	contrib/amd64/crc32-pclmul_asm.S
-)
diff --git a/contrib/libzlib-ng/README.md b/contrib/libzlib-ng/README.md
deleted file mode 100644
index 35ea0545568..00000000000
--- a/contrib/libzlib-ng/README.md
+++ /dev/null
@@ -1,65 +0,0 @@
-Travis CI: [![build status](https://api.travis-ci.org/Dead2/zlib-ng.svg)](https://travis-ci.org/Dead2/zlib-ng/)
-
-zlib-ng - zlib for the next generation systems
-
-Maintained by Hans Kristian Rosbach
-          aka Dead2 (zlib-ng àt circlestorm dót org)
-
-
-Fork Motivation and History
----------------------------
-
-The motivation for this fork was due to seeing several 3rd party
-contributions containing new optimizations not getting implemented
-into the official zlib repository.
-
-Mark Adler has been maintaining zlib for a very long time, and he has
-done a great job and hopefully he will continue for a long time yet.
-The idea of zlib-ng is not to replace zlib, but to co-exist as a
-drop-in replacement with a lower threshold for code change.
-
-zlib has a long history and is incredibly portable, even supporting
-lots of systems that predate the Internet. This is great, but it does
-complicate further development and maintainability.
-The zlib code has to make numerous workarounds for old compilers that
-do not understand ANSI-C or to accommodate systems with limitations
-such as operating in a 16-bit environment.
-
-Many of these workarounds are only maintenance burdens, some of them
-are pretty huge code-wise. For example, the [v]s[n]printf workaround
-code has a whopping 8 different implementations just to cater to
-various old compilers. With this many workarounds cluttered throughout
-the code, new programmers with an idea/interest for zlib will need
-to take some time to figure out why all of these seemingly strange
-things are used, and how to work within those confines.
-
-So I decided to make a fork, merge all the Intel optimizations, merge
-the Cloudflare optimizations that did not conflict, plus a couple
-of other smaller patches. Then I started cleaning out workarounds,
-various dead code, all contrib and example code as there is little
-point in having those in this fork for different reasons.
-
-Lastly I have been cleaning up the handling of different arches,
-so that it will be easier to implement arch-specific code without
-cluttering up the main code too much.
-
-Now, there is still a lot to do and I am sure there are better ways
-of doing several of the changes I have done. And I would be delighted
-to receive patches, preferably as pull requests on github.
-Just remember that any code you submit must be your own and it must
-be zlib licensed.
-
-Please read LICENSE.md, it is very simple and very liberal.
-
-
-Acknowledgments
-----------------
-
-Big thanks to Raske Sider AS / raskesider.no for sponsoring my
-maintainership of zlib-ng.
-
-The deflate format used by zlib was defined by Phil Katz.
-The deflate and zlib specifications were written by L. Peter Deutsch.
-
-zlib was originally created by Jean-loup Gailly (compression)
-and Mark Adler (decompression).
diff --git a/contrib/libzlib-ng/README.zlib b/contrib/libzlib-ng/README.zlib
deleted file mode 100644
index 200579260ac..00000000000
--- a/contrib/libzlib-ng/README.zlib
+++ /dev/null
@@ -1,121 +0,0 @@
-## 
-# THIS IS AN UNMAINTAINED COPY OF THE ORIGINAL FILE DISTRIBUTED WITH ZLIB 1.2.8
-## 
-
-
-
-ZLIB DATA COMPRESSION LIBRARY
-
-zlib 1.2.8 is a general purpose data compression library.  All the code is
-thread safe.  The data format used by the zlib library is described by RFCs
-(Request for Comments) 1950 to 1952 in the files
-http://tools.ietf.org/html/rfc1950 (zlib format), rfc1951 (deflate format) and
-rfc1952 (gzip format).
-
-All functions of the compression library are documented in the file zlib.h
-(volunteer to write man pages welcome, contact zlib@gzip.org).  A usage example
-of the library is given in the file test/example.c which also tests that
-the library is working correctly.  Another example is given in the file
-test/minigzip.c.  The compression library itself is composed of all source
-files in the root directory.
-
-To compile all files and run the test program, follow the instructions given at
-the top of Makefile.in.  In short "./configure; make test", and if that goes
-well, "make install" should work for most flavors of Unix.  For Windows, use
-one of the special makefiles in win32/ or contrib/vstudio/ .  For VMS, use
-make_vms.com.
-
-Questions about zlib should be sent to <zlib@gzip.org>, or to Gilles Vollant
-<info@winimage.com> for the Windows DLL version.  The zlib home page is
-http://zlib.net/ .  Before reporting a problem, please check this site to
-verify that you have the latest version of zlib; otherwise get the latest
-version and check whether the problem still exists or not.
-
-PLEASE read the zlib FAQ http://zlib.net/zlib_faq.html before asking for help.
-
-Mark Nelson <markn@ieee.org> wrote an article about zlib for the Jan.  1997
-issue of Dr.  Dobb's Journal; a copy of the article is available at
-http://marknelson.us/1997/01/01/zlib-engine/ .
-
-The changes made in version 1.2.8 are documented in the file ChangeLog.
-
-Unsupported third party contributions are provided in directory contrib/ .
-
-zlib is available in Java using the java.util.zip package, documented at
-http://java.sun.com/developer/technicalArticles/Programming/compression/ .
-
-A Perl interface to zlib written by Paul Marquess <pmqs@cpan.org> is available
-at CPAN (Comprehensive Perl Archive Network) sites, including
-http://search.cpan.org/~pmqs/IO-Compress-Zlib/ .
-
-A Python interface to zlib written by A.M. Kuchling <amk@amk.ca> is
-available in Python 1.5 and later versions, see
-http://docs.python.org/library/zlib.html .
-
-zlib is built into tcl: http://wiki.tcl.tk/4610 .
-
-An experimental package to read and write files in .zip format, written on top
-of zlib by Gilles Vollant <info@winimage.com>, is available in the
-contrib/minizip directory of zlib.
-
-
-Notes for some targets:
-
-- For Windows DLL versions, please see win32/DLL_FAQ.txt
-
-- For 64-bit Irix, deflate.c must be compiled without any optimization. With
-  -O, one libpng test fails. The test works in 32 bit mode (with the -n32
-  compiler flag). The compiler bug has been reported to SGI.
-
-- zlib doesn't work with gcc 2.6.3 on a DEC 3000/300LX under OSF/1 2.1 it works
-  when compiled with cc.
-
-- On Digital Unix 4.0D (formely OSF/1) on AlphaServer, the cc option -std1 is
-  necessary to get gzprintf working correctly. This is done by configure.
-
-- zlib doesn't work on HP-UX 9.05 with some versions of /bin/cc. It works with
-  other compilers. Use "make test" to check your compiler.
-
-- gzdopen is not supported on RISCOS or BEOS.
-
-- For PalmOs, see http://palmzlib.sourceforge.net/
-
-
-Acknowledgments:
-
-  The deflate format used by zlib was defined by Phil Katz.  The deflate and
-  zlib specifications were written by L.  Peter Deutsch.  Thanks to all the
-  people who reported problems and suggested various improvements in zlib; they
-  are too numerous to cite here.
-
-Copyright notice:
-
- (C) 1995-2013 Jean-loup Gailly and Mark Adler
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-
-  Jean-loup Gailly        Mark Adler
-  jloup@gzip.org          madler@alumni.caltech.edu
-
-If you use the zlib library in a product, we would appreciate *not* receiving
-lengthy legal documents to sign.  The sources are provided for free but without
-warranty of any kind.  The library has been entirely written by Jean-loup
-Gailly and Mark Adler; it does not include third-party code.
-
-If you redistribute modified sources, we would appreciate that you include in
-the file ChangeLog history information documenting your changes.  Please read
-the FAQ for more information on the distribution of modified source versions.
diff --git a/contrib/libzlib-ng/adler32.c b/contrib/libzlib-ng/adler32.c
deleted file mode 100644
index 495101dd5d0..00000000000
--- a/contrib/libzlib-ng/adler32.c
+++ /dev/null
@@ -1,177 +0,0 @@
-/* adler32.c -- compute the Adler-32 checksum of a data stream
- * Copyright (C) 1995-2011 Mark Adler
- * For conditions of distribution and use, see copyright notice in zlib.h
- */
-
-/* @(#) $Id$ */
-
-#include "zutil.h"
-
-static uint32_t adler32_combine_(uint32_t adler1, uint32_t adler2, z_off64_t len2);
-
-#define BASE 65521U     /* largest prime smaller than 65536 */
-#define NMAX 5552
-/* NMAX is the largest n such that 255n(n+1)/2 + (n+1)(BASE-1) <= 2^32-1 */
-
-#define DO1(buf, i)  {adler += (buf)[i]; sum2 += adler;}
-#define DO2(buf, i)  DO1(buf, i); DO1(buf, i+1);
-#define DO4(buf, i)  DO2(buf, i); DO2(buf, i+2);
-#define DO8(buf, i)  DO4(buf, i); DO4(buf, i+4);
-#define DO16(buf)    DO8(buf, 0); DO8(buf, 8);
-
-/* use NO_DIVIDE if your processor does not do division in hardware --
-   try it both ways to see which is faster */
-#ifdef NO_DIVIDE
-/* note that this assumes BASE is 65521, where 65536 % 65521 == 15
-   (thank you to John Reiser for pointing this out) */
-#  define CHOP(a) \
-    do { \
-        uint32_t tmp = a >> 16; \
-        a &= 0xffff; \
-        a += (tmp << 4) - tmp; \
-    } while (0)
-#  define MOD28(a) \
-    do { \
-        CHOP(a); \
-        if (a >= BASE) a -= BASE; \
-    } while (0)
-#  define MOD(a) \
-    do { \
-        CHOP(a); \
-        MOD28(a); \
-    } while (0)
-#  define MOD63(a) \
-    do { /* this assumes a is not negative */ \
-        z_off64_t tmp = a >> 32; \
-        a &= 0xffffffffL; \
-        a += (tmp << 8) - (tmp << 5) + tmp; \
-        tmp = a >> 16; \
-        a &= 0xffffL; \
-        a += (tmp << 4) - tmp; \
-        tmp = a >> 16; \
-        a &= 0xffffL; \
-        a += (tmp << 4) - tmp; \
-        if (a >= BASE) a -= BASE; \
-    } while (0)
-#else
-#  define MOD(a) a %= BASE
-#  define MOD28(a) a %= BASE
-#  define MOD63(a) a %= BASE
-#endif
-
-/* ========================================================================= */
-uint32_t ZEXPORT adler32(uint32_t adler, const unsigned char *buf, uint32_t len) {
-    uint32_t sum2;
-    unsigned n;
-
-    /* split Adler-32 into component sums */
-    sum2 = (adler >> 16) & 0xffff;
-    adler &= 0xffff;
-
-    /* in case user likes doing a byte at a time, keep it fast */
-    if (len == 1) {
-        adler += buf[0];
-        if (adler >= BASE)
-            adler -= BASE;
-        sum2 += adler;
-        if (sum2 >= BASE)
-            sum2 -= BASE;
-        return adler | (sum2 << 16);
-    }
-
-    /* initial Adler-32 value (deferred check for len == 1 speed) */
-    if (buf == Z_NULL)
-        return 1L;
-
-    /* in case short lengths are provided, keep it somewhat fast */
-    if (len < 16) {
-        while (len--) {
-            adler += *buf++;
-            sum2 += adler;
-        }
-        if (adler >= BASE)
-            adler -= BASE;
-        MOD28(sum2);            /* only added so many BASE's */
-        return adler | (sum2 << 16);
-    }
-
-    /* do length NMAX blocks -- requires just one modulo operation */
-    while (len >= NMAX) {
-        len -= NMAX;
-#ifndef UNROLL_LESS
-        n = NMAX / 16;          /* NMAX is divisible by 16 */
-#else
-        n = NMAX / 8;           /* NMAX is divisible by 8 */
-#endif
-        do {
-#ifndef UNROLL_LESS
-            DO16(buf);          /* 16 sums unrolled */
-            buf += 16;
-#else
-            DO8(buf, 0);         /* 8 sums unrolled */
-            buf += 8;
-#endif
-        } while (--n);
-        MOD(adler);
-        MOD(sum2);
-    }
-
-    /* do remaining bytes (less than NMAX, still just one modulo) */
-    if (len) {                  /* avoid modulos if none remaining */
-#ifndef UNROLL_LESS
-        while (len >= 16) {
-            len -= 16;
-            DO16(buf);
-            buf += 16;
-#else
-        while (len >= 8) {
-            len -= 8;
-            DO8(buf, 0);
-            buf += 8;
-#endif
-        }
-        while (len--) {
-            adler += *buf++;
-            sum2 += adler;
-        }
-        MOD(adler);
-        MOD(sum2);
-    }
-
-    /* return recombined sums */
-    return adler | (sum2 << 16);
-}
-
-/* ========================================================================= */
-static uint32_t adler32_combine_(uint32_t adler1, uint32_t adler2, z_off64_t len2) {
-    uint32_t sum1;
-    uint32_t sum2;
-    unsigned rem;
-
-    /* for negative len, return invalid adler32 as a clue for debugging */
-    if (len2 < 0)
-        return 0xffffffff;
-
-    /* the derivation of this formula is left as an exercise for the reader */
-    MOD63(len2);                /* assumes len2 >= 0 */
-    rem = (unsigned)len2;
-    sum1 = adler1 & 0xffff;
-    sum2 = rem * sum1;
-    MOD(sum2);
-    sum1 += (adler2 & 0xffff) + BASE - 1;
-    sum2 += ((adler1 >> 16) & 0xffff) + ((adler2 >> 16) & 0xffff) + BASE - rem;
-    if (sum1 >= BASE) sum1 -= BASE;
-    if (sum1 >= BASE) sum1 -= BASE;
-    if (sum2 >= ((unsigned long)BASE << 1)) sum2 -= ((unsigned long)BASE << 1);
-    if (sum2 >= BASE) sum2 -= BASE;
-    return sum1 | (sum2 << 16);
-}
-
-/* ========================================================================= */
-uint32_t ZEXPORT adler32_combine(uint32_t adler1, uint32_t adler2, z_off_t len2) {
-    return adler32_combine_(adler1, adler2, len2);
-}
-
-uint32_t ZEXPORT adler32_combine64(uint32_t adler1, uint32_t adler2, z_off64_t len2) {
-    return adler32_combine_(adler1, adler2, len2);
-}
diff --git a/contrib/libzlib-ng/arch/.gitignore b/contrib/libzlib-ng/arch/.gitignore
deleted file mode 100644
index 2c3af0a08cb..00000000000
--- a/contrib/libzlib-ng/arch/.gitignore
+++ /dev/null
@@ -1,2 +0,0 @@
-# ignore Makefiles; they're all automatically generated
-Makefile
diff --git a/contrib/libzlib-ng/arch/arm/Makefile.in b/contrib/libzlib-ng/arch/arm/Makefile.in
deleted file mode 100644
index 759a1213ba8..00000000000
--- a/contrib/libzlib-ng/arch/arm/Makefile.in
+++ /dev/null
@@ -1,20 +0,0 @@
-# Makefile for zlib
-# Copyright (C) 1995-2013 Jean-loup Gailly, Mark Adler
-# For conditions of distribution and use, see copyright notice in zlib.h
-
-CC=
-CFLAGS=
-SFLAGS=
-INCLUDES=
-
-SRCDIR=
-SRCTOP=
-
-all:
-
-
-mostlyclean: clean
-clean:
-	rm -f *.o *.lo *~ \
-	rm -rf objs
-	rm -f *.gcda *.gcno *.gcov
diff --git a/contrib/libzlib-ng/arch/generic/Makefile.in b/contrib/libzlib-ng/arch/generic/Makefile.in
deleted file mode 100644
index 759a1213ba8..00000000000
--- a/contrib/libzlib-ng/arch/generic/Makefile.in
+++ /dev/null
@@ -1,20 +0,0 @@
-# Makefile for zlib
-# Copyright (C) 1995-2013 Jean-loup Gailly, Mark Adler
-# For conditions of distribution and use, see copyright notice in zlib.h
-
-CC=
-CFLAGS=
-SFLAGS=
-INCLUDES=
-
-SRCDIR=
-SRCTOP=
-
-all:
-
-
-mostlyclean: clean
-clean:
-	rm -f *.o *.lo *~ \
-	rm -rf objs
-	rm -f *.gcda *.gcno *.gcov
diff --git a/contrib/libzlib-ng/arch/x86/INDEX b/contrib/libzlib-ng/arch/x86/INDEX
deleted file mode 100644
index 9ee3802a2cd..00000000000
--- a/contrib/libzlib-ng/arch/x86/INDEX
+++ /dev/null
@@ -1,3 +0,0 @@
-fill_window_sse.c	SSE2 optimized fill_window
-deflate_quick.c		SSE4 optimized deflate strategy for use as level 1
-crc_folding.c		SSE4 + PCLMULQDQ optimized CRC folding implementation
diff --git a/contrib/libzlib-ng/arch/x86/Makefile.in b/contrib/libzlib-ng/arch/x86/Makefile.in
deleted file mode 100644
index 3604ba85226..00000000000
--- a/contrib/libzlib-ng/arch/x86/Makefile.in
+++ /dev/null
@@ -1,53 +0,0 @@
-# Makefile for zlib
-# Copyright (C) 1995-2013 Jean-loup Gailly, Mark Adler
-# For conditions of distribution and use, see copyright notice in zlib.h
-
-CC=
-CFLAGS=
-SFLAGS=
-INCLUDES=
-
-SRCDIR=
-SRCTOP=
-
-all: x86.o x86.lo fill_window_sse.o fill_window_sse.lo deflate_quick.o deflate_quick.lo insert_string_sse.o insert_string_sse.lo crc_folding.o crc_folding.lo
-
-x86.o:
-	$(CC) $(CFLAGS) $(INCLUDES) -c -o $@ $(SRCDIR)/x86.c
-
-x86.lo:
-	$(CC) $(SFLAGS) $(INCLUDES) -c -o $@ $(SRCDIR)/x86.c
-
-fill_window_sse.o:
-	$(CC) $(CFLAGS) -msse2 $(INCLUDES) -c -o $@ $(SRCDIR)/fill_window_sse.c
-
-fill_window_sse.lo:
-	$(CC) $(SFLAGS) -msse2 -DPIC $(INCLUDES) -c -o $@ $(SRCDIR)/fill_window_sse.c
-
-deflate_quick.o:
-	$(CC) $(CFLAGS) -msse4 $(INCLUDES) -c -o $@ $(SRCDIR)/deflate_quick.c
-
-deflate_quick.lo:
-	$(CC) $(SFLAGS) -msse4 -DPIC $(INCLUDES) -c -o $@ $(SRCDIR)/deflate_quick.c
-
-insert_string_sse.o:
-	$(CC) $(CFLAGS) -msse4 $(INCLUDES) -c -o $@ $(SRCDIR)/insert_string_sse.c
-
-insert_string_sse.lo:
-	$(CC) $(SFLAGS) -msse4 -DPIC $(INCLUDES) -c -o $@ $(SRCDIR)/insert_string_sse.c
-
-crc_folding.o:
-	$(CC) $(CFLAGS) -mpclmul -msse4 $(INCLUDES) -c -o $@ $(SRCDIR)/crc_folding.c
-
-crc_folding.lo:
-	$(CC) $(SFLAGS) -mpclmul -msse4 -DPIC $(INCLUDES) -c -o $@ $(SRCDIR)/crc_folding.c
-
-
-mostlyclean: clean
-clean:
-	rm -f *.o *.lo *~ \
-	rm -rf objs
-	rm -f *.gcda *.gcno *.gcov
-
-distclean:
-	rm -f Makefile
diff --git a/contrib/libzlib-ng/arch/x86/crc_folding.c b/contrib/libzlib-ng/arch/x86/crc_folding.c
deleted file mode 100644
index b1fb6ec3a35..00000000000
--- a/contrib/libzlib-ng/arch/x86/crc_folding.c
+++ /dev/null
@@ -1,465 +0,0 @@
-/*
- * Compute the CRC32 using a parallelized folding approach with the PCLMULQDQ 
- * instruction.
- *
- * A white paper describing this algorithm can be found at:
- * http://www.intel.com/content/dam/www/public/us/en/documents/white-papers/fast-crc-computation-generic-polynomials-pclmulqdq-paper.pdf
- *
- * Copyright (C) 2013 Intel Corporation. All rights reserved.
- * Authors:
- *     Wajdi Feghali   <wajdi.k.feghali@intel.com>
- *     Jim Guilford    <james.guilford@intel.com>
- *     Vinodh Gopal    <vinodh.gopal@intel.com>
- *     Erdinc Ozturk   <erdinc.ozturk@intel.com>
- *     Jim Kukunas     <james.t.kukunas@linux.intel.com>
- *
- * For conditions of distribution and use, see copyright notice in zlib.h
- */
-
-#ifdef X86_PCLMULQDQ_CRC
-
-#include <inttypes.h>
-#include <immintrin.h>
-#include <wmmintrin.h>
-
-#include "deflate.h"
-
-
-#define CRC_LOAD(s) \
-    do { \
-        __m128i xmm_crc0 = _mm_loadu_si128((__m128i *)s->crc0 + 0);\
-        __m128i xmm_crc1 = _mm_loadu_si128((__m128i *)s->crc0 + 1);\
-        __m128i xmm_crc2 = _mm_loadu_si128((__m128i *)s->crc0 + 2);\
-        __m128i xmm_crc3 = _mm_loadu_si128((__m128i *)s->crc0 + 3);\
-        __m128i xmm_crc_part = _mm_loadu_si128((__m128i *)s->crc0 + 4);
-
-#define CRC_SAVE(s) \
-        _mm_storeu_si128((__m128i *)s->crc0 + 0, xmm_crc0);\
-        _mm_storeu_si128((__m128i *)s->crc0 + 1, xmm_crc1);\
-        _mm_storeu_si128((__m128i *)s->crc0 + 2, xmm_crc2);\
-        _mm_storeu_si128((__m128i *)s->crc0 + 3, xmm_crc3);\
-        _mm_storeu_si128((__m128i *)s->crc0 + 4, xmm_crc_part);\
-    } while (0);
-
-ZLIB_INTERNAL void crc_fold_init(deflate_state *const s) {
-    CRC_LOAD(s)
-
-    xmm_crc0 = _mm_cvtsi32_si128(0x9db42487);
-    xmm_crc1 = _mm_setzero_si128();
-    xmm_crc2 = _mm_setzero_si128();
-    xmm_crc3 = _mm_setzero_si128();
-
-    CRC_SAVE(s)
-
-    s->strm->adler = 0;
-}
-
-local void fold_1(deflate_state *const s, __m128i *xmm_crc0, __m128i *xmm_crc1, __m128i *xmm_crc2, __m128i *xmm_crc3) {
-    const __m128i xmm_fold4 = _mm_set_epi32(
-            0x00000001, 0x54442bd4,
-            0x00000001, 0xc6e41596);
-
-    __m128i x_tmp3;
-    __m128 ps_crc0, ps_crc3, ps_res;
-
-    x_tmp3 = *xmm_crc3;
-
-    *xmm_crc3 = *xmm_crc0;
-    *xmm_crc0 = _mm_clmulepi64_si128(*xmm_crc0, xmm_fold4, 0x01);
-    *xmm_crc3 = _mm_clmulepi64_si128(*xmm_crc3, xmm_fold4, 0x10);
-    ps_crc0 = _mm_castsi128_ps(*xmm_crc0);
-    ps_crc3 = _mm_castsi128_ps(*xmm_crc3);
-    ps_res = _mm_xor_ps(ps_crc0, ps_crc3);
-
-    *xmm_crc0 = *xmm_crc1;
-    *xmm_crc1 = *xmm_crc2;
-    *xmm_crc2 = x_tmp3;
-    *xmm_crc3 = _mm_castps_si128(ps_res);
-}
-
-local void fold_2(deflate_state *const s, __m128i *xmm_crc0, __m128i *xmm_crc1, __m128i *xmm_crc2, __m128i *xmm_crc3) {
-    const __m128i xmm_fold4 = _mm_set_epi32(
-            0x00000001, 0x54442bd4,
-            0x00000001, 0xc6e41596);
-
-    __m128i x_tmp3, x_tmp2;
-    __m128 ps_crc0, ps_crc1, ps_crc2, ps_crc3, ps_res31, ps_res20;
-
-    x_tmp3 = *xmm_crc3;
-    x_tmp2 = *xmm_crc2;
-
-    *xmm_crc3 = *xmm_crc1;
-    *xmm_crc1 = _mm_clmulepi64_si128(*xmm_crc1, xmm_fold4, 0x01);
-    *xmm_crc3 = _mm_clmulepi64_si128(*xmm_crc3, xmm_fold4, 0x10);
-    ps_crc3 = _mm_castsi128_ps(*xmm_crc3);
-    ps_crc1 = _mm_castsi128_ps(*xmm_crc1);
-    ps_res31 = _mm_xor_ps(ps_crc3, ps_crc1);
-
-    *xmm_crc2 = *xmm_crc0;
-    *xmm_crc0 = _mm_clmulepi64_si128(*xmm_crc0, xmm_fold4, 0x01);
-    *xmm_crc2 = _mm_clmulepi64_si128(*xmm_crc2, xmm_fold4, 0x10);
-    ps_crc0 = _mm_castsi128_ps(*xmm_crc0);
-    ps_crc2 = _mm_castsi128_ps(*xmm_crc2);
-    ps_res20 = _mm_xor_ps(ps_crc0, ps_crc2);
-
-    *xmm_crc0 = x_tmp2;
-    *xmm_crc1 = x_tmp3;
-    *xmm_crc2 = _mm_castps_si128(ps_res20);
-    *xmm_crc3 = _mm_castps_si128(ps_res31);
-}
-
-local void fold_3(deflate_state *const s, __m128i *xmm_crc0, __m128i *xmm_crc1, __m128i *xmm_crc2, __m128i *xmm_crc3) {
-    const __m128i xmm_fold4 = _mm_set_epi32(
-            0x00000001, 0x54442bd4,
-            0x00000001, 0xc6e41596);
-
-    __m128i x_tmp3;
-    __m128 ps_crc0, ps_crc1, ps_crc2, ps_crc3, ps_res32, ps_res21, ps_res10;
-
-    x_tmp3 = *xmm_crc3;
-
-    *xmm_crc3 = *xmm_crc2;
-    *xmm_crc2 = _mm_clmulepi64_si128(*xmm_crc2, xmm_fold4, 0x01);
-    *xmm_crc3 = _mm_clmulepi64_si128(*xmm_crc3, xmm_fold4, 0x10);
-    ps_crc2 = _mm_castsi128_ps(*xmm_crc2);
-    ps_crc3 = _mm_castsi128_ps(*xmm_crc3);
-    ps_res32 = _mm_xor_ps(ps_crc2, ps_crc3);
-
-    *xmm_crc2 = *xmm_crc1;
-    *xmm_crc1 = _mm_clmulepi64_si128(*xmm_crc1, xmm_fold4, 0x01);
-    *xmm_crc2 = _mm_clmulepi64_si128(*xmm_crc2, xmm_fold4, 0x10);
-    ps_crc1 = _mm_castsi128_ps(*xmm_crc1);
-    ps_crc2 = _mm_castsi128_ps(*xmm_crc2);
-    ps_res21 = _mm_xor_ps(ps_crc1, ps_crc2);
-
-    *xmm_crc1 = *xmm_crc0;
-    *xmm_crc0 = _mm_clmulepi64_si128(*xmm_crc0, xmm_fold4, 0x01);
-    *xmm_crc1 = _mm_clmulepi64_si128(*xmm_crc1, xmm_fold4, 0x10);
-    ps_crc0 = _mm_castsi128_ps(*xmm_crc0);
-    ps_crc1 = _mm_castsi128_ps(*xmm_crc1);
-    ps_res10 = _mm_xor_ps(ps_crc0, ps_crc1);
-
-    *xmm_crc0 = x_tmp3;
-    *xmm_crc1 = _mm_castps_si128(ps_res10);
-    *xmm_crc2 = _mm_castps_si128(ps_res21);
-    *xmm_crc3 = _mm_castps_si128(ps_res32);
-}
-
-local void fold_4(deflate_state *const s, __m128i *xmm_crc0, __m128i *xmm_crc1, __m128i *xmm_crc2, __m128i *xmm_crc3) {
-    const __m128i xmm_fold4 = _mm_set_epi32(
-            0x00000001, 0x54442bd4,
-            0x00000001, 0xc6e41596);
-
-    __m128i x_tmp0, x_tmp1, x_tmp2, x_tmp3;
-    __m128 ps_crc0, ps_crc1, ps_crc2, ps_crc3;
-    __m128 ps_t0, ps_t1, ps_t2, ps_t3;
-    __m128 ps_res0, ps_res1, ps_res2, ps_res3;
-
-    x_tmp0 = *xmm_crc0;
-    x_tmp1 = *xmm_crc1;
-    x_tmp2 = *xmm_crc2;
-    x_tmp3 = *xmm_crc3;
-
-    *xmm_crc0 = _mm_clmulepi64_si128(*xmm_crc0, xmm_fold4, 0x01);
-    x_tmp0 = _mm_clmulepi64_si128(x_tmp0, xmm_fold4, 0x10);
-    ps_crc0 = _mm_castsi128_ps(*xmm_crc0);
-    ps_t0 = _mm_castsi128_ps(x_tmp0);
-    ps_res0 = _mm_xor_ps(ps_crc0, ps_t0);
-
-    *xmm_crc1 = _mm_clmulepi64_si128(*xmm_crc1, xmm_fold4, 0x01);
-    x_tmp1 = _mm_clmulepi64_si128(x_tmp1, xmm_fold4, 0x10);
-    ps_crc1 = _mm_castsi128_ps(*xmm_crc1);
-    ps_t1 = _mm_castsi128_ps(x_tmp1);
-    ps_res1 = _mm_xor_ps(ps_crc1, ps_t1);
-
-    *xmm_crc2 = _mm_clmulepi64_si128(*xmm_crc2, xmm_fold4, 0x01);
-    x_tmp2 = _mm_clmulepi64_si128(x_tmp2, xmm_fold4, 0x10);
-    ps_crc2 = _mm_castsi128_ps(*xmm_crc2);
-    ps_t2 = _mm_castsi128_ps(x_tmp2);
-    ps_res2 = _mm_xor_ps(ps_crc2, ps_t2);
-
-    *xmm_crc3 = _mm_clmulepi64_si128(*xmm_crc3, xmm_fold4, 0x01);
-    x_tmp3 = _mm_clmulepi64_si128(x_tmp3, xmm_fold4, 0x10);
-    ps_crc3 = _mm_castsi128_ps(*xmm_crc3);
-    ps_t3 = _mm_castsi128_ps(x_tmp3);
-    ps_res3 = _mm_xor_ps(ps_crc3, ps_t3);
-
-    *xmm_crc0 = _mm_castps_si128(ps_res0);
-    *xmm_crc1 = _mm_castps_si128(ps_res1);
-    *xmm_crc2 = _mm_castps_si128(ps_res2);
-    *xmm_crc3 = _mm_castps_si128(ps_res3);
-}
-
-local const unsigned ALIGNED_(32) pshufb_shf_table[60] = {
-    0x84838281, 0x88878685, 0x8c8b8a89, 0x008f8e8d, /* shl 15 (16 - 1)/shr1 */
-    0x85848382, 0x89888786, 0x8d8c8b8a, 0x01008f8e, /* shl 14 (16 - 3)/shr2 */
-    0x86858483, 0x8a898887, 0x8e8d8c8b, 0x0201008f, /* shl 13 (16 - 4)/shr3 */
-    0x87868584, 0x8b8a8988, 0x8f8e8d8c, 0x03020100, /* shl 12 (16 - 4)/shr4 */
-    0x88878685, 0x8c8b8a89, 0x008f8e8d, 0x04030201, /* shl 11 (16 - 5)/shr5 */
-    0x89888786, 0x8d8c8b8a, 0x01008f8e, 0x05040302, /* shl 10 (16 - 6)/shr6 */
-    0x8a898887, 0x8e8d8c8b, 0x0201008f, 0x06050403, /* shl  9 (16 - 7)/shr7 */
-    0x8b8a8988, 0x8f8e8d8c, 0x03020100, 0x07060504, /* shl  8 (16 - 8)/shr8 */
-    0x8c8b8a89, 0x008f8e8d, 0x04030201, 0x08070605, /* shl  7 (16 - 9)/shr9 */
-    0x8d8c8b8a, 0x01008f8e, 0x05040302, 0x09080706, /* shl  6 (16 -10)/shr10*/
-    0x8e8d8c8b, 0x0201008f, 0x06050403, 0x0a090807, /* shl  5 (16 -11)/shr11*/
-    0x8f8e8d8c, 0x03020100, 0x07060504, 0x0b0a0908, /* shl  4 (16 -12)/shr12*/
-    0x008f8e8d, 0x04030201, 0x08070605, 0x0c0b0a09, /* shl  3 (16 -13)/shr13*/
-    0x01008f8e, 0x05040302, 0x09080706, 0x0d0c0b0a, /* shl  2 (16 -14)/shr14*/
-    0x0201008f, 0x06050403, 0x0a090807, 0x0e0d0c0b  /* shl  1 (16 -15)/shr15*/
-};
-
-local void partial_fold(deflate_state *const s, const size_t len, __m128i *xmm_crc0, __m128i *xmm_crc1,
-        __m128i *xmm_crc2, __m128i *xmm_crc3, __m128i *xmm_crc_part) {
-
-    const __m128i xmm_fold4 = _mm_set_epi32(
-            0x00000001, 0x54442bd4,
-            0x00000001, 0xc6e41596);
-    const __m128i xmm_mask3 = _mm_set1_epi32(0x80808080);
-
-    __m128i xmm_shl, xmm_shr, xmm_tmp1, xmm_tmp2, xmm_tmp3;
-    __m128i xmm_a0_0, xmm_a0_1;
-    __m128 ps_crc3, psa0_0, psa0_1, ps_res;
-
-    xmm_shl = _mm_load_si128((__m128i *)pshufb_shf_table + (len - 1));
-    xmm_shr = xmm_shl;
-    xmm_shr = _mm_xor_si128(xmm_shr, xmm_mask3);
-
-    xmm_a0_0 = _mm_shuffle_epi8(*xmm_crc0, xmm_shl);
-
-    *xmm_crc0 = _mm_shuffle_epi8(*xmm_crc0, xmm_shr);
-    xmm_tmp1 = _mm_shuffle_epi8(*xmm_crc1, xmm_shl);
-    *xmm_crc0 = _mm_or_si128(*xmm_crc0, xmm_tmp1);
-
-    *xmm_crc1 = _mm_shuffle_epi8(*xmm_crc1, xmm_shr);
-    xmm_tmp2 = _mm_shuffle_epi8(*xmm_crc2, xmm_shl);
-    *xmm_crc1 = _mm_or_si128(*xmm_crc1, xmm_tmp2);
-
-    *xmm_crc2 = _mm_shuffle_epi8(*xmm_crc2, xmm_shr);
-    xmm_tmp3 = _mm_shuffle_epi8(*xmm_crc3, xmm_shl);
-    *xmm_crc2 = _mm_or_si128(*xmm_crc2, xmm_tmp3);
-
-    *xmm_crc3 = _mm_shuffle_epi8(*xmm_crc3, xmm_shr);
-    *xmm_crc_part = _mm_shuffle_epi8(*xmm_crc_part, xmm_shl);
-    *xmm_crc3 = _mm_or_si128(*xmm_crc3, *xmm_crc_part);
-
-    xmm_a0_1 = _mm_clmulepi64_si128(xmm_a0_0, xmm_fold4, 0x10);
-    xmm_a0_0 = _mm_clmulepi64_si128(xmm_a0_0, xmm_fold4, 0x01);
-
-    ps_crc3 = _mm_castsi128_ps(*xmm_crc3);
-    psa0_0 = _mm_castsi128_ps(xmm_a0_0);
-    psa0_1 = _mm_castsi128_ps(xmm_a0_1);
-
-    ps_res = _mm_xor_ps(ps_crc3, psa0_0);
-    ps_res = _mm_xor_ps(ps_res, psa0_1);
-
-    *xmm_crc3 = _mm_castps_si128(ps_res);
-}
-
-ZLIB_INTERNAL void crc_fold_copy(deflate_state *const s, unsigned char *dst, const unsigned char *src, long len) {
-    unsigned long algn_diff;
-    __m128i xmm_t0, xmm_t1, xmm_t2, xmm_t3;
-
-    CRC_LOAD(s)
-
-    if (len < 16) {
-        if (len == 0)
-            return;
-        xmm_crc_part = _mm_loadu_si128((__m128i *)src);
-        goto partial;
-    }
-
-    algn_diff = (0 - (uintptr_t)src) & 0xF;
-    if (algn_diff) {
-        xmm_crc_part = _mm_loadu_si128((__m128i *)src);
-        _mm_storeu_si128((__m128i *)dst, xmm_crc_part);
-
-        dst += algn_diff;
-        src += algn_diff;
-        len -= algn_diff;
-
-        partial_fold(s, algn_diff, &xmm_crc0, &xmm_crc1, &xmm_crc2, &xmm_crc3,
-            &xmm_crc_part);
-    }
-
-    while ((len -= 64) >= 0) {
-        xmm_t0 = _mm_load_si128((__m128i *)src);
-        xmm_t1 = _mm_load_si128((__m128i *)src + 1);
-        xmm_t2 = _mm_load_si128((__m128i *)src + 2);
-        xmm_t3 = _mm_load_si128((__m128i *)src + 3);
-
-        fold_4(s, &xmm_crc0, &xmm_crc1, &xmm_crc2, &xmm_crc3);
-
-        _mm_storeu_si128((__m128i *)dst, xmm_t0);
-        _mm_storeu_si128((__m128i *)dst + 1, xmm_t1);
-        _mm_storeu_si128((__m128i *)dst + 2, xmm_t2);
-        _mm_storeu_si128((__m128i *)dst + 3, xmm_t3);
-
-        xmm_crc0 = _mm_xor_si128(xmm_crc0, xmm_t0);
-        xmm_crc1 = _mm_xor_si128(xmm_crc1, xmm_t1);
-        xmm_crc2 = _mm_xor_si128(xmm_crc2, xmm_t2);
-        xmm_crc3 = _mm_xor_si128(xmm_crc3, xmm_t3);
-
-        src += 64;
-        dst += 64;
-    }
-
-    /*
-     * len = num bytes left - 64
-     */
-    if (len + 16 >= 0) {
-        len += 16;
-
-        xmm_t0 = _mm_load_si128((__m128i *)src);
-        xmm_t1 = _mm_load_si128((__m128i *)src + 1);
-        xmm_t2 = _mm_load_si128((__m128i *)src + 2);
-
-        fold_3(s, &xmm_crc0, &xmm_crc1, &xmm_crc2, &xmm_crc3);
-
-        _mm_storeu_si128((__m128i *)dst, xmm_t0);
-        _mm_storeu_si128((__m128i *)dst + 1, xmm_t1);
-        _mm_storeu_si128((__m128i *)dst + 2, xmm_t2);
-
-        xmm_crc1 = _mm_xor_si128(xmm_crc1, xmm_t0);
-        xmm_crc2 = _mm_xor_si128(xmm_crc2, xmm_t1);
-        xmm_crc3 = _mm_xor_si128(xmm_crc3, xmm_t2);
-
-        if (len == 0)
-            goto done;
-
-        dst += 48;
-        xmm_crc_part = _mm_load_si128((__m128i *)src + 3);
-    } else if (len + 32 >= 0) {
-        len += 32;
-
-        xmm_t0 = _mm_load_si128((__m128i *)src);
-        xmm_t1 = _mm_load_si128((__m128i *)src + 1);
-
-        fold_2(s, &xmm_crc0, &xmm_crc1, &xmm_crc2, &xmm_crc3);
-
-        _mm_storeu_si128((__m128i *)dst, xmm_t0);
-        _mm_storeu_si128((__m128i *)dst + 1, xmm_t1);
-
-        xmm_crc2 = _mm_xor_si128(xmm_crc2, xmm_t0);
-        xmm_crc3 = _mm_xor_si128(xmm_crc3, xmm_t1);
-
-        if (len == 0)
-            goto done;
-
-        dst += 32;
-        xmm_crc_part = _mm_load_si128((__m128i *)src + 2);
-    } else if (len + 48 >= 0) {
-        len += 48;
-
-        xmm_t0 = _mm_load_si128((__m128i *)src);
-
-        fold_1(s, &xmm_crc0, &xmm_crc1, &xmm_crc2, &xmm_crc3);
-
-        _mm_storeu_si128((__m128i *)dst, xmm_t0);
-
-        xmm_crc3 = _mm_xor_si128(xmm_crc3, xmm_t0);
-
-        if (len == 0)
-            goto done;
-
-        dst += 16;
-        xmm_crc_part = _mm_load_si128((__m128i *)src + 1);
-    } else {
-        len += 64;
-        if (len == 0)
-            goto done;
-        xmm_crc_part = _mm_load_si128((__m128i *)src);
-    }
-
-partial:
-    _mm_storeu_si128((__m128i *)dst, xmm_crc_part);
-    partial_fold(s, len, &xmm_crc0, &xmm_crc1, &xmm_crc2, &xmm_crc3,
-        &xmm_crc_part);
-done:
-    CRC_SAVE(s)
-}
-
-local const unsigned ALIGNED_(16) crc_k[] = {
-    0xccaa009e, 0x00000000, /* rk1 */
-    0x751997d0, 0x00000001, /* rk2 */
-    0xccaa009e, 0x00000000, /* rk5 */
-    0x63cd6124, 0x00000001, /* rk6 */
-    0xf7011640, 0x00000001, /* rk7 */
-    0xdb710640, 0x00000001  /* rk8 */
-};
-
-local const unsigned ALIGNED_(16) crc_mask[4] = {
-    0xFFFFFFFF, 0xFFFFFFFF, 0x00000000, 0x00000000
-};
-
-local const unsigned ALIGNED_(16) crc_mask2[4] = {
-    0x00000000, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF
-};
-
-uint32_t ZLIB_INTERNAL crc_fold_512to32(deflate_state *const s) {
-    const __m128i xmm_mask  = _mm_load_si128((__m128i *)crc_mask);
-    const __m128i xmm_mask2 = _mm_load_si128((__m128i *)crc_mask2);
-
-    uint32_t crc;
-    __m128i x_tmp0, x_tmp1, x_tmp2, crc_fold;
-
-    CRC_LOAD(s)
-
-    /*
-     * k1
-     */
-    crc_fold = _mm_load_si128((__m128i *)crc_k);
-
-    x_tmp0 = _mm_clmulepi64_si128(xmm_crc0, crc_fold, 0x10);
-    xmm_crc0 = _mm_clmulepi64_si128(xmm_crc0, crc_fold, 0x01);
-    xmm_crc1 = _mm_xor_si128(xmm_crc1, x_tmp0);
-    xmm_crc1 = _mm_xor_si128(xmm_crc1, xmm_crc0);
-
-    x_tmp1 = _mm_clmulepi64_si128(xmm_crc1, crc_fold, 0x10);
-    xmm_crc1 = _mm_clmulepi64_si128(xmm_crc1, crc_fold, 0x01);
-    xmm_crc2 = _mm_xor_si128(xmm_crc2, x_tmp1);
-    xmm_crc2 = _mm_xor_si128(xmm_crc2, xmm_crc1);
-
-    x_tmp2 = _mm_clmulepi64_si128(xmm_crc2, crc_fold, 0x10);
-    xmm_crc2 = _mm_clmulepi64_si128(xmm_crc2, crc_fold, 0x01);
-    xmm_crc3 = _mm_xor_si128(xmm_crc3, x_tmp2);
-    xmm_crc3 = _mm_xor_si128(xmm_crc3, xmm_crc2);
-
-    /*
-     * k5
-     */
-    crc_fold = _mm_load_si128((__m128i *)crc_k + 1);
-
-    xmm_crc0 = xmm_crc3;
-    xmm_crc3 = _mm_clmulepi64_si128(xmm_crc3, crc_fold, 0);
-    xmm_crc0 = _mm_srli_si128(xmm_crc0, 8);
-    xmm_crc3 = _mm_xor_si128(xmm_crc3, xmm_crc0);
-
-    xmm_crc0 = xmm_crc3;
-    xmm_crc3 = _mm_slli_si128(xmm_crc3, 4);
-    xmm_crc3 = _mm_clmulepi64_si128(xmm_crc3, crc_fold, 0x10);
-    xmm_crc3 = _mm_xor_si128(xmm_crc3, xmm_crc0);
-    xmm_crc3 = _mm_and_si128(xmm_crc3, xmm_mask2);
-
-    /*
-     * k7
-     */
-    xmm_crc1 = xmm_crc3;
-    xmm_crc2 = xmm_crc3;
-    crc_fold = _mm_load_si128((__m128i *)crc_k + 2);
-
-    xmm_crc3 = _mm_clmulepi64_si128(xmm_crc3, crc_fold, 0);
-    xmm_crc3 = _mm_xor_si128(xmm_crc3, xmm_crc2);
-    xmm_crc3 = _mm_and_si128(xmm_crc3, xmm_mask);
-
-    xmm_crc2 = xmm_crc3;
-    xmm_crc3 = _mm_clmulepi64_si128(xmm_crc3, crc_fold, 0x10);
-    xmm_crc3 = _mm_xor_si128(xmm_crc3, xmm_crc2);
-    xmm_crc3 = _mm_xor_si128(xmm_crc3, xmm_crc1);
-
-    crc = _mm_extract_epi32(xmm_crc3, 2);
-    return ~crc;
-    CRC_SAVE(s)
-}
-
-#endif
-
diff --git a/contrib/libzlib-ng/arch/x86/deflate_quick.c b/contrib/libzlib-ng/arch/x86/deflate_quick.c
deleted file mode 100644
index b5190d59898..00000000000
--- a/contrib/libzlib-ng/arch/x86/deflate_quick.c
+++ /dev/null
@@ -1,2371 +0,0 @@
-/*
- * The deflate_quick deflate strategy, designed to be used when cycles are
- * at a premium.
- *
- * Copyright (C) 2013 Intel Corporation. All rights reserved.
- * Authors:
- *  Wajdi Feghali   <wajdi.k.feghali@intel.com>
- *  Jim Guilford    <james.guilford@intel.com>
- *  Vinodh Gopal    <vinodh.gopal@intel.com>
- *     Erdinc Ozturk   <erdinc.ozturk@intel.com>
- *  Jim Kukunas     <james.t.kukunas@linux.intel.com>
- *
- * For conditions of distribution and use, see copyright notice in zlib.h
- */
-
-#include <immintrin.h>
-#ifdef _MSC_VER
-#  include <nmmintrin.h>
-#endif
-#include "deflate.h"
-
-extern void fill_window_sse(deflate_state *s);
-extern void flush_pending(z_stream *strm);
-
-local inline long compare258(const unsigned char *const src0, const unsigned char *const src1) {
-#ifdef _MSC_VER
-    long cnt;
-
-    cnt = 0;
-    do {
-#define mode  _SIDD_UBYTE_OPS | _SIDD_CMP_EQUAL_EACH | _SIDD_NEGATIVE_POLARITY
-
-        int ret;
-        __m128i xmm_src0, xmm_src1;
-
-        xmm_src0 = _mm_loadu_si128((__m128i *)(src0 + cnt));
-        xmm_src1 = _mm_loadu_si128((__m128i *)(src1 + cnt));
-        ret = _mm_cmpestri(xmm_src0, 16, xmm_src1, 16, mode);
-        if (_mm_cmpestrc(xmm_src0, 16, xmm_src1, 16, mode)) {
-            cnt += ret;
-	    break;
-        }
-        cnt += 16;
-
-        xmm_src0 = _mm_loadu_si128((__m128i *)(src0 + cnt));
-        xmm_src1 = _mm_loadu_si128((__m128i *)(src1 + cnt));
-        ret = _mm_cmpestri(xmm_src0, 16, xmm_src1, 16, mode);
-        if (_mm_cmpestrc(xmm_src0, 16, xmm_src1, 16, mode)) {
-            cnt += ret;
-	    break;
-        }
-        cnt += 16;
-    } while (cnt < 256);
-
-    if (*(unsigned short *)(src0 + cnt) == *(unsigned short *)(src1 + cnt)) {
-        cnt += 2;
-    } else if (*(src0 + cnt) == *(src1 + cnt)) {
-        cnt++;
-    }
-    return cnt;
-#else
-    uintptr_t ax, dx, cx;
-    __m128i xmm_src0;
-
-    ax = 16;
-    dx = 16;
-    /* set cx to something, otherwise gcc thinks it's used
-       uninitalised */
-    cx = 0;
-
-    __asm__ __volatile__ (
-    "1:"
-        "movdqu     -16(%[src0], %[ax]), %[xmm_src0]\n\t"
-        "pcmpestri  $0x18, -16(%[src1], %[ax]), %[xmm_src0]\n\t"
-        "jc         2f\n\t"
-        "add        $16, %[ax]\n\t"
-
-        "movdqu     -16(%[src0], %[ax]), %[xmm_src0]\n\t"
-        "pcmpestri  $0x18, -16(%[src1], %[ax]), %[xmm_src0]\n\t"
-        "jc         2f\n\t"
-        "add        $16, %[ax]\n\t"
-
-        "cmp        $256 + 16, %[ax]\n\t"
-        "jb         1b\n\t"
-
-#ifdef X86
-        "movzwl     -16(%[src0], %[ax]), %[dx]\n\t"
-#else
-        "movzwq     -16(%[src0], %[ax]), %[dx]\n\t"
-#endif
-        "xorw       -16(%[src1], %[ax]), %%dx\n\t"
-        "jnz        3f\n\t"
-
-        "add        $2, %[ax]\n\t"
-        "jmp        4f\n\t"
-    "3:\n\t"
-        "rep; bsf   %[dx], %[cx]\n\t"
-        "shr        $3, %[cx]\n\t"
-    "2:"
-        "add        %[cx], %[ax]\n\t"
-    "4:"
-    : [ax] "+a" (ax),
-      [cx] "+c" (cx),
-      [dx] "+d" (dx),
-      [xmm_src0] "=x" (xmm_src0)
-    : [src0] "r" (src0),
-      [src1] "r" (src1)
-    : "cc"
-    );
-    return ax - 16;
-#endif
-}
-
-local const unsigned quick_len_codes[MAX_MATCH-MIN_MATCH+1];
-local const unsigned quick_dist_codes[8192];
-
-local inline void quick_send_bits(deflate_state *const s, const int value, const int length) {
-    unsigned code, out, w, b;
-
-    out = s->bi_buf;
-    w = s->bi_valid;
-
-    code = value << s->bi_valid;
-    out |= code;
-    w += length;
-
-    if (s->pending + 4 >= s->pending_buf_size)
-        flush_pending(s->strm);
-
-    *(unsigned *)(s->pending_buf + s->pending) = out;
-
-    b = w >> 3;
-    s->pending += b;
-    s->bi_buf =  out >> (b << 3);
-    s->bi_valid = w - (b << 3);
-}
-
-local inline void static_emit_ptr(deflate_state *const s, const int lc, const unsigned dist) {
-    unsigned code, len;
-
-    code = quick_len_codes[lc] >> 8;
-    len =  quick_len_codes[lc] & 0xFF;
-    quick_send_bits(s, code, len);
-
-    code = quick_dist_codes[dist-1] >> 8;
-    len  = quick_dist_codes[dist-1] & 0xFF;
-    quick_send_bits(s, code, len);
-}
-
-const ct_data static_ltree[L_CODES+2];
-
-local inline void static_emit_lit(deflate_state *const s, const int lit) {
-    quick_send_bits(s, static_ltree[lit].Code, static_ltree[lit].Len);
-    Tracecv(isgraph(lit), (stderr, " '%c' ", lit));
-}
-
-local void static_emit_tree(deflate_state *const s, const int flush) {
-    unsigned last;
-
-    last = flush == Z_FINISH ? 1 : 0;
-    send_bits(s, (STATIC_TREES << 1)+ last, 3);
-}
-
-
-local void static_emit_end_block(deflate_state *const s, int last) {
-    send_code(s, END_BLOCK, static_ltree);
-
-    if (last)
-        bi_windup(s);
-
-    s->block_start = s->strstart;
-    flush_pending(s->strm);
-}
-
-local inline Pos quick_insert_string(deflate_state *const s, const Pos str) {
-    Pos ret;
-    unsigned h = 0;
-
-#ifdef _MSC_VER
-    h = _mm_crc32_u32(h, *(unsigned *)(s->window + str));
-#else
-    __asm__ __volatile__ (
-        "crc32l (%[window], %[str], 1), %0\n\t"
-    : "+r" (h)
-    : [window] "r" (s->window),
-      [str] "r" ((uintptr_t)str)
-    );
-#endif
-
-    ret = s->head[h & s->hash_mask];
-    s->head[h & s->hash_mask] = str;
-    return ret;
-}
-
-ZLIB_INTERNAL block_state deflate_quick(deflate_state *s, int flush) {
-    IPos hash_head;
-    unsigned dist, match_len;
-
-    static_emit_tree(s, flush);
-
-    do {
-        if (s->lookahead < MIN_LOOKAHEAD) {
-            fill_window_sse(s);
-            if (s->lookahead < MIN_LOOKAHEAD && flush == Z_NO_FLUSH) {
-                static_emit_end_block(s, 0);
-                return need_more;
-            }
-            if (s->lookahead == 0)
-                break;
-        }
-
-        if (s->lookahead >= MIN_MATCH) {
-            hash_head = quick_insert_string(s, s->strstart);
-            dist = s->strstart - hash_head;
-
-            if ((dist-1) < (s->w_size - 1)) {
-                match_len = compare258(s->window + s->strstart, s->window + s->strstart - dist);
-
-                if (match_len >= MIN_MATCH) {
-                    if (match_len > s->lookahead)
-                        match_len = s->lookahead;
-
-                    if (match_len > MAX_MATCH)
-                        match_len = MAX_MATCH;
-
-                    static_emit_ptr(s, match_len - MIN_MATCH, s->strstart - hash_head);
-                    s->lookahead -= match_len;
-                    s->strstart += match_len;
-                    continue;
-                }
-            }
-        }
-
-        static_emit_lit(s, s->window[s->strstart]);
-        s->strstart++;
-        s->lookahead--;
-    } while (s->strm->avail_out != 0);
-
-    if (s->strm->avail_out == 0 && flush != Z_FINISH)
-        return need_more;
-
-    s->insert = s->strstart < MIN_MATCH - 1 ? s->strstart : MIN_MATCH-1;
-    if (flush == Z_FINISH) {
-        static_emit_end_block(s, 1);
-        if (s->strm->avail_out == 0)
-            return s->strm->avail_in == 0 ? finish_started : need_more;
-        else
-            return finish_done;
-    }
-
-    static_emit_end_block(s, 0);
-    return block_done;
-}
-
-local const unsigned quick_len_codes[MAX_MATCH-MIN_MATCH+1] = {
-    0x00004007, 0x00002007, 0x00006007, 0x00001007,
-    0x00005007, 0x00003007, 0x00007007, 0x00000807,
-    0x00004808, 0x0000c808, 0x00002808, 0x0000a808,
-    0x00006808, 0x0000e808, 0x00001808, 0x00009808,
-    0x00005809, 0x0000d809, 0x00015809, 0x0001d809,
-    0x00003809, 0x0000b809, 0x00013809, 0x0001b809,
-    0x00007809, 0x0000f809, 0x00017809, 0x0001f809,
-    0x00000409, 0x00008409, 0x00010409, 0x00018409,
-    0x0000440a, 0x0000c40a, 0x0001440a, 0x0001c40a,
-    0x0002440a, 0x0002c40a, 0x0003440a, 0x0003c40a,
-    0x0000240a, 0x0000a40a, 0x0001240a, 0x0001a40a,
-    0x0002240a, 0x0002a40a, 0x0003240a, 0x0003a40a,
-    0x0000640a, 0x0000e40a, 0x0001640a, 0x0001e40a,
-    0x0002640a, 0x0002e40a, 0x0003640a, 0x0003e40a,
-    0x0000140a, 0x0000940a, 0x0001140a, 0x0001940a,
-    0x0002140a, 0x0002940a, 0x0003140a, 0x0003940a,
-    0x0000540b, 0x0000d40b, 0x0001540b, 0x0001d40b,
-    0x0002540b, 0x0002d40b, 0x0003540b, 0x0003d40b,
-    0x0004540b, 0x0004d40b, 0x0005540b, 0x0005d40b,
-    0x0006540b, 0x0006d40b, 0x0007540b, 0x0007d40b,
-    0x0000340b, 0x0000b40b, 0x0001340b, 0x0001b40b,
-    0x0002340b, 0x0002b40b, 0x0003340b, 0x0003b40b,
-    0x0004340b, 0x0004b40b, 0x0005340b, 0x0005b40b,
-    0x0006340b, 0x0006b40b, 0x0007340b, 0x0007b40b,
-    0x0000740b, 0x0000f40b, 0x0001740b, 0x0001f40b,
-    0x0002740b, 0x0002f40b, 0x0003740b, 0x0003f40b,
-    0x0004740b, 0x0004f40b, 0x0005740b, 0x0005f40b,
-    0x0006740b, 0x0006f40b, 0x0007740b, 0x0007f40b,
-    0x0000030c, 0x0001030c, 0x0002030c, 0x0003030c,
-    0x0004030c, 0x0005030c, 0x0006030c, 0x0007030c,
-    0x0008030c, 0x0009030c, 0x000a030c, 0x000b030c,
-    0x000c030c, 0x000d030c, 0x000e030c, 0x000f030c,
-    0x0000830d, 0x0001830d, 0x0002830d, 0x0003830d,
-    0x0004830d, 0x0005830d, 0x0006830d, 0x0007830d,
-    0x0008830d, 0x0009830d, 0x000a830d, 0x000b830d,
-    0x000c830d, 0x000d830d, 0x000e830d, 0x000f830d,
-    0x0010830d, 0x0011830d, 0x0012830d, 0x0013830d,
-    0x0014830d, 0x0015830d, 0x0016830d, 0x0017830d,
-    0x0018830d, 0x0019830d, 0x001a830d, 0x001b830d,
-    0x001c830d, 0x001d830d, 0x001e830d, 0x001f830d,
-    0x0000430d, 0x0001430d, 0x0002430d, 0x0003430d,
-    0x0004430d, 0x0005430d, 0x0006430d, 0x0007430d,
-    0x0008430d, 0x0009430d, 0x000a430d, 0x000b430d,
-    0x000c430d, 0x000d430d, 0x000e430d, 0x000f430d,
-    0x0010430d, 0x0011430d, 0x0012430d, 0x0013430d,
-    0x0014430d, 0x0015430d, 0x0016430d, 0x0017430d,
-    0x0018430d, 0x0019430d, 0x001a430d, 0x001b430d,
-    0x001c430d, 0x001d430d, 0x001e430d, 0x001f430d,
-    0x0000c30d, 0x0001c30d, 0x0002c30d, 0x0003c30d,
-    0x0004c30d, 0x0005c30d, 0x0006c30d, 0x0007c30d,
-    0x0008c30d, 0x0009c30d, 0x000ac30d, 0x000bc30d,
-    0x000cc30d, 0x000dc30d, 0x000ec30d, 0x000fc30d,
-    0x0010c30d, 0x0011c30d, 0x0012c30d, 0x0013c30d,
-    0x0014c30d, 0x0015c30d, 0x0016c30d, 0x0017c30d,
-    0x0018c30d, 0x0019c30d, 0x001ac30d, 0x001bc30d,
-    0x001cc30d, 0x001dc30d, 0x001ec30d, 0x001fc30d,
-    0x0000230d, 0x0001230d, 0x0002230d, 0x0003230d,
-    0x0004230d, 0x0005230d, 0x0006230d, 0x0007230d,
-    0x0008230d, 0x0009230d, 0x000a230d, 0x000b230d,
-    0x000c230d, 0x000d230d, 0x000e230d, 0x000f230d,
-    0x0010230d, 0x0011230d, 0x0012230d, 0x0013230d,
-    0x0014230d, 0x0015230d, 0x0016230d, 0x0017230d,
-    0x0018230d, 0x0019230d, 0x001a230d, 0x001b230d,
-    0x001c230d, 0x001d230d, 0x001e230d, 0x0000a308,
-};
-
-local const unsigned quick_dist_codes[8192] = {
-    0x00000005, 0x00001005, 0x00000805, 0x00001805,
-    0x00000406, 0x00002406, 0x00001406, 0x00003406,
-    0x00000c07, 0x00002c07, 0x00004c07, 0x00006c07,
-    0x00001c07, 0x00003c07, 0x00005c07, 0x00007c07,
-    0x00000208, 0x00002208, 0x00004208, 0x00006208,
-    0x00008208, 0x0000a208, 0x0000c208, 0x0000e208,
-    0x00001208, 0x00003208, 0x00005208, 0x00007208,
-    0x00009208, 0x0000b208, 0x0000d208, 0x0000f208,
-    0x00000a09, 0x00002a09, 0x00004a09, 0x00006a09,
-    0x00008a09, 0x0000aa09, 0x0000ca09, 0x0000ea09,
-    0x00010a09, 0x00012a09, 0x00014a09, 0x00016a09,
-    0x00018a09, 0x0001aa09, 0x0001ca09, 0x0001ea09,
-    0x00001a09, 0x00003a09, 0x00005a09, 0x00007a09,
-    0x00009a09, 0x0000ba09, 0x0000da09, 0x0000fa09,
-    0x00011a09, 0x00013a09, 0x00015a09, 0x00017a09,
-    0x00019a09, 0x0001ba09, 0x0001da09, 0x0001fa09,
-    0x0000060a, 0x0000260a, 0x0000460a, 0x0000660a,
-    0x0000860a, 0x0000a60a, 0x0000c60a, 0x0000e60a,
-    0x0001060a, 0x0001260a, 0x0001460a, 0x0001660a,
-    0x0001860a, 0x0001a60a, 0x0001c60a, 0x0001e60a,
-    0x0002060a, 0x0002260a, 0x0002460a, 0x0002660a,
-    0x0002860a, 0x0002a60a, 0x0002c60a, 0x0002e60a,
-    0x0003060a, 0x0003260a, 0x0003460a, 0x0003660a,
-    0x0003860a, 0x0003a60a, 0x0003c60a, 0x0003e60a,
-    0x0000160a, 0x0000360a, 0x0000560a, 0x0000760a,
-    0x0000960a, 0x0000b60a, 0x0000d60a, 0x0000f60a,
-    0x0001160a, 0x0001360a, 0x0001560a, 0x0001760a,
-    0x0001960a, 0x0001b60a, 0x0001d60a, 0x0001f60a,
-    0x0002160a, 0x0002360a, 0x0002560a, 0x0002760a,
-    0x0002960a, 0x0002b60a, 0x0002d60a, 0x0002f60a,
-    0x0003160a, 0x0003360a, 0x0003560a, 0x0003760a,
-    0x0003960a, 0x0003b60a, 0x0003d60a, 0x0003f60a,
-    0x00000e0b, 0x00002e0b, 0x00004e0b, 0x00006e0b,
-    0x00008e0b, 0x0000ae0b, 0x0000ce0b, 0x0000ee0b,
-    0x00010e0b, 0x00012e0b, 0x00014e0b, 0x00016e0b,
-    0x00018e0b, 0x0001ae0b, 0x0001ce0b, 0x0001ee0b,
-    0x00020e0b, 0x00022e0b, 0x00024e0b, 0x00026e0b,
-    0x00028e0b, 0x0002ae0b, 0x0002ce0b, 0x0002ee0b,
-    0x00030e0b, 0x00032e0b, 0x00034e0b, 0x00036e0b,
-    0x00038e0b, 0x0003ae0b, 0x0003ce0b, 0x0003ee0b,
-    0x00040e0b, 0x00042e0b, 0x00044e0b, 0x00046e0b,
-    0x00048e0b, 0x0004ae0b, 0x0004ce0b, 0x0004ee0b,
-    0x00050e0b, 0x00052e0b, 0x00054e0b, 0x00056e0b,
-    0x00058e0b, 0x0005ae0b, 0x0005ce0b, 0x0005ee0b,
-    0x00060e0b, 0x00062e0b, 0x00064e0b, 0x00066e0b,
-    0x00068e0b, 0x0006ae0b, 0x0006ce0b, 0x0006ee0b,
-    0x00070e0b, 0x00072e0b, 0x00074e0b, 0x00076e0b,
-    0x00078e0b, 0x0007ae0b, 0x0007ce0b, 0x0007ee0b,
-    0x00001e0b, 0x00003e0b, 0x00005e0b, 0x00007e0b,
-    0x00009e0b, 0x0000be0b, 0x0000de0b, 0x0000fe0b,
-    0x00011e0b, 0x00013e0b, 0x00015e0b, 0x00017e0b,
-    0x00019e0b, 0x0001be0b, 0x0001de0b, 0x0001fe0b,
-    0x00021e0b, 0x00023e0b, 0x00025e0b, 0x00027e0b,
-    0x00029e0b, 0x0002be0b, 0x0002de0b, 0x0002fe0b,
-    0x00031e0b, 0x00033e0b, 0x00035e0b, 0x00037e0b,
-    0x00039e0b, 0x0003be0b, 0x0003de0b, 0x0003fe0b,
-    0x00041e0b, 0x00043e0b, 0x00045e0b, 0x00047e0b,
-    0x00049e0b, 0x0004be0b, 0x0004de0b, 0x0004fe0b,
-    0x00051e0b, 0x00053e0b, 0x00055e0b, 0x00057e0b,
-    0x00059e0b, 0x0005be0b, 0x0005de0b, 0x0005fe0b,
-    0x00061e0b, 0x00063e0b, 0x00065e0b, 0x00067e0b,
-    0x00069e0b, 0x0006be0b, 0x0006de0b, 0x0006fe0b,
-    0x00071e0b, 0x00073e0b, 0x00075e0b, 0x00077e0b,
-    0x00079e0b, 0x0007be0b, 0x0007de0b, 0x0007fe0b,
-    0x0000010c, 0x0000210c, 0x0000410c, 0x0000610c,
-    0x0000810c, 0x0000a10c, 0x0000c10c, 0x0000e10c,
-    0x0001010c, 0x0001210c, 0x0001410c, 0x0001610c,
-    0x0001810c, 0x0001a10c, 0x0001c10c, 0x0001e10c,
-    0x0002010c, 0x0002210c, 0x0002410c, 0x0002610c,
-    0x0002810c, 0x0002a10c, 0x0002c10c, 0x0002e10c,
-    0x0003010c, 0x0003210c, 0x0003410c, 0x0003610c,
-    0x0003810c, 0x0003a10c, 0x0003c10c, 0x0003e10c,
-    0x0004010c, 0x0004210c, 0x0004410c, 0x0004610c,
-    0x0004810c, 0x0004a10c, 0x0004c10c, 0x0004e10c,
-    0x0005010c, 0x0005210c, 0x0005410c, 0x0005610c,
-    0x0005810c, 0x0005a10c, 0x0005c10c, 0x0005e10c,
-    0x0006010c, 0x0006210c, 0x0006410c, 0x0006610c,
-    0x0006810c, 0x0006a10c, 0x0006c10c, 0x0006e10c,
-    0x0007010c, 0x0007210c, 0x0007410c, 0x0007610c,
-    0x0007810c, 0x0007a10c, 0x0007c10c, 0x0007e10c,
-    0x0008010c, 0x0008210c, 0x0008410c, 0x0008610c,
-    0x0008810c, 0x0008a10c, 0x0008c10c, 0x0008e10c,
-    0x0009010c, 0x0009210c, 0x0009410c, 0x0009610c,
-    0x0009810c, 0x0009a10c, 0x0009c10c, 0x0009e10c,
-    0x000a010c, 0x000a210c, 0x000a410c, 0x000a610c,
-    0x000a810c, 0x000aa10c, 0x000ac10c, 0x000ae10c,
-    0x000b010c, 0x000b210c, 0x000b410c, 0x000b610c,
-    0x000b810c, 0x000ba10c, 0x000bc10c, 0x000be10c,
-    0x000c010c, 0x000c210c, 0x000c410c, 0x000c610c,
-    0x000c810c, 0x000ca10c, 0x000cc10c, 0x000ce10c,
-    0x000d010c, 0x000d210c, 0x000d410c, 0x000d610c,
-    0x000d810c, 0x000da10c, 0x000dc10c, 0x000de10c,
-    0x000e010c, 0x000e210c, 0x000e410c, 0x000e610c,
-    0x000e810c, 0x000ea10c, 0x000ec10c, 0x000ee10c,
-    0x000f010c, 0x000f210c, 0x000f410c, 0x000f610c,
-    0x000f810c, 0x000fa10c, 0x000fc10c, 0x000fe10c,
-    0x0000110c, 0x0000310c, 0x0000510c, 0x0000710c,
-    0x0000910c, 0x0000b10c, 0x0000d10c, 0x0000f10c,
-    0x0001110c, 0x0001310c, 0x0001510c, 0x0001710c,
-    0x0001910c, 0x0001b10c, 0x0001d10c, 0x0001f10c,
-    0x0002110c, 0x0002310c, 0x0002510c, 0x0002710c,
-    0x0002910c, 0x0002b10c, 0x0002d10c, 0x0002f10c,
-    0x0003110c, 0x0003310c, 0x0003510c, 0x0003710c,
-    0x0003910c, 0x0003b10c, 0x0003d10c, 0x0003f10c,
-    0x0004110c, 0x0004310c, 0x0004510c, 0x0004710c,
-    0x0004910c, 0x0004b10c, 0x0004d10c, 0x0004f10c,
-    0x0005110c, 0x0005310c, 0x0005510c, 0x0005710c,
-    0x0005910c, 0x0005b10c, 0x0005d10c, 0x0005f10c,
-    0x0006110c, 0x0006310c, 0x0006510c, 0x0006710c,
-    0x0006910c, 0x0006b10c, 0x0006d10c, 0x0006f10c,
-    0x0007110c, 0x0007310c, 0x0007510c, 0x0007710c,
-    0x0007910c, 0x0007b10c, 0x0007d10c, 0x0007f10c,
-    0x0008110c, 0x0008310c, 0x0008510c, 0x0008710c,
-    0x0008910c, 0x0008b10c, 0x0008d10c, 0x0008f10c,
-    0x0009110c, 0x0009310c, 0x0009510c, 0x0009710c,
-    0x0009910c, 0x0009b10c, 0x0009d10c, 0x0009f10c,
-    0x000a110c, 0x000a310c, 0x000a510c, 0x000a710c,
-    0x000a910c, 0x000ab10c, 0x000ad10c, 0x000af10c,
-    0x000b110c, 0x000b310c, 0x000b510c, 0x000b710c,
-    0x000b910c, 0x000bb10c, 0x000bd10c, 0x000bf10c,
-    0x000c110c, 0x000c310c, 0x000c510c, 0x000c710c,
-    0x000c910c, 0x000cb10c, 0x000cd10c, 0x000cf10c,
-    0x000d110c, 0x000d310c, 0x000d510c, 0x000d710c,
-    0x000d910c, 0x000db10c, 0x000dd10c, 0x000df10c,
-    0x000e110c, 0x000e310c, 0x000e510c, 0x000e710c,
-    0x000e910c, 0x000eb10c, 0x000ed10c, 0x000ef10c,
-    0x000f110c, 0x000f310c, 0x000f510c, 0x000f710c,
-    0x000f910c, 0x000fb10c, 0x000fd10c, 0x000ff10c,
-    0x0000090d, 0x0000290d, 0x0000490d, 0x0000690d,
-    0x0000890d, 0x0000a90d, 0x0000c90d, 0x0000e90d,
-    0x0001090d, 0x0001290d, 0x0001490d, 0x0001690d,
-    0x0001890d, 0x0001a90d, 0x0001c90d, 0x0001e90d,
-    0x0002090d, 0x0002290d, 0x0002490d, 0x0002690d,
-    0x0002890d, 0x0002a90d, 0x0002c90d, 0x0002e90d,
-    0x0003090d, 0x0003290d, 0x0003490d, 0x0003690d,
-    0x0003890d, 0x0003a90d, 0x0003c90d, 0x0003e90d,
-    0x0004090d, 0x0004290d, 0x0004490d, 0x0004690d,
-    0x0004890d, 0x0004a90d, 0x0004c90d, 0x0004e90d,
-    0x0005090d, 0x0005290d, 0x0005490d, 0x0005690d,
-    0x0005890d, 0x0005a90d, 0x0005c90d, 0x0005e90d,
-    0x0006090d, 0x0006290d, 0x0006490d, 0x0006690d,
-    0x0006890d, 0x0006a90d, 0x0006c90d, 0x0006e90d,
-    0x0007090d, 0x0007290d, 0x0007490d, 0x0007690d,
-    0x0007890d, 0x0007a90d, 0x0007c90d, 0x0007e90d,
-    0x0008090d, 0x0008290d, 0x0008490d, 0x0008690d,
-    0x0008890d, 0x0008a90d, 0x0008c90d, 0x0008e90d,
-    0x0009090d, 0x0009290d, 0x0009490d, 0x0009690d,
-    0x0009890d, 0x0009a90d, 0x0009c90d, 0x0009e90d,
-    0x000a090d, 0x000a290d, 0x000a490d, 0x000a690d,
-    0x000a890d, 0x000aa90d, 0x000ac90d, 0x000ae90d,
-    0x000b090d, 0x000b290d, 0x000b490d, 0x000b690d,
-    0x000b890d, 0x000ba90d, 0x000bc90d, 0x000be90d,
-    0x000c090d, 0x000c290d, 0x000c490d, 0x000c690d,
-    0x000c890d, 0x000ca90d, 0x000cc90d, 0x000ce90d,
-    0x000d090d, 0x000d290d, 0x000d490d, 0x000d690d,
-    0x000d890d, 0x000da90d, 0x000dc90d, 0x000de90d,
-    0x000e090d, 0x000e290d, 0x000e490d, 0x000e690d,
-    0x000e890d, 0x000ea90d, 0x000ec90d, 0x000ee90d,
-    0x000f090d, 0x000f290d, 0x000f490d, 0x000f690d,
-    0x000f890d, 0x000fa90d, 0x000fc90d, 0x000fe90d,
-    0x0010090d, 0x0010290d, 0x0010490d, 0x0010690d,
-    0x0010890d, 0x0010a90d, 0x0010c90d, 0x0010e90d,
-    0x0011090d, 0x0011290d, 0x0011490d, 0x0011690d,
-    0x0011890d, 0x0011a90d, 0x0011c90d, 0x0011e90d,
-    0x0012090d, 0x0012290d, 0x0012490d, 0x0012690d,
-    0x0012890d, 0x0012a90d, 0x0012c90d, 0x0012e90d,
-    0x0013090d, 0x0013290d, 0x0013490d, 0x0013690d,
-    0x0013890d, 0x0013a90d, 0x0013c90d, 0x0013e90d,
-    0x0014090d, 0x0014290d, 0x0014490d, 0x0014690d,
-    0x0014890d, 0x0014a90d, 0x0014c90d, 0x0014e90d,
-    0x0015090d, 0x0015290d, 0x0015490d, 0x0015690d,
-    0x0015890d, 0x0015a90d, 0x0015c90d, 0x0015e90d,
-    0x0016090d, 0x0016290d, 0x0016490d, 0x0016690d,
-    0x0016890d, 0x0016a90d, 0x0016c90d, 0x0016e90d,
-    0x0017090d, 0x0017290d, 0x0017490d, 0x0017690d,
-    0x0017890d, 0x0017a90d, 0x0017c90d, 0x0017e90d,
-    0x0018090d, 0x0018290d, 0x0018490d, 0x0018690d,
-    0x0018890d, 0x0018a90d, 0x0018c90d, 0x0018e90d,
-    0x0019090d, 0x0019290d, 0x0019490d, 0x0019690d,
-    0x0019890d, 0x0019a90d, 0x0019c90d, 0x0019e90d,
-    0x001a090d, 0x001a290d, 0x001a490d, 0x001a690d,
-    0x001a890d, 0x001aa90d, 0x001ac90d, 0x001ae90d,
-    0x001b090d, 0x001b290d, 0x001b490d, 0x001b690d,
-    0x001b890d, 0x001ba90d, 0x001bc90d, 0x001be90d,
-    0x001c090d, 0x001c290d, 0x001c490d, 0x001c690d,
-    0x001c890d, 0x001ca90d, 0x001cc90d, 0x001ce90d,
-    0x001d090d, 0x001d290d, 0x001d490d, 0x001d690d,
-    0x001d890d, 0x001da90d, 0x001dc90d, 0x001de90d,
-    0x001e090d, 0x001e290d, 0x001e490d, 0x001e690d,
-    0x001e890d, 0x001ea90d, 0x001ec90d, 0x001ee90d,
-    0x001f090d, 0x001f290d, 0x001f490d, 0x001f690d,
-    0x001f890d, 0x001fa90d, 0x001fc90d, 0x001fe90d,
-    0x0000190d, 0x0000390d, 0x0000590d, 0x0000790d,
-    0x0000990d, 0x0000b90d, 0x0000d90d, 0x0000f90d,
-    0x0001190d, 0x0001390d, 0x0001590d, 0x0001790d,
-    0x0001990d, 0x0001b90d, 0x0001d90d, 0x0001f90d,
-    0x0002190d, 0x0002390d, 0x0002590d, 0x0002790d,
-    0x0002990d, 0x0002b90d, 0x0002d90d, 0x0002f90d,
-    0x0003190d, 0x0003390d, 0x0003590d, 0x0003790d,
-    0x0003990d, 0x0003b90d, 0x0003d90d, 0x0003f90d,
-    0x0004190d, 0x0004390d, 0x0004590d, 0x0004790d,
-    0x0004990d, 0x0004b90d, 0x0004d90d, 0x0004f90d,
-    0x0005190d, 0x0005390d, 0x0005590d, 0x0005790d,
-    0x0005990d, 0x0005b90d, 0x0005d90d, 0x0005f90d,
-    0x0006190d, 0x0006390d, 0x0006590d, 0x0006790d,
-    0x0006990d, 0x0006b90d, 0x0006d90d, 0x0006f90d,
-    0x0007190d, 0x0007390d, 0x0007590d, 0x0007790d,
-    0x0007990d, 0x0007b90d, 0x0007d90d, 0x0007f90d,
-    0x0008190d, 0x0008390d, 0x0008590d, 0x0008790d,
-    0x0008990d, 0x0008b90d, 0x0008d90d, 0x0008f90d,
-    0x0009190d, 0x0009390d, 0x0009590d, 0x0009790d,
-    0x0009990d, 0x0009b90d, 0x0009d90d, 0x0009f90d,
-    0x000a190d, 0x000a390d, 0x000a590d, 0x000a790d,
-    0x000a990d, 0x000ab90d, 0x000ad90d, 0x000af90d,
-    0x000b190d, 0x000b390d, 0x000b590d, 0x000b790d,
-    0x000b990d, 0x000bb90d, 0x000bd90d, 0x000bf90d,
-    0x000c190d, 0x000c390d, 0x000c590d, 0x000c790d,
-    0x000c990d, 0x000cb90d, 0x000cd90d, 0x000cf90d,
-    0x000d190d, 0x000d390d, 0x000d590d, 0x000d790d,
-    0x000d990d, 0x000db90d, 0x000dd90d, 0x000df90d,
-    0x000e190d, 0x000e390d, 0x000e590d, 0x000e790d,
-    0x000e990d, 0x000eb90d, 0x000ed90d, 0x000ef90d,
-    0x000f190d, 0x000f390d, 0x000f590d, 0x000f790d,
-    0x000f990d, 0x000fb90d, 0x000fd90d, 0x000ff90d,
-    0x0010190d, 0x0010390d, 0x0010590d, 0x0010790d,
-    0x0010990d, 0x0010b90d, 0x0010d90d, 0x0010f90d,
-    0x0011190d, 0x0011390d, 0x0011590d, 0x0011790d,
-    0x0011990d, 0x0011b90d, 0x0011d90d, 0x0011f90d,
-    0x0012190d, 0x0012390d, 0x0012590d, 0x0012790d,
-    0x0012990d, 0x0012b90d, 0x0012d90d, 0x0012f90d,
-    0x0013190d, 0x0013390d, 0x0013590d, 0x0013790d,
-    0x0013990d, 0x0013b90d, 0x0013d90d, 0x0013f90d,
-    0x0014190d, 0x0014390d, 0x0014590d, 0x0014790d,
-    0x0014990d, 0x0014b90d, 0x0014d90d, 0x0014f90d,
-    0x0015190d, 0x0015390d, 0x0015590d, 0x0015790d,
-    0x0015990d, 0x0015b90d, 0x0015d90d, 0x0015f90d,
-    0x0016190d, 0x0016390d, 0x0016590d, 0x0016790d,
-    0x0016990d, 0x0016b90d, 0x0016d90d, 0x0016f90d,
-    0x0017190d, 0x0017390d, 0x0017590d, 0x0017790d,
-    0x0017990d, 0x0017b90d, 0x0017d90d, 0x0017f90d,
-    0x0018190d, 0x0018390d, 0x0018590d, 0x0018790d,
-    0x0018990d, 0x0018b90d, 0x0018d90d, 0x0018f90d,
-    0x0019190d, 0x0019390d, 0x0019590d, 0x0019790d,
-    0x0019990d, 0x0019b90d, 0x0019d90d, 0x0019f90d,
-    0x001a190d, 0x001a390d, 0x001a590d, 0x001a790d,
-    0x001a990d, 0x001ab90d, 0x001ad90d, 0x001af90d,
-    0x001b190d, 0x001b390d, 0x001b590d, 0x001b790d,
-    0x001b990d, 0x001bb90d, 0x001bd90d, 0x001bf90d,
-    0x001c190d, 0x001c390d, 0x001c590d, 0x001c790d,
-    0x001c990d, 0x001cb90d, 0x001cd90d, 0x001cf90d,
-    0x001d190d, 0x001d390d, 0x001d590d, 0x001d790d,
-    0x001d990d, 0x001db90d, 0x001dd90d, 0x001df90d,
-    0x001e190d, 0x001e390d, 0x001e590d, 0x001e790d,
-    0x001e990d, 0x001eb90d, 0x001ed90d, 0x001ef90d,
-    0x001f190d, 0x001f390d, 0x001f590d, 0x001f790d,
-    0x001f990d, 0x001fb90d, 0x001fd90d, 0x001ff90d,
-    0x0000050e, 0x0000250e, 0x0000450e, 0x0000650e,
-    0x0000850e, 0x0000a50e, 0x0000c50e, 0x0000e50e,
-    0x0001050e, 0x0001250e, 0x0001450e, 0x0001650e,
-    0x0001850e, 0x0001a50e, 0x0001c50e, 0x0001e50e,
-    0x0002050e, 0x0002250e, 0x0002450e, 0x0002650e,
-    0x0002850e, 0x0002a50e, 0x0002c50e, 0x0002e50e,
-    0x0003050e, 0x0003250e, 0x0003450e, 0x0003650e,
-    0x0003850e, 0x0003a50e, 0x0003c50e, 0x0003e50e,
-    0x0004050e, 0x0004250e, 0x0004450e, 0x0004650e,
-    0x0004850e, 0x0004a50e, 0x0004c50e, 0x0004e50e,
-    0x0005050e, 0x0005250e, 0x0005450e, 0x0005650e,
-    0x0005850e, 0x0005a50e, 0x0005c50e, 0x0005e50e,
-    0x0006050e, 0x0006250e, 0x0006450e, 0x0006650e,
-    0x0006850e, 0x0006a50e, 0x0006c50e, 0x0006e50e,
-    0x0007050e, 0x0007250e, 0x0007450e, 0x0007650e,
-    0x0007850e, 0x0007a50e, 0x0007c50e, 0x0007e50e,
-    0x0008050e, 0x0008250e, 0x0008450e, 0x0008650e,
-    0x0008850e, 0x0008a50e, 0x0008c50e, 0x0008e50e,
-    0x0009050e, 0x0009250e, 0x0009450e, 0x0009650e,
-    0x0009850e, 0x0009a50e, 0x0009c50e, 0x0009e50e,
-    0x000a050e, 0x000a250e, 0x000a450e, 0x000a650e,
-    0x000a850e, 0x000aa50e, 0x000ac50e, 0x000ae50e,
-    0x000b050e, 0x000b250e, 0x000b450e, 0x000b650e,
-    0x000b850e, 0x000ba50e, 0x000bc50e, 0x000be50e,
-    0x000c050e, 0x000c250e, 0x000c450e, 0x000c650e,
-    0x000c850e, 0x000ca50e, 0x000cc50e, 0x000ce50e,
-    0x000d050e, 0x000d250e, 0x000d450e, 0x000d650e,
-    0x000d850e, 0x000da50e, 0x000dc50e, 0x000de50e,
-    0x000e050e, 0x000e250e, 0x000e450e, 0x000e650e,
-    0x000e850e, 0x000ea50e, 0x000ec50e, 0x000ee50e,
-    0x000f050e, 0x000f250e, 0x000f450e, 0x000f650e,
-    0x000f850e, 0x000fa50e, 0x000fc50e, 0x000fe50e,
-    0x0010050e, 0x0010250e, 0x0010450e, 0x0010650e,
-    0x0010850e, 0x0010a50e, 0x0010c50e, 0x0010e50e,
-    0x0011050e, 0x0011250e, 0x0011450e, 0x0011650e,
-    0x0011850e, 0x0011a50e, 0x0011c50e, 0x0011e50e,
-    0x0012050e, 0x0012250e, 0x0012450e, 0x0012650e,
-    0x0012850e, 0x0012a50e, 0x0012c50e, 0x0012e50e,
-    0x0013050e, 0x0013250e, 0x0013450e, 0x0013650e,
-    0x0013850e, 0x0013a50e, 0x0013c50e, 0x0013e50e,
-    0x0014050e, 0x0014250e, 0x0014450e, 0x0014650e,
-    0x0014850e, 0x0014a50e, 0x0014c50e, 0x0014e50e,
-    0x0015050e, 0x0015250e, 0x0015450e, 0x0015650e,
-    0x0015850e, 0x0015a50e, 0x0015c50e, 0x0015e50e,
-    0x0016050e, 0x0016250e, 0x0016450e, 0x0016650e,
-    0x0016850e, 0x0016a50e, 0x0016c50e, 0x0016e50e,
-    0x0017050e, 0x0017250e, 0x0017450e, 0x0017650e,
-    0x0017850e, 0x0017a50e, 0x0017c50e, 0x0017e50e,
-    0x0018050e, 0x0018250e, 0x0018450e, 0x0018650e,
-    0x0018850e, 0x0018a50e, 0x0018c50e, 0x0018e50e,
-    0x0019050e, 0x0019250e, 0x0019450e, 0x0019650e,
-    0x0019850e, 0x0019a50e, 0x0019c50e, 0x0019e50e,
-    0x001a050e, 0x001a250e, 0x001a450e, 0x001a650e,
-    0x001a850e, 0x001aa50e, 0x001ac50e, 0x001ae50e,
-    0x001b050e, 0x001b250e, 0x001b450e, 0x001b650e,
-    0x001b850e, 0x001ba50e, 0x001bc50e, 0x001be50e,
-    0x001c050e, 0x001c250e, 0x001c450e, 0x001c650e,
-    0x001c850e, 0x001ca50e, 0x001cc50e, 0x001ce50e,
-    0x001d050e, 0x001d250e, 0x001d450e, 0x001d650e,
-    0x001d850e, 0x001da50e, 0x001dc50e, 0x001de50e,
-    0x001e050e, 0x001e250e, 0x001e450e, 0x001e650e,
-    0x001e850e, 0x001ea50e, 0x001ec50e, 0x001ee50e,
-    0x001f050e, 0x001f250e, 0x001f450e, 0x001f650e,
-    0x001f850e, 0x001fa50e, 0x001fc50e, 0x001fe50e,
-    0x0020050e, 0x0020250e, 0x0020450e, 0x0020650e,
-    0x0020850e, 0x0020a50e, 0x0020c50e, 0x0020e50e,
-    0x0021050e, 0x0021250e, 0x0021450e, 0x0021650e,
-    0x0021850e, 0x0021a50e, 0x0021c50e, 0x0021e50e,
-    0x0022050e, 0x0022250e, 0x0022450e, 0x0022650e,
-    0x0022850e, 0x0022a50e, 0x0022c50e, 0x0022e50e,
-    0x0023050e, 0x0023250e, 0x0023450e, 0x0023650e,
-    0x0023850e, 0x0023a50e, 0x0023c50e, 0x0023e50e,
-    0x0024050e, 0x0024250e, 0x0024450e, 0x0024650e,
-    0x0024850e, 0x0024a50e, 0x0024c50e, 0x0024e50e,
-    0x0025050e, 0x0025250e, 0x0025450e, 0x0025650e,
-    0x0025850e, 0x0025a50e, 0x0025c50e, 0x0025e50e,
-    0x0026050e, 0x0026250e, 0x0026450e, 0x0026650e,
-    0x0026850e, 0x0026a50e, 0x0026c50e, 0x0026e50e,
-    0x0027050e, 0x0027250e, 0x0027450e, 0x0027650e,
-    0x0027850e, 0x0027a50e, 0x0027c50e, 0x0027e50e,
-    0x0028050e, 0x0028250e, 0x0028450e, 0x0028650e,
-    0x0028850e, 0x0028a50e, 0x0028c50e, 0x0028e50e,
-    0x0029050e, 0x0029250e, 0x0029450e, 0x0029650e,
-    0x0029850e, 0x0029a50e, 0x0029c50e, 0x0029e50e,
-    0x002a050e, 0x002a250e, 0x002a450e, 0x002a650e,
-    0x002a850e, 0x002aa50e, 0x002ac50e, 0x002ae50e,
-    0x002b050e, 0x002b250e, 0x002b450e, 0x002b650e,
-    0x002b850e, 0x002ba50e, 0x002bc50e, 0x002be50e,
-    0x002c050e, 0x002c250e, 0x002c450e, 0x002c650e,
-    0x002c850e, 0x002ca50e, 0x002cc50e, 0x002ce50e,
-    0x002d050e, 0x002d250e, 0x002d450e, 0x002d650e,
-    0x002d850e, 0x002da50e, 0x002dc50e, 0x002de50e,
-    0x002e050e, 0x002e250e, 0x002e450e, 0x002e650e,
-    0x002e850e, 0x002ea50e, 0x002ec50e, 0x002ee50e,
-    0x002f050e, 0x002f250e, 0x002f450e, 0x002f650e,
-    0x002f850e, 0x002fa50e, 0x002fc50e, 0x002fe50e,
-    0x0030050e, 0x0030250e, 0x0030450e, 0x0030650e,
-    0x0030850e, 0x0030a50e, 0x0030c50e, 0x0030e50e,
-    0x0031050e, 0x0031250e, 0x0031450e, 0x0031650e,
-    0x0031850e, 0x0031a50e, 0x0031c50e, 0x0031e50e,
-    0x0032050e, 0x0032250e, 0x0032450e, 0x0032650e,
-    0x0032850e, 0x0032a50e, 0x0032c50e, 0x0032e50e,
-    0x0033050e, 0x0033250e, 0x0033450e, 0x0033650e,
-    0x0033850e, 0x0033a50e, 0x0033c50e, 0x0033e50e,
-    0x0034050e, 0x0034250e, 0x0034450e, 0x0034650e,
-    0x0034850e, 0x0034a50e, 0x0034c50e, 0x0034e50e,
-    0x0035050e, 0x0035250e, 0x0035450e, 0x0035650e,
-    0x0035850e, 0x0035a50e, 0x0035c50e, 0x0035e50e,
-    0x0036050e, 0x0036250e, 0x0036450e, 0x0036650e,
-    0x0036850e, 0x0036a50e, 0x0036c50e, 0x0036e50e,
-    0x0037050e, 0x0037250e, 0x0037450e, 0x0037650e,
-    0x0037850e, 0x0037a50e, 0x0037c50e, 0x0037e50e,
-    0x0038050e, 0x0038250e, 0x0038450e, 0x0038650e,
-    0x0038850e, 0x0038a50e, 0x0038c50e, 0x0038e50e,
-    0x0039050e, 0x0039250e, 0x0039450e, 0x0039650e,
-    0x0039850e, 0x0039a50e, 0x0039c50e, 0x0039e50e,
-    0x003a050e, 0x003a250e, 0x003a450e, 0x003a650e,
-    0x003a850e, 0x003aa50e, 0x003ac50e, 0x003ae50e,
-    0x003b050e, 0x003b250e, 0x003b450e, 0x003b650e,
-    0x003b850e, 0x003ba50e, 0x003bc50e, 0x003be50e,
-    0x003c050e, 0x003c250e, 0x003c450e, 0x003c650e,
-    0x003c850e, 0x003ca50e, 0x003cc50e, 0x003ce50e,
-    0x003d050e, 0x003d250e, 0x003d450e, 0x003d650e,
-    0x003d850e, 0x003da50e, 0x003dc50e, 0x003de50e,
-    0x003e050e, 0x003e250e, 0x003e450e, 0x003e650e,
-    0x003e850e, 0x003ea50e, 0x003ec50e, 0x003ee50e,
-    0x003f050e, 0x003f250e, 0x003f450e, 0x003f650e,
-    0x003f850e, 0x003fa50e, 0x003fc50e, 0x003fe50e,
-    0x0000150e, 0x0000350e, 0x0000550e, 0x0000750e,
-    0x0000950e, 0x0000b50e, 0x0000d50e, 0x0000f50e,
-    0x0001150e, 0x0001350e, 0x0001550e, 0x0001750e,
-    0x0001950e, 0x0001b50e, 0x0001d50e, 0x0001f50e,
-    0x0002150e, 0x0002350e, 0x0002550e, 0x0002750e,
-    0x0002950e, 0x0002b50e, 0x0002d50e, 0x0002f50e,
-    0x0003150e, 0x0003350e, 0x0003550e, 0x0003750e,
-    0x0003950e, 0x0003b50e, 0x0003d50e, 0x0003f50e,
-    0x0004150e, 0x0004350e, 0x0004550e, 0x0004750e,
-    0x0004950e, 0x0004b50e, 0x0004d50e, 0x0004f50e,
-    0x0005150e, 0x0005350e, 0x0005550e, 0x0005750e,
-    0x0005950e, 0x0005b50e, 0x0005d50e, 0x0005f50e,
-    0x0006150e, 0x0006350e, 0x0006550e, 0x0006750e,
-    0x0006950e, 0x0006b50e, 0x0006d50e, 0x0006f50e,
-    0x0007150e, 0x0007350e, 0x0007550e, 0x0007750e,
-    0x0007950e, 0x0007b50e, 0x0007d50e, 0x0007f50e,
-    0x0008150e, 0x0008350e, 0x0008550e, 0x0008750e,
-    0x0008950e, 0x0008b50e, 0x0008d50e, 0x0008f50e,
-    0x0009150e, 0x0009350e, 0x0009550e, 0x0009750e,
-    0x0009950e, 0x0009b50e, 0x0009d50e, 0x0009f50e,
-    0x000a150e, 0x000a350e, 0x000a550e, 0x000a750e,
-    0x000a950e, 0x000ab50e, 0x000ad50e, 0x000af50e,
-    0x000b150e, 0x000b350e, 0x000b550e, 0x000b750e,
-    0x000b950e, 0x000bb50e, 0x000bd50e, 0x000bf50e,
-    0x000c150e, 0x000c350e, 0x000c550e, 0x000c750e,
-    0x000c950e, 0x000cb50e, 0x000cd50e, 0x000cf50e,
-    0x000d150e, 0x000d350e, 0x000d550e, 0x000d750e,
-    0x000d950e, 0x000db50e, 0x000dd50e, 0x000df50e,
-    0x000e150e, 0x000e350e, 0x000e550e, 0x000e750e,
-    0x000e950e, 0x000eb50e, 0x000ed50e, 0x000ef50e,
-    0x000f150e, 0x000f350e, 0x000f550e, 0x000f750e,
-    0x000f950e, 0x000fb50e, 0x000fd50e, 0x000ff50e,
-    0x0010150e, 0x0010350e, 0x0010550e, 0x0010750e,
-    0x0010950e, 0x0010b50e, 0x0010d50e, 0x0010f50e,
-    0x0011150e, 0x0011350e, 0x0011550e, 0x0011750e,
-    0x0011950e, 0x0011b50e, 0x0011d50e, 0x0011f50e,
-    0x0012150e, 0x0012350e, 0x0012550e, 0x0012750e,
-    0x0012950e, 0x0012b50e, 0x0012d50e, 0x0012f50e,
-    0x0013150e, 0x0013350e, 0x0013550e, 0x0013750e,
-    0x0013950e, 0x0013b50e, 0x0013d50e, 0x0013f50e,
-    0x0014150e, 0x0014350e, 0x0014550e, 0x0014750e,
-    0x0014950e, 0x0014b50e, 0x0014d50e, 0x0014f50e,
-    0x0015150e, 0x0015350e, 0x0015550e, 0x0015750e,
-    0x0015950e, 0x0015b50e, 0x0015d50e, 0x0015f50e,
-    0x0016150e, 0x0016350e, 0x0016550e, 0x0016750e,
-    0x0016950e, 0x0016b50e, 0x0016d50e, 0x0016f50e,
-    0x0017150e, 0x0017350e, 0x0017550e, 0x0017750e,
-    0x0017950e, 0x0017b50e, 0x0017d50e, 0x0017f50e,
-    0x0018150e, 0x0018350e, 0x0018550e, 0x0018750e,
-    0x0018950e, 0x0018b50e, 0x0018d50e, 0x0018f50e,
-    0x0019150e, 0x0019350e, 0x0019550e, 0x0019750e,
-    0x0019950e, 0x0019b50e, 0x0019d50e, 0x0019f50e,
-    0x001a150e, 0x001a350e, 0x001a550e, 0x001a750e,
-    0x001a950e, 0x001ab50e, 0x001ad50e, 0x001af50e,
-    0x001b150e, 0x001b350e, 0x001b550e, 0x001b750e,
-    0x001b950e, 0x001bb50e, 0x001bd50e, 0x001bf50e,
-    0x001c150e, 0x001c350e, 0x001c550e, 0x001c750e,
-    0x001c950e, 0x001cb50e, 0x001cd50e, 0x001cf50e,
-    0x001d150e, 0x001d350e, 0x001d550e, 0x001d750e,
-    0x001d950e, 0x001db50e, 0x001dd50e, 0x001df50e,
-    0x001e150e, 0x001e350e, 0x001e550e, 0x001e750e,
-    0x001e950e, 0x001eb50e, 0x001ed50e, 0x001ef50e,
-    0x001f150e, 0x001f350e, 0x001f550e, 0x001f750e,
-    0x001f950e, 0x001fb50e, 0x001fd50e, 0x001ff50e,
-    0x0020150e, 0x0020350e, 0x0020550e, 0x0020750e,
-    0x0020950e, 0x0020b50e, 0x0020d50e, 0x0020f50e,
-    0x0021150e, 0x0021350e, 0x0021550e, 0x0021750e,
-    0x0021950e, 0x0021b50e, 0x0021d50e, 0x0021f50e,
-    0x0022150e, 0x0022350e, 0x0022550e, 0x0022750e,
-    0x0022950e, 0x0022b50e, 0x0022d50e, 0x0022f50e,
-    0x0023150e, 0x0023350e, 0x0023550e, 0x0023750e,
-    0x0023950e, 0x0023b50e, 0x0023d50e, 0x0023f50e,
-    0x0024150e, 0x0024350e, 0x0024550e, 0x0024750e,
-    0x0024950e, 0x0024b50e, 0x0024d50e, 0x0024f50e,
-    0x0025150e, 0x0025350e, 0x0025550e, 0x0025750e,
-    0x0025950e, 0x0025b50e, 0x0025d50e, 0x0025f50e,
-    0x0026150e, 0x0026350e, 0x0026550e, 0x0026750e,
-    0x0026950e, 0x0026b50e, 0x0026d50e, 0x0026f50e,
-    0x0027150e, 0x0027350e, 0x0027550e, 0x0027750e,
-    0x0027950e, 0x0027b50e, 0x0027d50e, 0x0027f50e,
-    0x0028150e, 0x0028350e, 0x0028550e, 0x0028750e,
-    0x0028950e, 0x0028b50e, 0x0028d50e, 0x0028f50e,
-    0x0029150e, 0x0029350e, 0x0029550e, 0x0029750e,
-    0x0029950e, 0x0029b50e, 0x0029d50e, 0x0029f50e,
-    0x002a150e, 0x002a350e, 0x002a550e, 0x002a750e,
-    0x002a950e, 0x002ab50e, 0x002ad50e, 0x002af50e,
-    0x002b150e, 0x002b350e, 0x002b550e, 0x002b750e,
-    0x002b950e, 0x002bb50e, 0x002bd50e, 0x002bf50e,
-    0x002c150e, 0x002c350e, 0x002c550e, 0x002c750e,
-    0x002c950e, 0x002cb50e, 0x002cd50e, 0x002cf50e,
-    0x002d150e, 0x002d350e, 0x002d550e, 0x002d750e,
-    0x002d950e, 0x002db50e, 0x002dd50e, 0x002df50e,
-    0x002e150e, 0x002e350e, 0x002e550e, 0x002e750e,
-    0x002e950e, 0x002eb50e, 0x002ed50e, 0x002ef50e,
-    0x002f150e, 0x002f350e, 0x002f550e, 0x002f750e,
-    0x002f950e, 0x002fb50e, 0x002fd50e, 0x002ff50e,
-    0x0030150e, 0x0030350e, 0x0030550e, 0x0030750e,
-    0x0030950e, 0x0030b50e, 0x0030d50e, 0x0030f50e,
-    0x0031150e, 0x0031350e, 0x0031550e, 0x0031750e,
-    0x0031950e, 0x0031b50e, 0x0031d50e, 0x0031f50e,
-    0x0032150e, 0x0032350e, 0x0032550e, 0x0032750e,
-    0x0032950e, 0x0032b50e, 0x0032d50e, 0x0032f50e,
-    0x0033150e, 0x0033350e, 0x0033550e, 0x0033750e,
-    0x0033950e, 0x0033b50e, 0x0033d50e, 0x0033f50e,
-    0x0034150e, 0x0034350e, 0x0034550e, 0x0034750e,
-    0x0034950e, 0x0034b50e, 0x0034d50e, 0x0034f50e,
-    0x0035150e, 0x0035350e, 0x0035550e, 0x0035750e,
-    0x0035950e, 0x0035b50e, 0x0035d50e, 0x0035f50e,
-    0x0036150e, 0x0036350e, 0x0036550e, 0x0036750e,
-    0x0036950e, 0x0036b50e, 0x0036d50e, 0x0036f50e,
-    0x0037150e, 0x0037350e, 0x0037550e, 0x0037750e,
-    0x0037950e, 0x0037b50e, 0x0037d50e, 0x0037f50e,
-    0x0038150e, 0x0038350e, 0x0038550e, 0x0038750e,
-    0x0038950e, 0x0038b50e, 0x0038d50e, 0x0038f50e,
-    0x0039150e, 0x0039350e, 0x0039550e, 0x0039750e,
-    0x0039950e, 0x0039b50e, 0x0039d50e, 0x0039f50e,
-    0x003a150e, 0x003a350e, 0x003a550e, 0x003a750e,
-    0x003a950e, 0x003ab50e, 0x003ad50e, 0x003af50e,
-    0x003b150e, 0x003b350e, 0x003b550e, 0x003b750e,
-    0x003b950e, 0x003bb50e, 0x003bd50e, 0x003bf50e,
-    0x003c150e, 0x003c350e, 0x003c550e, 0x003c750e,
-    0x003c950e, 0x003cb50e, 0x003cd50e, 0x003cf50e,
-    0x003d150e, 0x003d350e, 0x003d550e, 0x003d750e,
-    0x003d950e, 0x003db50e, 0x003dd50e, 0x003df50e,
-    0x003e150e, 0x003e350e, 0x003e550e, 0x003e750e,
-    0x003e950e, 0x003eb50e, 0x003ed50e, 0x003ef50e,
-    0x003f150e, 0x003f350e, 0x003f550e, 0x003f750e,
-    0x003f950e, 0x003fb50e, 0x003fd50e, 0x003ff50e,
-    0x00000d0f, 0x00002d0f, 0x00004d0f, 0x00006d0f,
-    0x00008d0f, 0x0000ad0f, 0x0000cd0f, 0x0000ed0f,
-    0x00010d0f, 0x00012d0f, 0x00014d0f, 0x00016d0f,
-    0x00018d0f, 0x0001ad0f, 0x0001cd0f, 0x0001ed0f,
-    0x00020d0f, 0x00022d0f, 0x00024d0f, 0x00026d0f,
-    0x00028d0f, 0x0002ad0f, 0x0002cd0f, 0x0002ed0f,
-    0x00030d0f, 0x00032d0f, 0x00034d0f, 0x00036d0f,
-    0x00038d0f, 0x0003ad0f, 0x0003cd0f, 0x0003ed0f,
-    0x00040d0f, 0x00042d0f, 0x00044d0f, 0x00046d0f,
-    0x00048d0f, 0x0004ad0f, 0x0004cd0f, 0x0004ed0f,
-    0x00050d0f, 0x00052d0f, 0x00054d0f, 0x00056d0f,
-    0x00058d0f, 0x0005ad0f, 0x0005cd0f, 0x0005ed0f,
-    0x00060d0f, 0x00062d0f, 0x00064d0f, 0x00066d0f,
-    0x00068d0f, 0x0006ad0f, 0x0006cd0f, 0x0006ed0f,
-    0x00070d0f, 0x00072d0f, 0x00074d0f, 0x00076d0f,
-    0x00078d0f, 0x0007ad0f, 0x0007cd0f, 0x0007ed0f,
-    0x00080d0f, 0x00082d0f, 0x00084d0f, 0x00086d0f,
-    0x00088d0f, 0x0008ad0f, 0x0008cd0f, 0x0008ed0f,
-    0x00090d0f, 0x00092d0f, 0x00094d0f, 0x00096d0f,
-    0x00098d0f, 0x0009ad0f, 0x0009cd0f, 0x0009ed0f,
-    0x000a0d0f, 0x000a2d0f, 0x000a4d0f, 0x000a6d0f,
-    0x000a8d0f, 0x000aad0f, 0x000acd0f, 0x000aed0f,
-    0x000b0d0f, 0x000b2d0f, 0x000b4d0f, 0x000b6d0f,
-    0x000b8d0f, 0x000bad0f, 0x000bcd0f, 0x000bed0f,
-    0x000c0d0f, 0x000c2d0f, 0x000c4d0f, 0x000c6d0f,
-    0x000c8d0f, 0x000cad0f, 0x000ccd0f, 0x000ced0f,
-    0x000d0d0f, 0x000d2d0f, 0x000d4d0f, 0x000d6d0f,
-    0x000d8d0f, 0x000dad0f, 0x000dcd0f, 0x000ded0f,
-    0x000e0d0f, 0x000e2d0f, 0x000e4d0f, 0x000e6d0f,
-    0x000e8d0f, 0x000ead0f, 0x000ecd0f, 0x000eed0f,
-    0x000f0d0f, 0x000f2d0f, 0x000f4d0f, 0x000f6d0f,
-    0x000f8d0f, 0x000fad0f, 0x000fcd0f, 0x000fed0f,
-    0x00100d0f, 0x00102d0f, 0x00104d0f, 0x00106d0f,
-    0x00108d0f, 0x0010ad0f, 0x0010cd0f, 0x0010ed0f,
-    0x00110d0f, 0x00112d0f, 0x00114d0f, 0x00116d0f,
-    0x00118d0f, 0x0011ad0f, 0x0011cd0f, 0x0011ed0f,
-    0x00120d0f, 0x00122d0f, 0x00124d0f, 0x00126d0f,
-    0x00128d0f, 0x0012ad0f, 0x0012cd0f, 0x0012ed0f,
-    0x00130d0f, 0x00132d0f, 0x00134d0f, 0x00136d0f,
-    0x00138d0f, 0x0013ad0f, 0x0013cd0f, 0x0013ed0f,
-    0x00140d0f, 0x00142d0f, 0x00144d0f, 0x00146d0f,
-    0x00148d0f, 0x0014ad0f, 0x0014cd0f, 0x0014ed0f,
-    0x00150d0f, 0x00152d0f, 0x00154d0f, 0x00156d0f,
-    0x00158d0f, 0x0015ad0f, 0x0015cd0f, 0x0015ed0f,
-    0x00160d0f, 0x00162d0f, 0x00164d0f, 0x00166d0f,
-    0x00168d0f, 0x0016ad0f, 0x0016cd0f, 0x0016ed0f,
-    0x00170d0f, 0x00172d0f, 0x00174d0f, 0x00176d0f,
-    0x00178d0f, 0x0017ad0f, 0x0017cd0f, 0x0017ed0f,
-    0x00180d0f, 0x00182d0f, 0x00184d0f, 0x00186d0f,
-    0x00188d0f, 0x0018ad0f, 0x0018cd0f, 0x0018ed0f,
-    0x00190d0f, 0x00192d0f, 0x00194d0f, 0x00196d0f,
-    0x00198d0f, 0x0019ad0f, 0x0019cd0f, 0x0019ed0f,
-    0x001a0d0f, 0x001a2d0f, 0x001a4d0f, 0x001a6d0f,
-    0x001a8d0f, 0x001aad0f, 0x001acd0f, 0x001aed0f,
-    0x001b0d0f, 0x001b2d0f, 0x001b4d0f, 0x001b6d0f,
-    0x001b8d0f, 0x001bad0f, 0x001bcd0f, 0x001bed0f,
-    0x001c0d0f, 0x001c2d0f, 0x001c4d0f, 0x001c6d0f,
-    0x001c8d0f, 0x001cad0f, 0x001ccd0f, 0x001ced0f,
-    0x001d0d0f, 0x001d2d0f, 0x001d4d0f, 0x001d6d0f,
-    0x001d8d0f, 0x001dad0f, 0x001dcd0f, 0x001ded0f,
-    0x001e0d0f, 0x001e2d0f, 0x001e4d0f, 0x001e6d0f,
-    0x001e8d0f, 0x001ead0f, 0x001ecd0f, 0x001eed0f,
-    0x001f0d0f, 0x001f2d0f, 0x001f4d0f, 0x001f6d0f,
-    0x001f8d0f, 0x001fad0f, 0x001fcd0f, 0x001fed0f,
-    0x00200d0f, 0x00202d0f, 0x00204d0f, 0x00206d0f,
-    0x00208d0f, 0x0020ad0f, 0x0020cd0f, 0x0020ed0f,
-    0x00210d0f, 0x00212d0f, 0x00214d0f, 0x00216d0f,
-    0x00218d0f, 0x0021ad0f, 0x0021cd0f, 0x0021ed0f,
-    0x00220d0f, 0x00222d0f, 0x00224d0f, 0x00226d0f,
-    0x00228d0f, 0x0022ad0f, 0x0022cd0f, 0x0022ed0f,
-    0x00230d0f, 0x00232d0f, 0x00234d0f, 0x00236d0f,
-    0x00238d0f, 0x0023ad0f, 0x0023cd0f, 0x0023ed0f,
-    0x00240d0f, 0x00242d0f, 0x00244d0f, 0x00246d0f,
-    0x00248d0f, 0x0024ad0f, 0x0024cd0f, 0x0024ed0f,
-    0x00250d0f, 0x00252d0f, 0x00254d0f, 0x00256d0f,
-    0x00258d0f, 0x0025ad0f, 0x0025cd0f, 0x0025ed0f,
-    0x00260d0f, 0x00262d0f, 0x00264d0f, 0x00266d0f,
-    0x00268d0f, 0x0026ad0f, 0x0026cd0f, 0x0026ed0f,
-    0x00270d0f, 0x00272d0f, 0x00274d0f, 0x00276d0f,
-    0x00278d0f, 0x0027ad0f, 0x0027cd0f, 0x0027ed0f,
-    0x00280d0f, 0x00282d0f, 0x00284d0f, 0x00286d0f,
-    0x00288d0f, 0x0028ad0f, 0x0028cd0f, 0x0028ed0f,
-    0x00290d0f, 0x00292d0f, 0x00294d0f, 0x00296d0f,
-    0x00298d0f, 0x0029ad0f, 0x0029cd0f, 0x0029ed0f,
-    0x002a0d0f, 0x002a2d0f, 0x002a4d0f, 0x002a6d0f,
-    0x002a8d0f, 0x002aad0f, 0x002acd0f, 0x002aed0f,
-    0x002b0d0f, 0x002b2d0f, 0x002b4d0f, 0x002b6d0f,
-    0x002b8d0f, 0x002bad0f, 0x002bcd0f, 0x002bed0f,
-    0x002c0d0f, 0x002c2d0f, 0x002c4d0f, 0x002c6d0f,
-    0x002c8d0f, 0x002cad0f, 0x002ccd0f, 0x002ced0f,
-    0x002d0d0f, 0x002d2d0f, 0x002d4d0f, 0x002d6d0f,
-    0x002d8d0f, 0x002dad0f, 0x002dcd0f, 0x002ded0f,
-    0x002e0d0f, 0x002e2d0f, 0x002e4d0f, 0x002e6d0f,
-    0x002e8d0f, 0x002ead0f, 0x002ecd0f, 0x002eed0f,
-    0x002f0d0f, 0x002f2d0f, 0x002f4d0f, 0x002f6d0f,
-    0x002f8d0f, 0x002fad0f, 0x002fcd0f, 0x002fed0f,
-    0x00300d0f, 0x00302d0f, 0x00304d0f, 0x00306d0f,
-    0x00308d0f, 0x0030ad0f, 0x0030cd0f, 0x0030ed0f,
-    0x00310d0f, 0x00312d0f, 0x00314d0f, 0x00316d0f,
-    0x00318d0f, 0x0031ad0f, 0x0031cd0f, 0x0031ed0f,
-    0x00320d0f, 0x00322d0f, 0x00324d0f, 0x00326d0f,
-    0x00328d0f, 0x0032ad0f, 0x0032cd0f, 0x0032ed0f,
-    0x00330d0f, 0x00332d0f, 0x00334d0f, 0x00336d0f,
-    0x00338d0f, 0x0033ad0f, 0x0033cd0f, 0x0033ed0f,
-    0x00340d0f, 0x00342d0f, 0x00344d0f, 0x00346d0f,
-    0x00348d0f, 0x0034ad0f, 0x0034cd0f, 0x0034ed0f,
-    0x00350d0f, 0x00352d0f, 0x00354d0f, 0x00356d0f,
-    0x00358d0f, 0x0035ad0f, 0x0035cd0f, 0x0035ed0f,
-    0x00360d0f, 0x00362d0f, 0x00364d0f, 0x00366d0f,
-    0x00368d0f, 0x0036ad0f, 0x0036cd0f, 0x0036ed0f,
-    0x00370d0f, 0x00372d0f, 0x00374d0f, 0x00376d0f,
-    0x00378d0f, 0x0037ad0f, 0x0037cd0f, 0x0037ed0f,
-    0x00380d0f, 0x00382d0f, 0x00384d0f, 0x00386d0f,
-    0x00388d0f, 0x0038ad0f, 0x0038cd0f, 0x0038ed0f,
-    0x00390d0f, 0x00392d0f, 0x00394d0f, 0x00396d0f,
-    0x00398d0f, 0x0039ad0f, 0x0039cd0f, 0x0039ed0f,
-    0x003a0d0f, 0x003a2d0f, 0x003a4d0f, 0x003a6d0f,
-    0x003a8d0f, 0x003aad0f, 0x003acd0f, 0x003aed0f,
-    0x003b0d0f, 0x003b2d0f, 0x003b4d0f, 0x003b6d0f,
-    0x003b8d0f, 0x003bad0f, 0x003bcd0f, 0x003bed0f,
-    0x003c0d0f, 0x003c2d0f, 0x003c4d0f, 0x003c6d0f,
-    0x003c8d0f, 0x003cad0f, 0x003ccd0f, 0x003ced0f,
-    0x003d0d0f, 0x003d2d0f, 0x003d4d0f, 0x003d6d0f,
-    0x003d8d0f, 0x003dad0f, 0x003dcd0f, 0x003ded0f,
-    0x003e0d0f, 0x003e2d0f, 0x003e4d0f, 0x003e6d0f,
-    0x003e8d0f, 0x003ead0f, 0x003ecd0f, 0x003eed0f,
-    0x003f0d0f, 0x003f2d0f, 0x003f4d0f, 0x003f6d0f,
-    0x003f8d0f, 0x003fad0f, 0x003fcd0f, 0x003fed0f,
-    0x00400d0f, 0x00402d0f, 0x00404d0f, 0x00406d0f,
-    0x00408d0f, 0x0040ad0f, 0x0040cd0f, 0x0040ed0f,
-    0x00410d0f, 0x00412d0f, 0x00414d0f, 0x00416d0f,
-    0x00418d0f, 0x0041ad0f, 0x0041cd0f, 0x0041ed0f,
-    0x00420d0f, 0x00422d0f, 0x00424d0f, 0x00426d0f,
-    0x00428d0f, 0x0042ad0f, 0x0042cd0f, 0x0042ed0f,
-    0x00430d0f, 0x00432d0f, 0x00434d0f, 0x00436d0f,
-    0x00438d0f, 0x0043ad0f, 0x0043cd0f, 0x0043ed0f,
-    0x00440d0f, 0x00442d0f, 0x00444d0f, 0x00446d0f,
-    0x00448d0f, 0x0044ad0f, 0x0044cd0f, 0x0044ed0f,
-    0x00450d0f, 0x00452d0f, 0x00454d0f, 0x00456d0f,
-    0x00458d0f, 0x0045ad0f, 0x0045cd0f, 0x0045ed0f,
-    0x00460d0f, 0x00462d0f, 0x00464d0f, 0x00466d0f,
-    0x00468d0f, 0x0046ad0f, 0x0046cd0f, 0x0046ed0f,
-    0x00470d0f, 0x00472d0f, 0x00474d0f, 0x00476d0f,
-    0x00478d0f, 0x0047ad0f, 0x0047cd0f, 0x0047ed0f,
-    0x00480d0f, 0x00482d0f, 0x00484d0f, 0x00486d0f,
-    0x00488d0f, 0x0048ad0f, 0x0048cd0f, 0x0048ed0f,
-    0x00490d0f, 0x00492d0f, 0x00494d0f, 0x00496d0f,
-    0x00498d0f, 0x0049ad0f, 0x0049cd0f, 0x0049ed0f,
-    0x004a0d0f, 0x004a2d0f, 0x004a4d0f, 0x004a6d0f,
-    0x004a8d0f, 0x004aad0f, 0x004acd0f, 0x004aed0f,
-    0x004b0d0f, 0x004b2d0f, 0x004b4d0f, 0x004b6d0f,
-    0x004b8d0f, 0x004bad0f, 0x004bcd0f, 0x004bed0f,
-    0x004c0d0f, 0x004c2d0f, 0x004c4d0f, 0x004c6d0f,
-    0x004c8d0f, 0x004cad0f, 0x004ccd0f, 0x004ced0f,
-    0x004d0d0f, 0x004d2d0f, 0x004d4d0f, 0x004d6d0f,
-    0x004d8d0f, 0x004dad0f, 0x004dcd0f, 0x004ded0f,
-    0x004e0d0f, 0x004e2d0f, 0x004e4d0f, 0x004e6d0f,
-    0x004e8d0f, 0x004ead0f, 0x004ecd0f, 0x004eed0f,
-    0x004f0d0f, 0x004f2d0f, 0x004f4d0f, 0x004f6d0f,
-    0x004f8d0f, 0x004fad0f, 0x004fcd0f, 0x004fed0f,
-    0x00500d0f, 0x00502d0f, 0x00504d0f, 0x00506d0f,
-    0x00508d0f, 0x0050ad0f, 0x0050cd0f, 0x0050ed0f,
-    0x00510d0f, 0x00512d0f, 0x00514d0f, 0x00516d0f,
-    0x00518d0f, 0x0051ad0f, 0x0051cd0f, 0x0051ed0f,
-    0x00520d0f, 0x00522d0f, 0x00524d0f, 0x00526d0f,
-    0x00528d0f, 0x0052ad0f, 0x0052cd0f, 0x0052ed0f,
-    0x00530d0f, 0x00532d0f, 0x00534d0f, 0x00536d0f,
-    0x00538d0f, 0x0053ad0f, 0x0053cd0f, 0x0053ed0f,
-    0x00540d0f, 0x00542d0f, 0x00544d0f, 0x00546d0f,
-    0x00548d0f, 0x0054ad0f, 0x0054cd0f, 0x0054ed0f,
-    0x00550d0f, 0x00552d0f, 0x00554d0f, 0x00556d0f,
-    0x00558d0f, 0x0055ad0f, 0x0055cd0f, 0x0055ed0f,
-    0x00560d0f, 0x00562d0f, 0x00564d0f, 0x00566d0f,
-    0x00568d0f, 0x0056ad0f, 0x0056cd0f, 0x0056ed0f,
-    0x00570d0f, 0x00572d0f, 0x00574d0f, 0x00576d0f,
-    0x00578d0f, 0x0057ad0f, 0x0057cd0f, 0x0057ed0f,
-    0x00580d0f, 0x00582d0f, 0x00584d0f, 0x00586d0f,
-    0x00588d0f, 0x0058ad0f, 0x0058cd0f, 0x0058ed0f,
-    0x00590d0f, 0x00592d0f, 0x00594d0f, 0x00596d0f,
-    0x00598d0f, 0x0059ad0f, 0x0059cd0f, 0x0059ed0f,
-    0x005a0d0f, 0x005a2d0f, 0x005a4d0f, 0x005a6d0f,
-    0x005a8d0f, 0x005aad0f, 0x005acd0f, 0x005aed0f,
-    0x005b0d0f, 0x005b2d0f, 0x005b4d0f, 0x005b6d0f,
-    0x005b8d0f, 0x005bad0f, 0x005bcd0f, 0x005bed0f,
-    0x005c0d0f, 0x005c2d0f, 0x005c4d0f, 0x005c6d0f,
-    0x005c8d0f, 0x005cad0f, 0x005ccd0f, 0x005ced0f,
-    0x005d0d0f, 0x005d2d0f, 0x005d4d0f, 0x005d6d0f,
-    0x005d8d0f, 0x005dad0f, 0x005dcd0f, 0x005ded0f,
-    0x005e0d0f, 0x005e2d0f, 0x005e4d0f, 0x005e6d0f,
-    0x005e8d0f, 0x005ead0f, 0x005ecd0f, 0x005eed0f,
-    0x005f0d0f, 0x005f2d0f, 0x005f4d0f, 0x005f6d0f,
-    0x005f8d0f, 0x005fad0f, 0x005fcd0f, 0x005fed0f,
-    0x00600d0f, 0x00602d0f, 0x00604d0f, 0x00606d0f,
-    0x00608d0f, 0x0060ad0f, 0x0060cd0f, 0x0060ed0f,
-    0x00610d0f, 0x00612d0f, 0x00614d0f, 0x00616d0f,
-    0x00618d0f, 0x0061ad0f, 0x0061cd0f, 0x0061ed0f,
-    0x00620d0f, 0x00622d0f, 0x00624d0f, 0x00626d0f,
-    0x00628d0f, 0x0062ad0f, 0x0062cd0f, 0x0062ed0f,
-    0x00630d0f, 0x00632d0f, 0x00634d0f, 0x00636d0f,
-    0x00638d0f, 0x0063ad0f, 0x0063cd0f, 0x0063ed0f,
-    0x00640d0f, 0x00642d0f, 0x00644d0f, 0x00646d0f,
-    0x00648d0f, 0x0064ad0f, 0x0064cd0f, 0x0064ed0f,
-    0x00650d0f, 0x00652d0f, 0x00654d0f, 0x00656d0f,
-    0x00658d0f, 0x0065ad0f, 0x0065cd0f, 0x0065ed0f,
-    0x00660d0f, 0x00662d0f, 0x00664d0f, 0x00666d0f,
-    0x00668d0f, 0x0066ad0f, 0x0066cd0f, 0x0066ed0f,
-    0x00670d0f, 0x00672d0f, 0x00674d0f, 0x00676d0f,
-    0x00678d0f, 0x0067ad0f, 0x0067cd0f, 0x0067ed0f,
-    0x00680d0f, 0x00682d0f, 0x00684d0f, 0x00686d0f,
-    0x00688d0f, 0x0068ad0f, 0x0068cd0f, 0x0068ed0f,
-    0x00690d0f, 0x00692d0f, 0x00694d0f, 0x00696d0f,
-    0x00698d0f, 0x0069ad0f, 0x0069cd0f, 0x0069ed0f,
-    0x006a0d0f, 0x006a2d0f, 0x006a4d0f, 0x006a6d0f,
-    0x006a8d0f, 0x006aad0f, 0x006acd0f, 0x006aed0f,
-    0x006b0d0f, 0x006b2d0f, 0x006b4d0f, 0x006b6d0f,
-    0x006b8d0f, 0x006bad0f, 0x006bcd0f, 0x006bed0f,
-    0x006c0d0f, 0x006c2d0f, 0x006c4d0f, 0x006c6d0f,
-    0x006c8d0f, 0x006cad0f, 0x006ccd0f, 0x006ced0f,
-    0x006d0d0f, 0x006d2d0f, 0x006d4d0f, 0x006d6d0f,
-    0x006d8d0f, 0x006dad0f, 0x006dcd0f, 0x006ded0f,
-    0x006e0d0f, 0x006e2d0f, 0x006e4d0f, 0x006e6d0f,
-    0x006e8d0f, 0x006ead0f, 0x006ecd0f, 0x006eed0f,
-    0x006f0d0f, 0x006f2d0f, 0x006f4d0f, 0x006f6d0f,
-    0x006f8d0f, 0x006fad0f, 0x006fcd0f, 0x006fed0f,
-    0x00700d0f, 0x00702d0f, 0x00704d0f, 0x00706d0f,
-    0x00708d0f, 0x0070ad0f, 0x0070cd0f, 0x0070ed0f,
-    0x00710d0f, 0x00712d0f, 0x00714d0f, 0x00716d0f,
-    0x00718d0f, 0x0071ad0f, 0x0071cd0f, 0x0071ed0f,
-    0x00720d0f, 0x00722d0f, 0x00724d0f, 0x00726d0f,
-    0x00728d0f, 0x0072ad0f, 0x0072cd0f, 0x0072ed0f,
-    0x00730d0f, 0x00732d0f, 0x00734d0f, 0x00736d0f,
-    0x00738d0f, 0x0073ad0f, 0x0073cd0f, 0x0073ed0f,
-    0x00740d0f, 0x00742d0f, 0x00744d0f, 0x00746d0f,
-    0x00748d0f, 0x0074ad0f, 0x0074cd0f, 0x0074ed0f,
-    0x00750d0f, 0x00752d0f, 0x00754d0f, 0x00756d0f,
-    0x00758d0f, 0x0075ad0f, 0x0075cd0f, 0x0075ed0f,
-    0x00760d0f, 0x00762d0f, 0x00764d0f, 0x00766d0f,
-    0x00768d0f, 0x0076ad0f, 0x0076cd0f, 0x0076ed0f,
-    0x00770d0f, 0x00772d0f, 0x00774d0f, 0x00776d0f,
-    0x00778d0f, 0x0077ad0f, 0x0077cd0f, 0x0077ed0f,
-    0x00780d0f, 0x00782d0f, 0x00784d0f, 0x00786d0f,
-    0x00788d0f, 0x0078ad0f, 0x0078cd0f, 0x0078ed0f,
-    0x00790d0f, 0x00792d0f, 0x00794d0f, 0x00796d0f,
-    0x00798d0f, 0x0079ad0f, 0x0079cd0f, 0x0079ed0f,
-    0x007a0d0f, 0x007a2d0f, 0x007a4d0f, 0x007a6d0f,
-    0x007a8d0f, 0x007aad0f, 0x007acd0f, 0x007aed0f,
-    0x007b0d0f, 0x007b2d0f, 0x007b4d0f, 0x007b6d0f,
-    0x007b8d0f, 0x007bad0f, 0x007bcd0f, 0x007bed0f,
-    0x007c0d0f, 0x007c2d0f, 0x007c4d0f, 0x007c6d0f,
-    0x007c8d0f, 0x007cad0f, 0x007ccd0f, 0x007ced0f,
-    0x007d0d0f, 0x007d2d0f, 0x007d4d0f, 0x007d6d0f,
-    0x007d8d0f, 0x007dad0f, 0x007dcd0f, 0x007ded0f,
-    0x007e0d0f, 0x007e2d0f, 0x007e4d0f, 0x007e6d0f,
-    0x007e8d0f, 0x007ead0f, 0x007ecd0f, 0x007eed0f,
-    0x007f0d0f, 0x007f2d0f, 0x007f4d0f, 0x007f6d0f,
-    0x007f8d0f, 0x007fad0f, 0x007fcd0f, 0x007fed0f,
-    0x00001d0f, 0x00003d0f, 0x00005d0f, 0x00007d0f,
-    0x00009d0f, 0x0000bd0f, 0x0000dd0f, 0x0000fd0f,
-    0x00011d0f, 0x00013d0f, 0x00015d0f, 0x00017d0f,
-    0x00019d0f, 0x0001bd0f, 0x0001dd0f, 0x0001fd0f,
-    0x00021d0f, 0x00023d0f, 0x00025d0f, 0x00027d0f,
-    0x00029d0f, 0x0002bd0f, 0x0002dd0f, 0x0002fd0f,
-    0x00031d0f, 0x00033d0f, 0x00035d0f, 0x00037d0f,
-    0x00039d0f, 0x0003bd0f, 0x0003dd0f, 0x0003fd0f,
-    0x00041d0f, 0x00043d0f, 0x00045d0f, 0x00047d0f,
-    0x00049d0f, 0x0004bd0f, 0x0004dd0f, 0x0004fd0f,
-    0x00051d0f, 0x00053d0f, 0x00055d0f, 0x00057d0f,
-    0x00059d0f, 0x0005bd0f, 0x0005dd0f, 0x0005fd0f,
-    0x00061d0f, 0x00063d0f, 0x00065d0f, 0x00067d0f,
-    0x00069d0f, 0x0006bd0f, 0x0006dd0f, 0x0006fd0f,
-    0x00071d0f, 0x00073d0f, 0x00075d0f, 0x00077d0f,
-    0x00079d0f, 0x0007bd0f, 0x0007dd0f, 0x0007fd0f,
-    0x00081d0f, 0x00083d0f, 0x00085d0f, 0x00087d0f,
-    0x00089d0f, 0x0008bd0f, 0x0008dd0f, 0x0008fd0f,
-    0x00091d0f, 0x00093d0f, 0x00095d0f, 0x00097d0f,
-    0x00099d0f, 0x0009bd0f, 0x0009dd0f, 0x0009fd0f,
-    0x000a1d0f, 0x000a3d0f, 0x000a5d0f, 0x000a7d0f,
-    0x000a9d0f, 0x000abd0f, 0x000add0f, 0x000afd0f,
-    0x000b1d0f, 0x000b3d0f, 0x000b5d0f, 0x000b7d0f,
-    0x000b9d0f, 0x000bbd0f, 0x000bdd0f, 0x000bfd0f,
-    0x000c1d0f, 0x000c3d0f, 0x000c5d0f, 0x000c7d0f,
-    0x000c9d0f, 0x000cbd0f, 0x000cdd0f, 0x000cfd0f,
-    0x000d1d0f, 0x000d3d0f, 0x000d5d0f, 0x000d7d0f,
-    0x000d9d0f, 0x000dbd0f, 0x000ddd0f, 0x000dfd0f,
-    0x000e1d0f, 0x000e3d0f, 0x000e5d0f, 0x000e7d0f,
-    0x000e9d0f, 0x000ebd0f, 0x000edd0f, 0x000efd0f,
-    0x000f1d0f, 0x000f3d0f, 0x000f5d0f, 0x000f7d0f,
-    0x000f9d0f, 0x000fbd0f, 0x000fdd0f, 0x000ffd0f,
-    0x00101d0f, 0x00103d0f, 0x00105d0f, 0x00107d0f,
-    0x00109d0f, 0x0010bd0f, 0x0010dd0f, 0x0010fd0f,
-    0x00111d0f, 0x00113d0f, 0x00115d0f, 0x00117d0f,
-    0x00119d0f, 0x0011bd0f, 0x0011dd0f, 0x0011fd0f,
-    0x00121d0f, 0x00123d0f, 0x00125d0f, 0x00127d0f,
-    0x00129d0f, 0x0012bd0f, 0x0012dd0f, 0x0012fd0f,
-    0x00131d0f, 0x00133d0f, 0x00135d0f, 0x00137d0f,
-    0x00139d0f, 0x0013bd0f, 0x0013dd0f, 0x0013fd0f,
-    0x00141d0f, 0x00143d0f, 0x00145d0f, 0x00147d0f,
-    0x00149d0f, 0x0014bd0f, 0x0014dd0f, 0x0014fd0f,
-    0x00151d0f, 0x00153d0f, 0x00155d0f, 0x00157d0f,
-    0x00159d0f, 0x0015bd0f, 0x0015dd0f, 0x0015fd0f,
-    0x00161d0f, 0x00163d0f, 0x00165d0f, 0x00167d0f,
-    0x00169d0f, 0x0016bd0f, 0x0016dd0f, 0x0016fd0f,
-    0x00171d0f, 0x00173d0f, 0x00175d0f, 0x00177d0f,
-    0x00179d0f, 0x0017bd0f, 0x0017dd0f, 0x0017fd0f,
-    0x00181d0f, 0x00183d0f, 0x00185d0f, 0x00187d0f,
-    0x00189d0f, 0x0018bd0f, 0x0018dd0f, 0x0018fd0f,
-    0x00191d0f, 0x00193d0f, 0x00195d0f, 0x00197d0f,
-    0x00199d0f, 0x0019bd0f, 0x0019dd0f, 0x0019fd0f,
-    0x001a1d0f, 0x001a3d0f, 0x001a5d0f, 0x001a7d0f,
-    0x001a9d0f, 0x001abd0f, 0x001add0f, 0x001afd0f,
-    0x001b1d0f, 0x001b3d0f, 0x001b5d0f, 0x001b7d0f,
-    0x001b9d0f, 0x001bbd0f, 0x001bdd0f, 0x001bfd0f,
-    0x001c1d0f, 0x001c3d0f, 0x001c5d0f, 0x001c7d0f,
-    0x001c9d0f, 0x001cbd0f, 0x001cdd0f, 0x001cfd0f,
-    0x001d1d0f, 0x001d3d0f, 0x001d5d0f, 0x001d7d0f,
-    0x001d9d0f, 0x001dbd0f, 0x001ddd0f, 0x001dfd0f,
-    0x001e1d0f, 0x001e3d0f, 0x001e5d0f, 0x001e7d0f,
-    0x001e9d0f, 0x001ebd0f, 0x001edd0f, 0x001efd0f,
-    0x001f1d0f, 0x001f3d0f, 0x001f5d0f, 0x001f7d0f,
-    0x001f9d0f, 0x001fbd0f, 0x001fdd0f, 0x001ffd0f,
-    0x00201d0f, 0x00203d0f, 0x00205d0f, 0x00207d0f,
-    0x00209d0f, 0x0020bd0f, 0x0020dd0f, 0x0020fd0f,
-    0x00211d0f, 0x00213d0f, 0x00215d0f, 0x00217d0f,
-    0x00219d0f, 0x0021bd0f, 0x0021dd0f, 0x0021fd0f,
-    0x00221d0f, 0x00223d0f, 0x00225d0f, 0x00227d0f,
-    0x00229d0f, 0x0022bd0f, 0x0022dd0f, 0x0022fd0f,
-    0x00231d0f, 0x00233d0f, 0x00235d0f, 0x00237d0f,
-    0x00239d0f, 0x0023bd0f, 0x0023dd0f, 0x0023fd0f,
-    0x00241d0f, 0x00243d0f, 0x00245d0f, 0x00247d0f,
-    0x00249d0f, 0x0024bd0f, 0x0024dd0f, 0x0024fd0f,
-    0x00251d0f, 0x00253d0f, 0x00255d0f, 0x00257d0f,
-    0x00259d0f, 0x0025bd0f, 0x0025dd0f, 0x0025fd0f,
-    0x00261d0f, 0x00263d0f, 0x00265d0f, 0x00267d0f,
-    0x00269d0f, 0x0026bd0f, 0x0026dd0f, 0x0026fd0f,
-    0x00271d0f, 0x00273d0f, 0x00275d0f, 0x00277d0f,
-    0x00279d0f, 0x0027bd0f, 0x0027dd0f, 0x0027fd0f,
-    0x00281d0f, 0x00283d0f, 0x00285d0f, 0x00287d0f,
-    0x00289d0f, 0x0028bd0f, 0x0028dd0f, 0x0028fd0f,
-    0x00291d0f, 0x00293d0f, 0x00295d0f, 0x00297d0f,
-    0x00299d0f, 0x0029bd0f, 0x0029dd0f, 0x0029fd0f,
-    0x002a1d0f, 0x002a3d0f, 0x002a5d0f, 0x002a7d0f,
-    0x002a9d0f, 0x002abd0f, 0x002add0f, 0x002afd0f,
-    0x002b1d0f, 0x002b3d0f, 0x002b5d0f, 0x002b7d0f,
-    0x002b9d0f, 0x002bbd0f, 0x002bdd0f, 0x002bfd0f,
-    0x002c1d0f, 0x002c3d0f, 0x002c5d0f, 0x002c7d0f,
-    0x002c9d0f, 0x002cbd0f, 0x002cdd0f, 0x002cfd0f,
-    0x002d1d0f, 0x002d3d0f, 0x002d5d0f, 0x002d7d0f,
-    0x002d9d0f, 0x002dbd0f, 0x002ddd0f, 0x002dfd0f,
-    0x002e1d0f, 0x002e3d0f, 0x002e5d0f, 0x002e7d0f,
-    0x002e9d0f, 0x002ebd0f, 0x002edd0f, 0x002efd0f,
-    0x002f1d0f, 0x002f3d0f, 0x002f5d0f, 0x002f7d0f,
-    0x002f9d0f, 0x002fbd0f, 0x002fdd0f, 0x002ffd0f,
-    0x00301d0f, 0x00303d0f, 0x00305d0f, 0x00307d0f,
-    0x00309d0f, 0x0030bd0f, 0x0030dd0f, 0x0030fd0f,
-    0x00311d0f, 0x00313d0f, 0x00315d0f, 0x00317d0f,
-    0x00319d0f, 0x0031bd0f, 0x0031dd0f, 0x0031fd0f,
-    0x00321d0f, 0x00323d0f, 0x00325d0f, 0x00327d0f,
-    0x00329d0f, 0x0032bd0f, 0x0032dd0f, 0x0032fd0f,
-    0x00331d0f, 0x00333d0f, 0x00335d0f, 0x00337d0f,
-    0x00339d0f, 0x0033bd0f, 0x0033dd0f, 0x0033fd0f,
-    0x00341d0f, 0x00343d0f, 0x00345d0f, 0x00347d0f,
-    0x00349d0f, 0x0034bd0f, 0x0034dd0f, 0x0034fd0f,
-    0x00351d0f, 0x00353d0f, 0x00355d0f, 0x00357d0f,
-    0x00359d0f, 0x0035bd0f, 0x0035dd0f, 0x0035fd0f,
-    0x00361d0f, 0x00363d0f, 0x00365d0f, 0x00367d0f,
-    0x00369d0f, 0x0036bd0f, 0x0036dd0f, 0x0036fd0f,
-    0x00371d0f, 0x00373d0f, 0x00375d0f, 0x00377d0f,
-    0x00379d0f, 0x0037bd0f, 0x0037dd0f, 0x0037fd0f,
-    0x00381d0f, 0x00383d0f, 0x00385d0f, 0x00387d0f,
-    0x00389d0f, 0x0038bd0f, 0x0038dd0f, 0x0038fd0f,
-    0x00391d0f, 0x00393d0f, 0x00395d0f, 0x00397d0f,
-    0x00399d0f, 0x0039bd0f, 0x0039dd0f, 0x0039fd0f,
-    0x003a1d0f, 0x003a3d0f, 0x003a5d0f, 0x003a7d0f,
-    0x003a9d0f, 0x003abd0f, 0x003add0f, 0x003afd0f,
-    0x003b1d0f, 0x003b3d0f, 0x003b5d0f, 0x003b7d0f,
-    0x003b9d0f, 0x003bbd0f, 0x003bdd0f, 0x003bfd0f,
-    0x003c1d0f, 0x003c3d0f, 0x003c5d0f, 0x003c7d0f,
-    0x003c9d0f, 0x003cbd0f, 0x003cdd0f, 0x003cfd0f,
-    0x003d1d0f, 0x003d3d0f, 0x003d5d0f, 0x003d7d0f,
-    0x003d9d0f, 0x003dbd0f, 0x003ddd0f, 0x003dfd0f,
-    0x003e1d0f, 0x003e3d0f, 0x003e5d0f, 0x003e7d0f,
-    0x003e9d0f, 0x003ebd0f, 0x003edd0f, 0x003efd0f,
-    0x003f1d0f, 0x003f3d0f, 0x003f5d0f, 0x003f7d0f,
-    0x003f9d0f, 0x003fbd0f, 0x003fdd0f, 0x003ffd0f,
-    0x00401d0f, 0x00403d0f, 0x00405d0f, 0x00407d0f,
-    0x00409d0f, 0x0040bd0f, 0x0040dd0f, 0x0040fd0f,
-    0x00411d0f, 0x00413d0f, 0x00415d0f, 0x00417d0f,
-    0x00419d0f, 0x0041bd0f, 0x0041dd0f, 0x0041fd0f,
-    0x00421d0f, 0x00423d0f, 0x00425d0f, 0x00427d0f,
-    0x00429d0f, 0x0042bd0f, 0x0042dd0f, 0x0042fd0f,
-    0x00431d0f, 0x00433d0f, 0x00435d0f, 0x00437d0f,
-    0x00439d0f, 0x0043bd0f, 0x0043dd0f, 0x0043fd0f,
-    0x00441d0f, 0x00443d0f, 0x00445d0f, 0x00447d0f,
-    0x00449d0f, 0x0044bd0f, 0x0044dd0f, 0x0044fd0f,
-    0x00451d0f, 0x00453d0f, 0x00455d0f, 0x00457d0f,
-    0x00459d0f, 0x0045bd0f, 0x0045dd0f, 0x0045fd0f,
-    0x00461d0f, 0x00463d0f, 0x00465d0f, 0x00467d0f,
-    0x00469d0f, 0x0046bd0f, 0x0046dd0f, 0x0046fd0f,
-    0x00471d0f, 0x00473d0f, 0x00475d0f, 0x00477d0f,
-    0x00479d0f, 0x0047bd0f, 0x0047dd0f, 0x0047fd0f,
-    0x00481d0f, 0x00483d0f, 0x00485d0f, 0x00487d0f,
-    0x00489d0f, 0x0048bd0f, 0x0048dd0f, 0x0048fd0f,
-    0x00491d0f, 0x00493d0f, 0x00495d0f, 0x00497d0f,
-    0x00499d0f, 0x0049bd0f, 0x0049dd0f, 0x0049fd0f,
-    0x004a1d0f, 0x004a3d0f, 0x004a5d0f, 0x004a7d0f,
-    0x004a9d0f, 0x004abd0f, 0x004add0f, 0x004afd0f,
-    0x004b1d0f, 0x004b3d0f, 0x004b5d0f, 0x004b7d0f,
-    0x004b9d0f, 0x004bbd0f, 0x004bdd0f, 0x004bfd0f,
-    0x004c1d0f, 0x004c3d0f, 0x004c5d0f, 0x004c7d0f,
-    0x004c9d0f, 0x004cbd0f, 0x004cdd0f, 0x004cfd0f,
-    0x004d1d0f, 0x004d3d0f, 0x004d5d0f, 0x004d7d0f,
-    0x004d9d0f, 0x004dbd0f, 0x004ddd0f, 0x004dfd0f,
-    0x004e1d0f, 0x004e3d0f, 0x004e5d0f, 0x004e7d0f,
-    0x004e9d0f, 0x004ebd0f, 0x004edd0f, 0x004efd0f,
-    0x004f1d0f, 0x004f3d0f, 0x004f5d0f, 0x004f7d0f,
-    0x004f9d0f, 0x004fbd0f, 0x004fdd0f, 0x004ffd0f,
-    0x00501d0f, 0x00503d0f, 0x00505d0f, 0x00507d0f,
-    0x00509d0f, 0x0050bd0f, 0x0050dd0f, 0x0050fd0f,
-    0x00511d0f, 0x00513d0f, 0x00515d0f, 0x00517d0f,
-    0x00519d0f, 0x0051bd0f, 0x0051dd0f, 0x0051fd0f,
-    0x00521d0f, 0x00523d0f, 0x00525d0f, 0x00527d0f,
-    0x00529d0f, 0x0052bd0f, 0x0052dd0f, 0x0052fd0f,
-    0x00531d0f, 0x00533d0f, 0x00535d0f, 0x00537d0f,
-    0x00539d0f, 0x0053bd0f, 0x0053dd0f, 0x0053fd0f,
-    0x00541d0f, 0x00543d0f, 0x00545d0f, 0x00547d0f,
-    0x00549d0f, 0x0054bd0f, 0x0054dd0f, 0x0054fd0f,
-    0x00551d0f, 0x00553d0f, 0x00555d0f, 0x00557d0f,
-    0x00559d0f, 0x0055bd0f, 0x0055dd0f, 0x0055fd0f,
-    0x00561d0f, 0x00563d0f, 0x00565d0f, 0x00567d0f,
-    0x00569d0f, 0x0056bd0f, 0x0056dd0f, 0x0056fd0f,
-    0x00571d0f, 0x00573d0f, 0x00575d0f, 0x00577d0f,
-    0x00579d0f, 0x0057bd0f, 0x0057dd0f, 0x0057fd0f,
-    0x00581d0f, 0x00583d0f, 0x00585d0f, 0x00587d0f,
-    0x00589d0f, 0x0058bd0f, 0x0058dd0f, 0x0058fd0f,
-    0x00591d0f, 0x00593d0f, 0x00595d0f, 0x00597d0f,
-    0x00599d0f, 0x0059bd0f, 0x0059dd0f, 0x0059fd0f,
-    0x005a1d0f, 0x005a3d0f, 0x005a5d0f, 0x005a7d0f,
-    0x005a9d0f, 0x005abd0f, 0x005add0f, 0x005afd0f,
-    0x005b1d0f, 0x005b3d0f, 0x005b5d0f, 0x005b7d0f,
-    0x005b9d0f, 0x005bbd0f, 0x005bdd0f, 0x005bfd0f,
-    0x005c1d0f, 0x005c3d0f, 0x005c5d0f, 0x005c7d0f,
-    0x005c9d0f, 0x005cbd0f, 0x005cdd0f, 0x005cfd0f,
-    0x005d1d0f, 0x005d3d0f, 0x005d5d0f, 0x005d7d0f,
-    0x005d9d0f, 0x005dbd0f, 0x005ddd0f, 0x005dfd0f,
-    0x005e1d0f, 0x005e3d0f, 0x005e5d0f, 0x005e7d0f,
-    0x005e9d0f, 0x005ebd0f, 0x005edd0f, 0x005efd0f,
-    0x005f1d0f, 0x005f3d0f, 0x005f5d0f, 0x005f7d0f,
-    0x005f9d0f, 0x005fbd0f, 0x005fdd0f, 0x005ffd0f,
-    0x00601d0f, 0x00603d0f, 0x00605d0f, 0x00607d0f,
-    0x00609d0f, 0x0060bd0f, 0x0060dd0f, 0x0060fd0f,
-    0x00611d0f, 0x00613d0f, 0x00615d0f, 0x00617d0f,
-    0x00619d0f, 0x0061bd0f, 0x0061dd0f, 0x0061fd0f,
-    0x00621d0f, 0x00623d0f, 0x00625d0f, 0x00627d0f,
-    0x00629d0f, 0x0062bd0f, 0x0062dd0f, 0x0062fd0f,
-    0x00631d0f, 0x00633d0f, 0x00635d0f, 0x00637d0f,
-    0x00639d0f, 0x0063bd0f, 0x0063dd0f, 0x0063fd0f,
-    0x00641d0f, 0x00643d0f, 0x00645d0f, 0x00647d0f,
-    0x00649d0f, 0x0064bd0f, 0x0064dd0f, 0x0064fd0f,
-    0x00651d0f, 0x00653d0f, 0x00655d0f, 0x00657d0f,
-    0x00659d0f, 0x0065bd0f, 0x0065dd0f, 0x0065fd0f,
-    0x00661d0f, 0x00663d0f, 0x00665d0f, 0x00667d0f,
-    0x00669d0f, 0x0066bd0f, 0x0066dd0f, 0x0066fd0f,
-    0x00671d0f, 0x00673d0f, 0x00675d0f, 0x00677d0f,
-    0x00679d0f, 0x0067bd0f, 0x0067dd0f, 0x0067fd0f,
-    0x00681d0f, 0x00683d0f, 0x00685d0f, 0x00687d0f,
-    0x00689d0f, 0x0068bd0f, 0x0068dd0f, 0x0068fd0f,
-    0x00691d0f, 0x00693d0f, 0x00695d0f, 0x00697d0f,
-    0x00699d0f, 0x0069bd0f, 0x0069dd0f, 0x0069fd0f,
-    0x006a1d0f, 0x006a3d0f, 0x006a5d0f, 0x006a7d0f,
-    0x006a9d0f, 0x006abd0f, 0x006add0f, 0x006afd0f,
-    0x006b1d0f, 0x006b3d0f, 0x006b5d0f, 0x006b7d0f,
-    0x006b9d0f, 0x006bbd0f, 0x006bdd0f, 0x006bfd0f,
-    0x006c1d0f, 0x006c3d0f, 0x006c5d0f, 0x006c7d0f,
-    0x006c9d0f, 0x006cbd0f, 0x006cdd0f, 0x006cfd0f,
-    0x006d1d0f, 0x006d3d0f, 0x006d5d0f, 0x006d7d0f,
-    0x006d9d0f, 0x006dbd0f, 0x006ddd0f, 0x006dfd0f,
-    0x006e1d0f, 0x006e3d0f, 0x006e5d0f, 0x006e7d0f,
-    0x006e9d0f, 0x006ebd0f, 0x006edd0f, 0x006efd0f,
-    0x006f1d0f, 0x006f3d0f, 0x006f5d0f, 0x006f7d0f,
-    0x006f9d0f, 0x006fbd0f, 0x006fdd0f, 0x006ffd0f,
-    0x00701d0f, 0x00703d0f, 0x00705d0f, 0x00707d0f,
-    0x00709d0f, 0x0070bd0f, 0x0070dd0f, 0x0070fd0f,
-    0x00711d0f, 0x00713d0f, 0x00715d0f, 0x00717d0f,
-    0x00719d0f, 0x0071bd0f, 0x0071dd0f, 0x0071fd0f,
-    0x00721d0f, 0x00723d0f, 0x00725d0f, 0x00727d0f,
-    0x00729d0f, 0x0072bd0f, 0x0072dd0f, 0x0072fd0f,
-    0x00731d0f, 0x00733d0f, 0x00735d0f, 0x00737d0f,
-    0x00739d0f, 0x0073bd0f, 0x0073dd0f, 0x0073fd0f,
-    0x00741d0f, 0x00743d0f, 0x00745d0f, 0x00747d0f,
-    0x00749d0f, 0x0074bd0f, 0x0074dd0f, 0x0074fd0f,
-    0x00751d0f, 0x00753d0f, 0x00755d0f, 0x00757d0f,
-    0x00759d0f, 0x0075bd0f, 0x0075dd0f, 0x0075fd0f,
-    0x00761d0f, 0x00763d0f, 0x00765d0f, 0x00767d0f,
-    0x00769d0f, 0x0076bd0f, 0x0076dd0f, 0x0076fd0f,
-    0x00771d0f, 0x00773d0f, 0x00775d0f, 0x00777d0f,
-    0x00779d0f, 0x0077bd0f, 0x0077dd0f, 0x0077fd0f,
-    0x00781d0f, 0x00783d0f, 0x00785d0f, 0x00787d0f,
-    0x00789d0f, 0x0078bd0f, 0x0078dd0f, 0x0078fd0f,
-    0x00791d0f, 0x00793d0f, 0x00795d0f, 0x00797d0f,
-    0x00799d0f, 0x0079bd0f, 0x0079dd0f, 0x0079fd0f,
-    0x007a1d0f, 0x007a3d0f, 0x007a5d0f, 0x007a7d0f,
-    0x007a9d0f, 0x007abd0f, 0x007add0f, 0x007afd0f,
-    0x007b1d0f, 0x007b3d0f, 0x007b5d0f, 0x007b7d0f,
-    0x007b9d0f, 0x007bbd0f, 0x007bdd0f, 0x007bfd0f,
-    0x007c1d0f, 0x007c3d0f, 0x007c5d0f, 0x007c7d0f,
-    0x007c9d0f, 0x007cbd0f, 0x007cdd0f, 0x007cfd0f,
-    0x007d1d0f, 0x007d3d0f, 0x007d5d0f, 0x007d7d0f,
-    0x007d9d0f, 0x007dbd0f, 0x007ddd0f, 0x007dfd0f,
-    0x007e1d0f, 0x007e3d0f, 0x007e5d0f, 0x007e7d0f,
-    0x007e9d0f, 0x007ebd0f, 0x007edd0f, 0x007efd0f,
-    0x007f1d0f, 0x007f3d0f, 0x007f5d0f, 0x007f7d0f,
-    0x007f9d0f, 0x007fbd0f, 0x007fdd0f, 0x007ffd0f,
-    0x00000310, 0x00002310, 0x00004310, 0x00006310,
-    0x00008310, 0x0000a310, 0x0000c310, 0x0000e310,
-    0x00010310, 0x00012310, 0x00014310, 0x00016310,
-    0x00018310, 0x0001a310, 0x0001c310, 0x0001e310,
-    0x00020310, 0x00022310, 0x00024310, 0x00026310,
-    0x00028310, 0x0002a310, 0x0002c310, 0x0002e310,
-    0x00030310, 0x00032310, 0x00034310, 0x00036310,
-    0x00038310, 0x0003a310, 0x0003c310, 0x0003e310,
-    0x00040310, 0x00042310, 0x00044310, 0x00046310,
-    0x00048310, 0x0004a310, 0x0004c310, 0x0004e310,
-    0x00050310, 0x00052310, 0x00054310, 0x00056310,
-    0x00058310, 0x0005a310, 0x0005c310, 0x0005e310,
-    0x00060310, 0x00062310, 0x00064310, 0x00066310,
-    0x00068310, 0x0006a310, 0x0006c310, 0x0006e310,
-    0x00070310, 0x00072310, 0x00074310, 0x00076310,
-    0x00078310, 0x0007a310, 0x0007c310, 0x0007e310,
-    0x00080310, 0x00082310, 0x00084310, 0x00086310,
-    0x00088310, 0x0008a310, 0x0008c310, 0x0008e310,
-    0x00090310, 0x00092310, 0x00094310, 0x00096310,
-    0x00098310, 0x0009a310, 0x0009c310, 0x0009e310,
-    0x000a0310, 0x000a2310, 0x000a4310, 0x000a6310,
-    0x000a8310, 0x000aa310, 0x000ac310, 0x000ae310,
-    0x000b0310, 0x000b2310, 0x000b4310, 0x000b6310,
-    0x000b8310, 0x000ba310, 0x000bc310, 0x000be310,
-    0x000c0310, 0x000c2310, 0x000c4310, 0x000c6310,
-    0x000c8310, 0x000ca310, 0x000cc310, 0x000ce310,
-    0x000d0310, 0x000d2310, 0x000d4310, 0x000d6310,
-    0x000d8310, 0x000da310, 0x000dc310, 0x000de310,
-    0x000e0310, 0x000e2310, 0x000e4310, 0x000e6310,
-    0x000e8310, 0x000ea310, 0x000ec310, 0x000ee310,
-    0x000f0310, 0x000f2310, 0x000f4310, 0x000f6310,
-    0x000f8310, 0x000fa310, 0x000fc310, 0x000fe310,
-    0x00100310, 0x00102310, 0x00104310, 0x00106310,
-    0x00108310, 0x0010a310, 0x0010c310, 0x0010e310,
-    0x00110310, 0x00112310, 0x00114310, 0x00116310,
-    0x00118310, 0x0011a310, 0x0011c310, 0x0011e310,
-    0x00120310, 0x00122310, 0x00124310, 0x00126310,
-    0x00128310, 0x0012a310, 0x0012c310, 0x0012e310,
-    0x00130310, 0x00132310, 0x00134310, 0x00136310,
-    0x00138310, 0x0013a310, 0x0013c310, 0x0013e310,
-    0x00140310, 0x00142310, 0x00144310, 0x00146310,
-    0x00148310, 0x0014a310, 0x0014c310, 0x0014e310,
-    0x00150310, 0x00152310, 0x00154310, 0x00156310,
-    0x00158310, 0x0015a310, 0x0015c310, 0x0015e310,
-    0x00160310, 0x00162310, 0x00164310, 0x00166310,
-    0x00168310, 0x0016a310, 0x0016c310, 0x0016e310,
-    0x00170310, 0x00172310, 0x00174310, 0x00176310,
-    0x00178310, 0x0017a310, 0x0017c310, 0x0017e310,
-    0x00180310, 0x00182310, 0x00184310, 0x00186310,
-    0x00188310, 0x0018a310, 0x0018c310, 0x0018e310,
-    0x00190310, 0x00192310, 0x00194310, 0x00196310,
-    0x00198310, 0x0019a310, 0x0019c310, 0x0019e310,
-    0x001a0310, 0x001a2310, 0x001a4310, 0x001a6310,
-    0x001a8310, 0x001aa310, 0x001ac310, 0x001ae310,
-    0x001b0310, 0x001b2310, 0x001b4310, 0x001b6310,
-    0x001b8310, 0x001ba310, 0x001bc310, 0x001be310,
-    0x001c0310, 0x001c2310, 0x001c4310, 0x001c6310,
-    0x001c8310, 0x001ca310, 0x001cc310, 0x001ce310,
-    0x001d0310, 0x001d2310, 0x001d4310, 0x001d6310,
-    0x001d8310, 0x001da310, 0x001dc310, 0x001de310,
-    0x001e0310, 0x001e2310, 0x001e4310, 0x001e6310,
-    0x001e8310, 0x001ea310, 0x001ec310, 0x001ee310,
-    0x001f0310, 0x001f2310, 0x001f4310, 0x001f6310,
-    0x001f8310, 0x001fa310, 0x001fc310, 0x001fe310,
-    0x00200310, 0x00202310, 0x00204310, 0x00206310,
-    0x00208310, 0x0020a310, 0x0020c310, 0x0020e310,
-    0x00210310, 0x00212310, 0x00214310, 0x00216310,
-    0x00218310, 0x0021a310, 0x0021c310, 0x0021e310,
-    0x00220310, 0x00222310, 0x00224310, 0x00226310,
-    0x00228310, 0x0022a310, 0x0022c310, 0x0022e310,
-    0x00230310, 0x00232310, 0x00234310, 0x00236310,
-    0x00238310, 0x0023a310, 0x0023c310, 0x0023e310,
-    0x00240310, 0x00242310, 0x00244310, 0x00246310,
-    0x00248310, 0x0024a310, 0x0024c310, 0x0024e310,
-    0x00250310, 0x00252310, 0x00254310, 0x00256310,
-    0x00258310, 0x0025a310, 0x0025c310, 0x0025e310,
-    0x00260310, 0x00262310, 0x00264310, 0x00266310,
-    0x00268310, 0x0026a310, 0x0026c310, 0x0026e310,
-    0x00270310, 0x00272310, 0x00274310, 0x00276310,
-    0x00278310, 0x0027a310, 0x0027c310, 0x0027e310,
-    0x00280310, 0x00282310, 0x00284310, 0x00286310,
-    0x00288310, 0x0028a310, 0x0028c310, 0x0028e310,
-    0x00290310, 0x00292310, 0x00294310, 0x00296310,
-    0x00298310, 0x0029a310, 0x0029c310, 0x0029e310,
-    0x002a0310, 0x002a2310, 0x002a4310, 0x002a6310,
-    0x002a8310, 0x002aa310, 0x002ac310, 0x002ae310,
-    0x002b0310, 0x002b2310, 0x002b4310, 0x002b6310,
-    0x002b8310, 0x002ba310, 0x002bc310, 0x002be310,
-    0x002c0310, 0x002c2310, 0x002c4310, 0x002c6310,
-    0x002c8310, 0x002ca310, 0x002cc310, 0x002ce310,
-    0x002d0310, 0x002d2310, 0x002d4310, 0x002d6310,
-    0x002d8310, 0x002da310, 0x002dc310, 0x002de310,
-    0x002e0310, 0x002e2310, 0x002e4310, 0x002e6310,
-    0x002e8310, 0x002ea310, 0x002ec310, 0x002ee310,
-    0x002f0310, 0x002f2310, 0x002f4310, 0x002f6310,
-    0x002f8310, 0x002fa310, 0x002fc310, 0x002fe310,
-    0x00300310, 0x00302310, 0x00304310, 0x00306310,
-    0x00308310, 0x0030a310, 0x0030c310, 0x0030e310,
-    0x00310310, 0x00312310, 0x00314310, 0x00316310,
-    0x00318310, 0x0031a310, 0x0031c310, 0x0031e310,
-    0x00320310, 0x00322310, 0x00324310, 0x00326310,
-    0x00328310, 0x0032a310, 0x0032c310, 0x0032e310,
-    0x00330310, 0x00332310, 0x00334310, 0x00336310,
-    0x00338310, 0x0033a310, 0x0033c310, 0x0033e310,
-    0x00340310, 0x00342310, 0x00344310, 0x00346310,
-    0x00348310, 0x0034a310, 0x0034c310, 0x0034e310,
-    0x00350310, 0x00352310, 0x00354310, 0x00356310,
-    0x00358310, 0x0035a310, 0x0035c310, 0x0035e310,
-    0x00360310, 0x00362310, 0x00364310, 0x00366310,
-    0x00368310, 0x0036a310, 0x0036c310, 0x0036e310,
-    0x00370310, 0x00372310, 0x00374310, 0x00376310,
-    0x00378310, 0x0037a310, 0x0037c310, 0x0037e310,
-    0x00380310, 0x00382310, 0x00384310, 0x00386310,
-    0x00388310, 0x0038a310, 0x0038c310, 0x0038e310,
-    0x00390310, 0x00392310, 0x00394310, 0x00396310,
-    0x00398310, 0x0039a310, 0x0039c310, 0x0039e310,
-    0x003a0310, 0x003a2310, 0x003a4310, 0x003a6310,
-    0x003a8310, 0x003aa310, 0x003ac310, 0x003ae310,
-    0x003b0310, 0x003b2310, 0x003b4310, 0x003b6310,
-    0x003b8310, 0x003ba310, 0x003bc310, 0x003be310,
-    0x003c0310, 0x003c2310, 0x003c4310, 0x003c6310,
-    0x003c8310, 0x003ca310, 0x003cc310, 0x003ce310,
-    0x003d0310, 0x003d2310, 0x003d4310, 0x003d6310,
-    0x003d8310, 0x003da310, 0x003dc310, 0x003de310,
-    0x003e0310, 0x003e2310, 0x003e4310, 0x003e6310,
-    0x003e8310, 0x003ea310, 0x003ec310, 0x003ee310,
-    0x003f0310, 0x003f2310, 0x003f4310, 0x003f6310,
-    0x003f8310, 0x003fa310, 0x003fc310, 0x003fe310,
-    0x00400310, 0x00402310, 0x00404310, 0x00406310,
-    0x00408310, 0x0040a310, 0x0040c310, 0x0040e310,
-    0x00410310, 0x00412310, 0x00414310, 0x00416310,
-    0x00418310, 0x0041a310, 0x0041c310, 0x0041e310,
-    0x00420310, 0x00422310, 0x00424310, 0x00426310,
-    0x00428310, 0x0042a310, 0x0042c310, 0x0042e310,
-    0x00430310, 0x00432310, 0x00434310, 0x00436310,
-    0x00438310, 0x0043a310, 0x0043c310, 0x0043e310,
-    0x00440310, 0x00442310, 0x00444310, 0x00446310,
-    0x00448310, 0x0044a310, 0x0044c310, 0x0044e310,
-    0x00450310, 0x00452310, 0x00454310, 0x00456310,
-    0x00458310, 0x0045a310, 0x0045c310, 0x0045e310,
-    0x00460310, 0x00462310, 0x00464310, 0x00466310,
-    0x00468310, 0x0046a310, 0x0046c310, 0x0046e310,
-    0x00470310, 0x00472310, 0x00474310, 0x00476310,
-    0x00478310, 0x0047a310, 0x0047c310, 0x0047e310,
-    0x00480310, 0x00482310, 0x00484310, 0x00486310,
-    0x00488310, 0x0048a310, 0x0048c310, 0x0048e310,
-    0x00490310, 0x00492310, 0x00494310, 0x00496310,
-    0x00498310, 0x0049a310, 0x0049c310, 0x0049e310,
-    0x004a0310, 0x004a2310, 0x004a4310, 0x004a6310,
-    0x004a8310, 0x004aa310, 0x004ac310, 0x004ae310,
-    0x004b0310, 0x004b2310, 0x004b4310, 0x004b6310,
-    0x004b8310, 0x004ba310, 0x004bc310, 0x004be310,
-    0x004c0310, 0x004c2310, 0x004c4310, 0x004c6310,
-    0x004c8310, 0x004ca310, 0x004cc310, 0x004ce310,
-    0x004d0310, 0x004d2310, 0x004d4310, 0x004d6310,
-    0x004d8310, 0x004da310, 0x004dc310, 0x004de310,
-    0x004e0310, 0x004e2310, 0x004e4310, 0x004e6310,
-    0x004e8310, 0x004ea310, 0x004ec310, 0x004ee310,
-    0x004f0310, 0x004f2310, 0x004f4310, 0x004f6310,
-    0x004f8310, 0x004fa310, 0x004fc310, 0x004fe310,
-    0x00500310, 0x00502310, 0x00504310, 0x00506310,
-    0x00508310, 0x0050a310, 0x0050c310, 0x0050e310,
-    0x00510310, 0x00512310, 0x00514310, 0x00516310,
-    0x00518310, 0x0051a310, 0x0051c310, 0x0051e310,
-    0x00520310, 0x00522310, 0x00524310, 0x00526310,
-    0x00528310, 0x0052a310, 0x0052c310, 0x0052e310,
-    0x00530310, 0x00532310, 0x00534310, 0x00536310,
-    0x00538310, 0x0053a310, 0x0053c310, 0x0053e310,
-    0x00540310, 0x00542310, 0x00544310, 0x00546310,
-    0x00548310, 0x0054a310, 0x0054c310, 0x0054e310,
-    0x00550310, 0x00552310, 0x00554310, 0x00556310,
-    0x00558310, 0x0055a310, 0x0055c310, 0x0055e310,
-    0x00560310, 0x00562310, 0x00564310, 0x00566310,
-    0x00568310, 0x0056a310, 0x0056c310, 0x0056e310,
-    0x00570310, 0x00572310, 0x00574310, 0x00576310,
-    0x00578310, 0x0057a310, 0x0057c310, 0x0057e310,
-    0x00580310, 0x00582310, 0x00584310, 0x00586310,
-    0x00588310, 0x0058a310, 0x0058c310, 0x0058e310,
-    0x00590310, 0x00592310, 0x00594310, 0x00596310,
-    0x00598310, 0x0059a310, 0x0059c310, 0x0059e310,
-    0x005a0310, 0x005a2310, 0x005a4310, 0x005a6310,
-    0x005a8310, 0x005aa310, 0x005ac310, 0x005ae310,
-    0x005b0310, 0x005b2310, 0x005b4310, 0x005b6310,
-    0x005b8310, 0x005ba310, 0x005bc310, 0x005be310,
-    0x005c0310, 0x005c2310, 0x005c4310, 0x005c6310,
-    0x005c8310, 0x005ca310, 0x005cc310, 0x005ce310,
-    0x005d0310, 0x005d2310, 0x005d4310, 0x005d6310,
-    0x005d8310, 0x005da310, 0x005dc310, 0x005de310,
-    0x005e0310, 0x005e2310, 0x005e4310, 0x005e6310,
-    0x005e8310, 0x005ea310, 0x005ec310, 0x005ee310,
-    0x005f0310, 0x005f2310, 0x005f4310, 0x005f6310,
-    0x005f8310, 0x005fa310, 0x005fc310, 0x005fe310,
-    0x00600310, 0x00602310, 0x00604310, 0x00606310,
-    0x00608310, 0x0060a310, 0x0060c310, 0x0060e310,
-    0x00610310, 0x00612310, 0x00614310, 0x00616310,
-    0x00618310, 0x0061a310, 0x0061c310, 0x0061e310,
-    0x00620310, 0x00622310, 0x00624310, 0x00626310,
-    0x00628310, 0x0062a310, 0x0062c310, 0x0062e310,
-    0x00630310, 0x00632310, 0x00634310, 0x00636310,
-    0x00638310, 0x0063a310, 0x0063c310, 0x0063e310,
-    0x00640310, 0x00642310, 0x00644310, 0x00646310,
-    0x00648310, 0x0064a310, 0x0064c310, 0x0064e310,
-    0x00650310, 0x00652310, 0x00654310, 0x00656310,
-    0x00658310, 0x0065a310, 0x0065c310, 0x0065e310,
-    0x00660310, 0x00662310, 0x00664310, 0x00666310,
-    0x00668310, 0x0066a310, 0x0066c310, 0x0066e310,
-    0x00670310, 0x00672310, 0x00674310, 0x00676310,
-    0x00678310, 0x0067a310, 0x0067c310, 0x0067e310,
-    0x00680310, 0x00682310, 0x00684310, 0x00686310,
-    0x00688310, 0x0068a310, 0x0068c310, 0x0068e310,
-    0x00690310, 0x00692310, 0x00694310, 0x00696310,
-    0x00698310, 0x0069a310, 0x0069c310, 0x0069e310,
-    0x006a0310, 0x006a2310, 0x006a4310, 0x006a6310,
-    0x006a8310, 0x006aa310, 0x006ac310, 0x006ae310,
-    0x006b0310, 0x006b2310, 0x006b4310, 0x006b6310,
-    0x006b8310, 0x006ba310, 0x006bc310, 0x006be310,
-    0x006c0310, 0x006c2310, 0x006c4310, 0x006c6310,
-    0x006c8310, 0x006ca310, 0x006cc310, 0x006ce310,
-    0x006d0310, 0x006d2310, 0x006d4310, 0x006d6310,
-    0x006d8310, 0x006da310, 0x006dc310, 0x006de310,
-    0x006e0310, 0x006e2310, 0x006e4310, 0x006e6310,
-    0x006e8310, 0x006ea310, 0x006ec310, 0x006ee310,
-    0x006f0310, 0x006f2310, 0x006f4310, 0x006f6310,
-    0x006f8310, 0x006fa310, 0x006fc310, 0x006fe310,
-    0x00700310, 0x00702310, 0x00704310, 0x00706310,
-    0x00708310, 0x0070a310, 0x0070c310, 0x0070e310,
-    0x00710310, 0x00712310, 0x00714310, 0x00716310,
-    0x00718310, 0x0071a310, 0x0071c310, 0x0071e310,
-    0x00720310, 0x00722310, 0x00724310, 0x00726310,
-    0x00728310, 0x0072a310, 0x0072c310, 0x0072e310,
-    0x00730310, 0x00732310, 0x00734310, 0x00736310,
-    0x00738310, 0x0073a310, 0x0073c310, 0x0073e310,
-    0x00740310, 0x00742310, 0x00744310, 0x00746310,
-    0x00748310, 0x0074a310, 0x0074c310, 0x0074e310,
-    0x00750310, 0x00752310, 0x00754310, 0x00756310,
-    0x00758310, 0x0075a310, 0x0075c310, 0x0075e310,
-    0x00760310, 0x00762310, 0x00764310, 0x00766310,
-    0x00768310, 0x0076a310, 0x0076c310, 0x0076e310,
-    0x00770310, 0x00772310, 0x00774310, 0x00776310,
-    0x00778310, 0x0077a310, 0x0077c310, 0x0077e310,
-    0x00780310, 0x00782310, 0x00784310, 0x00786310,
-    0x00788310, 0x0078a310, 0x0078c310, 0x0078e310,
-    0x00790310, 0x00792310, 0x00794310, 0x00796310,
-    0x00798310, 0x0079a310, 0x0079c310, 0x0079e310,
-    0x007a0310, 0x007a2310, 0x007a4310, 0x007a6310,
-    0x007a8310, 0x007aa310, 0x007ac310, 0x007ae310,
-    0x007b0310, 0x007b2310, 0x007b4310, 0x007b6310,
-    0x007b8310, 0x007ba310, 0x007bc310, 0x007be310,
-    0x007c0310, 0x007c2310, 0x007c4310, 0x007c6310,
-    0x007c8310, 0x007ca310, 0x007cc310, 0x007ce310,
-    0x007d0310, 0x007d2310, 0x007d4310, 0x007d6310,
-    0x007d8310, 0x007da310, 0x007dc310, 0x007de310,
-    0x007e0310, 0x007e2310, 0x007e4310, 0x007e6310,
-    0x007e8310, 0x007ea310, 0x007ec310, 0x007ee310,
-    0x007f0310, 0x007f2310, 0x007f4310, 0x007f6310,
-    0x007f8310, 0x007fa310, 0x007fc310, 0x007fe310,
-    0x00800310, 0x00802310, 0x00804310, 0x00806310,
-    0x00808310, 0x0080a310, 0x0080c310, 0x0080e310,
-    0x00810310, 0x00812310, 0x00814310, 0x00816310,
-    0x00818310, 0x0081a310, 0x0081c310, 0x0081e310,
-    0x00820310, 0x00822310, 0x00824310, 0x00826310,
-    0x00828310, 0x0082a310, 0x0082c310, 0x0082e310,
-    0x00830310, 0x00832310, 0x00834310, 0x00836310,
-    0x00838310, 0x0083a310, 0x0083c310, 0x0083e310,
-    0x00840310, 0x00842310, 0x00844310, 0x00846310,
-    0x00848310, 0x0084a310, 0x0084c310, 0x0084e310,
-    0x00850310, 0x00852310, 0x00854310, 0x00856310,
-    0x00858310, 0x0085a310, 0x0085c310, 0x0085e310,
-    0x00860310, 0x00862310, 0x00864310, 0x00866310,
-    0x00868310, 0x0086a310, 0x0086c310, 0x0086e310,
-    0x00870310, 0x00872310, 0x00874310, 0x00876310,
-    0x00878310, 0x0087a310, 0x0087c310, 0x0087e310,
-    0x00880310, 0x00882310, 0x00884310, 0x00886310,
-    0x00888310, 0x0088a310, 0x0088c310, 0x0088e310,
-    0x00890310, 0x00892310, 0x00894310, 0x00896310,
-    0x00898310, 0x0089a310, 0x0089c310, 0x0089e310,
-    0x008a0310, 0x008a2310, 0x008a4310, 0x008a6310,
-    0x008a8310, 0x008aa310, 0x008ac310, 0x008ae310,
-    0x008b0310, 0x008b2310, 0x008b4310, 0x008b6310,
-    0x008b8310, 0x008ba310, 0x008bc310, 0x008be310,
-    0x008c0310, 0x008c2310, 0x008c4310, 0x008c6310,
-    0x008c8310, 0x008ca310, 0x008cc310, 0x008ce310,
-    0x008d0310, 0x008d2310, 0x008d4310, 0x008d6310,
-    0x008d8310, 0x008da310, 0x008dc310, 0x008de310,
-    0x008e0310, 0x008e2310, 0x008e4310, 0x008e6310,
-    0x008e8310, 0x008ea310, 0x008ec310, 0x008ee310,
-    0x008f0310, 0x008f2310, 0x008f4310, 0x008f6310,
-    0x008f8310, 0x008fa310, 0x008fc310, 0x008fe310,
-    0x00900310, 0x00902310, 0x00904310, 0x00906310,
-    0x00908310, 0x0090a310, 0x0090c310, 0x0090e310,
-    0x00910310, 0x00912310, 0x00914310, 0x00916310,
-    0x00918310, 0x0091a310, 0x0091c310, 0x0091e310,
-    0x00920310, 0x00922310, 0x00924310, 0x00926310,
-    0x00928310, 0x0092a310, 0x0092c310, 0x0092e310,
-    0x00930310, 0x00932310, 0x00934310, 0x00936310,
-    0x00938310, 0x0093a310, 0x0093c310, 0x0093e310,
-    0x00940310, 0x00942310, 0x00944310, 0x00946310,
-    0x00948310, 0x0094a310, 0x0094c310, 0x0094e310,
-    0x00950310, 0x00952310, 0x00954310, 0x00956310,
-    0x00958310, 0x0095a310, 0x0095c310, 0x0095e310,
-    0x00960310, 0x00962310, 0x00964310, 0x00966310,
-    0x00968310, 0x0096a310, 0x0096c310, 0x0096e310,
-    0x00970310, 0x00972310, 0x00974310, 0x00976310,
-    0x00978310, 0x0097a310, 0x0097c310, 0x0097e310,
-    0x00980310, 0x00982310, 0x00984310, 0x00986310,
-    0x00988310, 0x0098a310, 0x0098c310, 0x0098e310,
-    0x00990310, 0x00992310, 0x00994310, 0x00996310,
-    0x00998310, 0x0099a310, 0x0099c310, 0x0099e310,
-    0x009a0310, 0x009a2310, 0x009a4310, 0x009a6310,
-    0x009a8310, 0x009aa310, 0x009ac310, 0x009ae310,
-    0x009b0310, 0x009b2310, 0x009b4310, 0x009b6310,
-    0x009b8310, 0x009ba310, 0x009bc310, 0x009be310,
-    0x009c0310, 0x009c2310, 0x009c4310, 0x009c6310,
-    0x009c8310, 0x009ca310, 0x009cc310, 0x009ce310,
-    0x009d0310, 0x009d2310, 0x009d4310, 0x009d6310,
-    0x009d8310, 0x009da310, 0x009dc310, 0x009de310,
-    0x009e0310, 0x009e2310, 0x009e4310, 0x009e6310,
-    0x009e8310, 0x009ea310, 0x009ec310, 0x009ee310,
-    0x009f0310, 0x009f2310, 0x009f4310, 0x009f6310,
-    0x009f8310, 0x009fa310, 0x009fc310, 0x009fe310,
-    0x00a00310, 0x00a02310, 0x00a04310, 0x00a06310,
-    0x00a08310, 0x00a0a310, 0x00a0c310, 0x00a0e310,
-    0x00a10310, 0x00a12310, 0x00a14310, 0x00a16310,
-    0x00a18310, 0x00a1a310, 0x00a1c310, 0x00a1e310,
-    0x00a20310, 0x00a22310, 0x00a24310, 0x00a26310,
-    0x00a28310, 0x00a2a310, 0x00a2c310, 0x00a2e310,
-    0x00a30310, 0x00a32310, 0x00a34310, 0x00a36310,
-    0x00a38310, 0x00a3a310, 0x00a3c310, 0x00a3e310,
-    0x00a40310, 0x00a42310, 0x00a44310, 0x00a46310,
-    0x00a48310, 0x00a4a310, 0x00a4c310, 0x00a4e310,
-    0x00a50310, 0x00a52310, 0x00a54310, 0x00a56310,
-    0x00a58310, 0x00a5a310, 0x00a5c310, 0x00a5e310,
-    0x00a60310, 0x00a62310, 0x00a64310, 0x00a66310,
-    0x00a68310, 0x00a6a310, 0x00a6c310, 0x00a6e310,
-    0x00a70310, 0x00a72310, 0x00a74310, 0x00a76310,
-    0x00a78310, 0x00a7a310, 0x00a7c310, 0x00a7e310,
-    0x00a80310, 0x00a82310, 0x00a84310, 0x00a86310,
-    0x00a88310, 0x00a8a310, 0x00a8c310, 0x00a8e310,
-    0x00a90310, 0x00a92310, 0x00a94310, 0x00a96310,
-    0x00a98310, 0x00a9a310, 0x00a9c310, 0x00a9e310,
-    0x00aa0310, 0x00aa2310, 0x00aa4310, 0x00aa6310,
-    0x00aa8310, 0x00aaa310, 0x00aac310, 0x00aae310,
-    0x00ab0310, 0x00ab2310, 0x00ab4310, 0x00ab6310,
-    0x00ab8310, 0x00aba310, 0x00abc310, 0x00abe310,
-    0x00ac0310, 0x00ac2310, 0x00ac4310, 0x00ac6310,
-    0x00ac8310, 0x00aca310, 0x00acc310, 0x00ace310,
-    0x00ad0310, 0x00ad2310, 0x00ad4310, 0x00ad6310,
-    0x00ad8310, 0x00ada310, 0x00adc310, 0x00ade310,
-    0x00ae0310, 0x00ae2310, 0x00ae4310, 0x00ae6310,
-    0x00ae8310, 0x00aea310, 0x00aec310, 0x00aee310,
-    0x00af0310, 0x00af2310, 0x00af4310, 0x00af6310,
-    0x00af8310, 0x00afa310, 0x00afc310, 0x00afe310,
-    0x00b00310, 0x00b02310, 0x00b04310, 0x00b06310,
-    0x00b08310, 0x00b0a310, 0x00b0c310, 0x00b0e310,
-    0x00b10310, 0x00b12310, 0x00b14310, 0x00b16310,
-    0x00b18310, 0x00b1a310, 0x00b1c310, 0x00b1e310,
-    0x00b20310, 0x00b22310, 0x00b24310, 0x00b26310,
-    0x00b28310, 0x00b2a310, 0x00b2c310, 0x00b2e310,
-    0x00b30310, 0x00b32310, 0x00b34310, 0x00b36310,
-    0x00b38310, 0x00b3a310, 0x00b3c310, 0x00b3e310,
-    0x00b40310, 0x00b42310, 0x00b44310, 0x00b46310,
-    0x00b48310, 0x00b4a310, 0x00b4c310, 0x00b4e310,
-    0x00b50310, 0x00b52310, 0x00b54310, 0x00b56310,
-    0x00b58310, 0x00b5a310, 0x00b5c310, 0x00b5e310,
-    0x00b60310, 0x00b62310, 0x00b64310, 0x00b66310,
-    0x00b68310, 0x00b6a310, 0x00b6c310, 0x00b6e310,
-    0x00b70310, 0x00b72310, 0x00b74310, 0x00b76310,
-    0x00b78310, 0x00b7a310, 0x00b7c310, 0x00b7e310,
-    0x00b80310, 0x00b82310, 0x00b84310, 0x00b86310,
-    0x00b88310, 0x00b8a310, 0x00b8c310, 0x00b8e310,
-    0x00b90310, 0x00b92310, 0x00b94310, 0x00b96310,
-    0x00b98310, 0x00b9a310, 0x00b9c310, 0x00b9e310,
-    0x00ba0310, 0x00ba2310, 0x00ba4310, 0x00ba6310,
-    0x00ba8310, 0x00baa310, 0x00bac310, 0x00bae310,
-    0x00bb0310, 0x00bb2310, 0x00bb4310, 0x00bb6310,
-    0x00bb8310, 0x00bba310, 0x00bbc310, 0x00bbe310,
-    0x00bc0310, 0x00bc2310, 0x00bc4310, 0x00bc6310,
-    0x00bc8310, 0x00bca310, 0x00bcc310, 0x00bce310,
-    0x00bd0310, 0x00bd2310, 0x00bd4310, 0x00bd6310,
-    0x00bd8310, 0x00bda310, 0x00bdc310, 0x00bde310,
-    0x00be0310, 0x00be2310, 0x00be4310, 0x00be6310,
-    0x00be8310, 0x00bea310, 0x00bec310, 0x00bee310,
-    0x00bf0310, 0x00bf2310, 0x00bf4310, 0x00bf6310,
-    0x00bf8310, 0x00bfa310, 0x00bfc310, 0x00bfe310,
-    0x00c00310, 0x00c02310, 0x00c04310, 0x00c06310,
-    0x00c08310, 0x00c0a310, 0x00c0c310, 0x00c0e310,
-    0x00c10310, 0x00c12310, 0x00c14310, 0x00c16310,
-    0x00c18310, 0x00c1a310, 0x00c1c310, 0x00c1e310,
-    0x00c20310, 0x00c22310, 0x00c24310, 0x00c26310,
-    0x00c28310, 0x00c2a310, 0x00c2c310, 0x00c2e310,
-    0x00c30310, 0x00c32310, 0x00c34310, 0x00c36310,
-    0x00c38310, 0x00c3a310, 0x00c3c310, 0x00c3e310,
-    0x00c40310, 0x00c42310, 0x00c44310, 0x00c46310,
-    0x00c48310, 0x00c4a310, 0x00c4c310, 0x00c4e310,
-    0x00c50310, 0x00c52310, 0x00c54310, 0x00c56310,
-    0x00c58310, 0x00c5a310, 0x00c5c310, 0x00c5e310,
-    0x00c60310, 0x00c62310, 0x00c64310, 0x00c66310,
-    0x00c68310, 0x00c6a310, 0x00c6c310, 0x00c6e310,
-    0x00c70310, 0x00c72310, 0x00c74310, 0x00c76310,
-    0x00c78310, 0x00c7a310, 0x00c7c310, 0x00c7e310,
-    0x00c80310, 0x00c82310, 0x00c84310, 0x00c86310,
-    0x00c88310, 0x00c8a310, 0x00c8c310, 0x00c8e310,
-    0x00c90310, 0x00c92310, 0x00c94310, 0x00c96310,
-    0x00c98310, 0x00c9a310, 0x00c9c310, 0x00c9e310,
-    0x00ca0310, 0x00ca2310, 0x00ca4310, 0x00ca6310,
-    0x00ca8310, 0x00caa310, 0x00cac310, 0x00cae310,
-    0x00cb0310, 0x00cb2310, 0x00cb4310, 0x00cb6310,
-    0x00cb8310, 0x00cba310, 0x00cbc310, 0x00cbe310,
-    0x00cc0310, 0x00cc2310, 0x00cc4310, 0x00cc6310,
-    0x00cc8310, 0x00cca310, 0x00ccc310, 0x00cce310,
-    0x00cd0310, 0x00cd2310, 0x00cd4310, 0x00cd6310,
-    0x00cd8310, 0x00cda310, 0x00cdc310, 0x00cde310,
-    0x00ce0310, 0x00ce2310, 0x00ce4310, 0x00ce6310,
-    0x00ce8310, 0x00cea310, 0x00cec310, 0x00cee310,
-    0x00cf0310, 0x00cf2310, 0x00cf4310, 0x00cf6310,
-    0x00cf8310, 0x00cfa310, 0x00cfc310, 0x00cfe310,
-    0x00d00310, 0x00d02310, 0x00d04310, 0x00d06310,
-    0x00d08310, 0x00d0a310, 0x00d0c310, 0x00d0e310,
-    0x00d10310, 0x00d12310, 0x00d14310, 0x00d16310,
-    0x00d18310, 0x00d1a310, 0x00d1c310, 0x00d1e310,
-    0x00d20310, 0x00d22310, 0x00d24310, 0x00d26310,
-    0x00d28310, 0x00d2a310, 0x00d2c310, 0x00d2e310,
-    0x00d30310, 0x00d32310, 0x00d34310, 0x00d36310,
-    0x00d38310, 0x00d3a310, 0x00d3c310, 0x00d3e310,
-    0x00d40310, 0x00d42310, 0x00d44310, 0x00d46310,
-    0x00d48310, 0x00d4a310, 0x00d4c310, 0x00d4e310,
-    0x00d50310, 0x00d52310, 0x00d54310, 0x00d56310,
-    0x00d58310, 0x00d5a310, 0x00d5c310, 0x00d5e310,
-    0x00d60310, 0x00d62310, 0x00d64310, 0x00d66310,
-    0x00d68310, 0x00d6a310, 0x00d6c310, 0x00d6e310,
-    0x00d70310, 0x00d72310, 0x00d74310, 0x00d76310,
-    0x00d78310, 0x00d7a310, 0x00d7c310, 0x00d7e310,
-    0x00d80310, 0x00d82310, 0x00d84310, 0x00d86310,
-    0x00d88310, 0x00d8a310, 0x00d8c310, 0x00d8e310,
-    0x00d90310, 0x00d92310, 0x00d94310, 0x00d96310,
-    0x00d98310, 0x00d9a310, 0x00d9c310, 0x00d9e310,
-    0x00da0310, 0x00da2310, 0x00da4310, 0x00da6310,
-    0x00da8310, 0x00daa310, 0x00dac310, 0x00dae310,
-    0x00db0310, 0x00db2310, 0x00db4310, 0x00db6310,
-    0x00db8310, 0x00dba310, 0x00dbc310, 0x00dbe310,
-    0x00dc0310, 0x00dc2310, 0x00dc4310, 0x00dc6310,
-    0x00dc8310, 0x00dca310, 0x00dcc310, 0x00dce310,
-    0x00dd0310, 0x00dd2310, 0x00dd4310, 0x00dd6310,
-    0x00dd8310, 0x00dda310, 0x00ddc310, 0x00dde310,
-    0x00de0310, 0x00de2310, 0x00de4310, 0x00de6310,
-    0x00de8310, 0x00dea310, 0x00dec310, 0x00dee310,
-    0x00df0310, 0x00df2310, 0x00df4310, 0x00df6310,
-    0x00df8310, 0x00dfa310, 0x00dfc310, 0x00dfe310,
-    0x00e00310, 0x00e02310, 0x00e04310, 0x00e06310,
-    0x00e08310, 0x00e0a310, 0x00e0c310, 0x00e0e310,
-    0x00e10310, 0x00e12310, 0x00e14310, 0x00e16310,
-    0x00e18310, 0x00e1a310, 0x00e1c310, 0x00e1e310,
-    0x00e20310, 0x00e22310, 0x00e24310, 0x00e26310,
-    0x00e28310, 0x00e2a310, 0x00e2c310, 0x00e2e310,
-    0x00e30310, 0x00e32310, 0x00e34310, 0x00e36310,
-    0x00e38310, 0x00e3a310, 0x00e3c310, 0x00e3e310,
-    0x00e40310, 0x00e42310, 0x00e44310, 0x00e46310,
-    0x00e48310, 0x00e4a310, 0x00e4c310, 0x00e4e310,
-    0x00e50310, 0x00e52310, 0x00e54310, 0x00e56310,
-    0x00e58310, 0x00e5a310, 0x00e5c310, 0x00e5e310,
-    0x00e60310, 0x00e62310, 0x00e64310, 0x00e66310,
-    0x00e68310, 0x00e6a310, 0x00e6c310, 0x00e6e310,
-    0x00e70310, 0x00e72310, 0x00e74310, 0x00e76310,
-    0x00e78310, 0x00e7a310, 0x00e7c310, 0x00e7e310,
-    0x00e80310, 0x00e82310, 0x00e84310, 0x00e86310,
-    0x00e88310, 0x00e8a310, 0x00e8c310, 0x00e8e310,
-    0x00e90310, 0x00e92310, 0x00e94310, 0x00e96310,
-    0x00e98310, 0x00e9a310, 0x00e9c310, 0x00e9e310,
-    0x00ea0310, 0x00ea2310, 0x00ea4310, 0x00ea6310,
-    0x00ea8310, 0x00eaa310, 0x00eac310, 0x00eae310,
-    0x00eb0310, 0x00eb2310, 0x00eb4310, 0x00eb6310,
-    0x00eb8310, 0x00eba310, 0x00ebc310, 0x00ebe310,
-    0x00ec0310, 0x00ec2310, 0x00ec4310, 0x00ec6310,
-    0x00ec8310, 0x00eca310, 0x00ecc310, 0x00ece310,
-    0x00ed0310, 0x00ed2310, 0x00ed4310, 0x00ed6310,
-    0x00ed8310, 0x00eda310, 0x00edc310, 0x00ede310,
-    0x00ee0310, 0x00ee2310, 0x00ee4310, 0x00ee6310,
-    0x00ee8310, 0x00eea310, 0x00eec310, 0x00eee310,
-    0x00ef0310, 0x00ef2310, 0x00ef4310, 0x00ef6310,
-    0x00ef8310, 0x00efa310, 0x00efc310, 0x00efe310,
-    0x00f00310, 0x00f02310, 0x00f04310, 0x00f06310,
-    0x00f08310, 0x00f0a310, 0x00f0c310, 0x00f0e310,
-    0x00f10310, 0x00f12310, 0x00f14310, 0x00f16310,
-    0x00f18310, 0x00f1a310, 0x00f1c310, 0x00f1e310,
-    0x00f20310, 0x00f22310, 0x00f24310, 0x00f26310,
-    0x00f28310, 0x00f2a310, 0x00f2c310, 0x00f2e310,
-    0x00f30310, 0x00f32310, 0x00f34310, 0x00f36310,
-    0x00f38310, 0x00f3a310, 0x00f3c310, 0x00f3e310,
-    0x00f40310, 0x00f42310, 0x00f44310, 0x00f46310,
-    0x00f48310, 0x00f4a310, 0x00f4c310, 0x00f4e310,
-    0x00f50310, 0x00f52310, 0x00f54310, 0x00f56310,
-    0x00f58310, 0x00f5a310, 0x00f5c310, 0x00f5e310,
-    0x00f60310, 0x00f62310, 0x00f64310, 0x00f66310,
-    0x00f68310, 0x00f6a310, 0x00f6c310, 0x00f6e310,
-    0x00f70310, 0x00f72310, 0x00f74310, 0x00f76310,
-    0x00f78310, 0x00f7a310, 0x00f7c310, 0x00f7e310,
-    0x00f80310, 0x00f82310, 0x00f84310, 0x00f86310,
-    0x00f88310, 0x00f8a310, 0x00f8c310, 0x00f8e310,
-    0x00f90310, 0x00f92310, 0x00f94310, 0x00f96310,
-    0x00f98310, 0x00f9a310, 0x00f9c310, 0x00f9e310,
-    0x00fa0310, 0x00fa2310, 0x00fa4310, 0x00fa6310,
-    0x00fa8310, 0x00faa310, 0x00fac310, 0x00fae310,
-    0x00fb0310, 0x00fb2310, 0x00fb4310, 0x00fb6310,
-    0x00fb8310, 0x00fba310, 0x00fbc310, 0x00fbe310,
-    0x00fc0310, 0x00fc2310, 0x00fc4310, 0x00fc6310,
-    0x00fc8310, 0x00fca310, 0x00fcc310, 0x00fce310,
-    0x00fd0310, 0x00fd2310, 0x00fd4310, 0x00fd6310,
-    0x00fd8310, 0x00fda310, 0x00fdc310, 0x00fde310,
-    0x00fe0310, 0x00fe2310, 0x00fe4310, 0x00fe6310,
-    0x00fe8310, 0x00fea310, 0x00fec310, 0x00fee310,
-    0x00ff0310, 0x00ff2310, 0x00ff4310, 0x00ff6310,
-    0x00ff8310, 0x00ffa310, 0x00ffc310, 0x00ffe310,
-    0x00001310, 0x00003310, 0x00005310, 0x00007310,
-    0x00009310, 0x0000b310, 0x0000d310, 0x0000f310,
-    0x00011310, 0x00013310, 0x00015310, 0x00017310,
-    0x00019310, 0x0001b310, 0x0001d310, 0x0001f310,
-    0x00021310, 0x00023310, 0x00025310, 0x00027310,
-    0x00029310, 0x0002b310, 0x0002d310, 0x0002f310,
-    0x00031310, 0x00033310, 0x00035310, 0x00037310,
-    0x00039310, 0x0003b310, 0x0003d310, 0x0003f310,
-    0x00041310, 0x00043310, 0x00045310, 0x00047310,
-    0x00049310, 0x0004b310, 0x0004d310, 0x0004f310,
-    0x00051310, 0x00053310, 0x00055310, 0x00057310,
-    0x00059310, 0x0005b310, 0x0005d310, 0x0005f310,
-    0x00061310, 0x00063310, 0x00065310, 0x00067310,
-    0x00069310, 0x0006b310, 0x0006d310, 0x0006f310,
-    0x00071310, 0x00073310, 0x00075310, 0x00077310,
-    0x00079310, 0x0007b310, 0x0007d310, 0x0007f310,
-    0x00081310, 0x00083310, 0x00085310, 0x00087310,
-    0x00089310, 0x0008b310, 0x0008d310, 0x0008f310,
-    0x00091310, 0x00093310, 0x00095310, 0x00097310,
-    0x00099310, 0x0009b310, 0x0009d310, 0x0009f310,
-    0x000a1310, 0x000a3310, 0x000a5310, 0x000a7310,
-    0x000a9310, 0x000ab310, 0x000ad310, 0x000af310,
-    0x000b1310, 0x000b3310, 0x000b5310, 0x000b7310,
-    0x000b9310, 0x000bb310, 0x000bd310, 0x000bf310,
-    0x000c1310, 0x000c3310, 0x000c5310, 0x000c7310,
-    0x000c9310, 0x000cb310, 0x000cd310, 0x000cf310,
-    0x000d1310, 0x000d3310, 0x000d5310, 0x000d7310,
-    0x000d9310, 0x000db310, 0x000dd310, 0x000df310,
-    0x000e1310, 0x000e3310, 0x000e5310, 0x000e7310,
-    0x000e9310, 0x000eb310, 0x000ed310, 0x000ef310,
-    0x000f1310, 0x000f3310, 0x000f5310, 0x000f7310,
-    0x000f9310, 0x000fb310, 0x000fd310, 0x000ff310,
-    0x00101310, 0x00103310, 0x00105310, 0x00107310,
-    0x00109310, 0x0010b310, 0x0010d310, 0x0010f310,
-    0x00111310, 0x00113310, 0x00115310, 0x00117310,
-    0x00119310, 0x0011b310, 0x0011d310, 0x0011f310,
-    0x00121310, 0x00123310, 0x00125310, 0x00127310,
-    0x00129310, 0x0012b310, 0x0012d310, 0x0012f310,
-    0x00131310, 0x00133310, 0x00135310, 0x00137310,
-    0x00139310, 0x0013b310, 0x0013d310, 0x0013f310,
-    0x00141310, 0x00143310, 0x00145310, 0x00147310,
-    0x00149310, 0x0014b310, 0x0014d310, 0x0014f310,
-    0x00151310, 0x00153310, 0x00155310, 0x00157310,
-    0x00159310, 0x0015b310, 0x0015d310, 0x0015f310,
-    0x00161310, 0x00163310, 0x00165310, 0x00167310,
-    0x00169310, 0x0016b310, 0x0016d310, 0x0016f310,
-    0x00171310, 0x00173310, 0x00175310, 0x00177310,
-    0x00179310, 0x0017b310, 0x0017d310, 0x0017f310,
-    0x00181310, 0x00183310, 0x00185310, 0x00187310,
-    0x00189310, 0x0018b310, 0x0018d310, 0x0018f310,
-    0x00191310, 0x00193310, 0x00195310, 0x00197310,
-    0x00199310, 0x0019b310, 0x0019d310, 0x0019f310,
-    0x001a1310, 0x001a3310, 0x001a5310, 0x001a7310,
-    0x001a9310, 0x001ab310, 0x001ad310, 0x001af310,
-    0x001b1310, 0x001b3310, 0x001b5310, 0x001b7310,
-    0x001b9310, 0x001bb310, 0x001bd310, 0x001bf310,
-    0x001c1310, 0x001c3310, 0x001c5310, 0x001c7310,
-    0x001c9310, 0x001cb310, 0x001cd310, 0x001cf310,
-    0x001d1310, 0x001d3310, 0x001d5310, 0x001d7310,
-    0x001d9310, 0x001db310, 0x001dd310, 0x001df310,
-    0x001e1310, 0x001e3310, 0x001e5310, 0x001e7310,
-    0x001e9310, 0x001eb310, 0x001ed310, 0x001ef310,
-    0x001f1310, 0x001f3310, 0x001f5310, 0x001f7310,
-    0x001f9310, 0x001fb310, 0x001fd310, 0x001ff310,
-    0x00201310, 0x00203310, 0x00205310, 0x00207310,
-    0x00209310, 0x0020b310, 0x0020d310, 0x0020f310,
-    0x00211310, 0x00213310, 0x00215310, 0x00217310,
-    0x00219310, 0x0021b310, 0x0021d310, 0x0021f310,
-    0x00221310, 0x00223310, 0x00225310, 0x00227310,
-    0x00229310, 0x0022b310, 0x0022d310, 0x0022f310,
-    0x00231310, 0x00233310, 0x00235310, 0x00237310,
-    0x00239310, 0x0023b310, 0x0023d310, 0x0023f310,
-    0x00241310, 0x00243310, 0x00245310, 0x00247310,
-    0x00249310, 0x0024b310, 0x0024d310, 0x0024f310,
-    0x00251310, 0x00253310, 0x00255310, 0x00257310,
-    0x00259310, 0x0025b310, 0x0025d310, 0x0025f310,
-    0x00261310, 0x00263310, 0x00265310, 0x00267310,
-    0x00269310, 0x0026b310, 0x0026d310, 0x0026f310,
-    0x00271310, 0x00273310, 0x00275310, 0x00277310,
-    0x00279310, 0x0027b310, 0x0027d310, 0x0027f310,
-    0x00281310, 0x00283310, 0x00285310, 0x00287310,
-    0x00289310, 0x0028b310, 0x0028d310, 0x0028f310,
-    0x00291310, 0x00293310, 0x00295310, 0x00297310,
-    0x00299310, 0x0029b310, 0x0029d310, 0x0029f310,
-    0x002a1310, 0x002a3310, 0x002a5310, 0x002a7310,
-    0x002a9310, 0x002ab310, 0x002ad310, 0x002af310,
-    0x002b1310, 0x002b3310, 0x002b5310, 0x002b7310,
-    0x002b9310, 0x002bb310, 0x002bd310, 0x002bf310,
-    0x002c1310, 0x002c3310, 0x002c5310, 0x002c7310,
-    0x002c9310, 0x002cb310, 0x002cd310, 0x002cf310,
-    0x002d1310, 0x002d3310, 0x002d5310, 0x002d7310,
-    0x002d9310, 0x002db310, 0x002dd310, 0x002df310,
-    0x002e1310, 0x002e3310, 0x002e5310, 0x002e7310,
-    0x002e9310, 0x002eb310, 0x002ed310, 0x002ef310,
-    0x002f1310, 0x002f3310, 0x002f5310, 0x002f7310,
-    0x002f9310, 0x002fb310, 0x002fd310, 0x002ff310,
-    0x00301310, 0x00303310, 0x00305310, 0x00307310,
-    0x00309310, 0x0030b310, 0x0030d310, 0x0030f310,
-    0x00311310, 0x00313310, 0x00315310, 0x00317310,
-    0x00319310, 0x0031b310, 0x0031d310, 0x0031f310,
-    0x00321310, 0x00323310, 0x00325310, 0x00327310,
-    0x00329310, 0x0032b310, 0x0032d310, 0x0032f310,
-    0x00331310, 0x00333310, 0x00335310, 0x00337310,
-    0x00339310, 0x0033b310, 0x0033d310, 0x0033f310,
-    0x00341310, 0x00343310, 0x00345310, 0x00347310,
-    0x00349310, 0x0034b310, 0x0034d310, 0x0034f310,
-    0x00351310, 0x00353310, 0x00355310, 0x00357310,
-    0x00359310, 0x0035b310, 0x0035d310, 0x0035f310,
-    0x00361310, 0x00363310, 0x00365310, 0x00367310,
-    0x00369310, 0x0036b310, 0x0036d310, 0x0036f310,
-    0x00371310, 0x00373310, 0x00375310, 0x00377310,
-    0x00379310, 0x0037b310, 0x0037d310, 0x0037f310,
-    0x00381310, 0x00383310, 0x00385310, 0x00387310,
-    0x00389310, 0x0038b310, 0x0038d310, 0x0038f310,
-    0x00391310, 0x00393310, 0x00395310, 0x00397310,
-    0x00399310, 0x0039b310, 0x0039d310, 0x0039f310,
-    0x003a1310, 0x003a3310, 0x003a5310, 0x003a7310,
-    0x003a9310, 0x003ab310, 0x003ad310, 0x003af310,
-    0x003b1310, 0x003b3310, 0x003b5310, 0x003b7310,
-    0x003b9310, 0x003bb310, 0x003bd310, 0x003bf310,
-    0x003c1310, 0x003c3310, 0x003c5310, 0x003c7310,
-    0x003c9310, 0x003cb310, 0x003cd310, 0x003cf310,
-    0x003d1310, 0x003d3310, 0x003d5310, 0x003d7310,
-    0x003d9310, 0x003db310, 0x003dd310, 0x003df310,
-    0x003e1310, 0x003e3310, 0x003e5310, 0x003e7310,
-    0x003e9310, 0x003eb310, 0x003ed310, 0x003ef310,
-    0x003f1310, 0x003f3310, 0x003f5310, 0x003f7310,
-    0x003f9310, 0x003fb310, 0x003fd310, 0x003ff310,
-    0x00401310, 0x00403310, 0x00405310, 0x00407310,
-    0x00409310, 0x0040b310, 0x0040d310, 0x0040f310,
-    0x00411310, 0x00413310, 0x00415310, 0x00417310,
-    0x00419310, 0x0041b310, 0x0041d310, 0x0041f310,
-    0x00421310, 0x00423310, 0x00425310, 0x00427310,
-    0x00429310, 0x0042b310, 0x0042d310, 0x0042f310,
-    0x00431310, 0x00433310, 0x00435310, 0x00437310,
-    0x00439310, 0x0043b310, 0x0043d310, 0x0043f310,
-    0x00441310, 0x00443310, 0x00445310, 0x00447310,
-    0x00449310, 0x0044b310, 0x0044d310, 0x0044f310,
-    0x00451310, 0x00453310, 0x00455310, 0x00457310,
-    0x00459310, 0x0045b310, 0x0045d310, 0x0045f310,
-    0x00461310, 0x00463310, 0x00465310, 0x00467310,
-    0x00469310, 0x0046b310, 0x0046d310, 0x0046f310,
-    0x00471310, 0x00473310, 0x00475310, 0x00477310,
-    0x00479310, 0x0047b310, 0x0047d310, 0x0047f310,
-    0x00481310, 0x00483310, 0x00485310, 0x00487310,
-    0x00489310, 0x0048b310, 0x0048d310, 0x0048f310,
-    0x00491310, 0x00493310, 0x00495310, 0x00497310,
-    0x00499310, 0x0049b310, 0x0049d310, 0x0049f310,
-    0x004a1310, 0x004a3310, 0x004a5310, 0x004a7310,
-    0x004a9310, 0x004ab310, 0x004ad310, 0x004af310,
-    0x004b1310, 0x004b3310, 0x004b5310, 0x004b7310,
-    0x004b9310, 0x004bb310, 0x004bd310, 0x004bf310,
-    0x004c1310, 0x004c3310, 0x004c5310, 0x004c7310,
-    0x004c9310, 0x004cb310, 0x004cd310, 0x004cf310,
-    0x004d1310, 0x004d3310, 0x004d5310, 0x004d7310,
-    0x004d9310, 0x004db310, 0x004dd310, 0x004df310,
-    0x004e1310, 0x004e3310, 0x004e5310, 0x004e7310,
-    0x004e9310, 0x004eb310, 0x004ed310, 0x004ef310,
-    0x004f1310, 0x004f3310, 0x004f5310, 0x004f7310,
-    0x004f9310, 0x004fb310, 0x004fd310, 0x004ff310,
-    0x00501310, 0x00503310, 0x00505310, 0x00507310,
-    0x00509310, 0x0050b310, 0x0050d310, 0x0050f310,
-    0x00511310, 0x00513310, 0x00515310, 0x00517310,
-    0x00519310, 0x0051b310, 0x0051d310, 0x0051f310,
-    0x00521310, 0x00523310, 0x00525310, 0x00527310,
-    0x00529310, 0x0052b310, 0x0052d310, 0x0052f310,
-    0x00531310, 0x00533310, 0x00535310, 0x00537310,
-    0x00539310, 0x0053b310, 0x0053d310, 0x0053f310,
-    0x00541310, 0x00543310, 0x00545310, 0x00547310,
-    0x00549310, 0x0054b310, 0x0054d310, 0x0054f310,
-    0x00551310, 0x00553310, 0x00555310, 0x00557310,
-    0x00559310, 0x0055b310, 0x0055d310, 0x0055f310,
-    0x00561310, 0x00563310, 0x00565310, 0x00567310,
-    0x00569310, 0x0056b310, 0x0056d310, 0x0056f310,
-    0x00571310, 0x00573310, 0x00575310, 0x00577310,
-    0x00579310, 0x0057b310, 0x0057d310, 0x0057f310,
-    0x00581310, 0x00583310, 0x00585310, 0x00587310,
-    0x00589310, 0x0058b310, 0x0058d310, 0x0058f310,
-    0x00591310, 0x00593310, 0x00595310, 0x00597310,
-    0x00599310, 0x0059b310, 0x0059d310, 0x0059f310,
-    0x005a1310, 0x005a3310, 0x005a5310, 0x005a7310,
-    0x005a9310, 0x005ab310, 0x005ad310, 0x005af310,
-    0x005b1310, 0x005b3310, 0x005b5310, 0x005b7310,
-    0x005b9310, 0x005bb310, 0x005bd310, 0x005bf310,
-    0x005c1310, 0x005c3310, 0x005c5310, 0x005c7310,
-    0x005c9310, 0x005cb310, 0x005cd310, 0x005cf310,
-    0x005d1310, 0x005d3310, 0x005d5310, 0x005d7310,
-    0x005d9310, 0x005db310, 0x005dd310, 0x005df310,
-    0x005e1310, 0x005e3310, 0x005e5310, 0x005e7310,
-    0x005e9310, 0x005eb310, 0x005ed310, 0x005ef310,
-    0x005f1310, 0x005f3310, 0x005f5310, 0x005f7310,
-    0x005f9310, 0x005fb310, 0x005fd310, 0x005ff310,
-    0x00601310, 0x00603310, 0x00605310, 0x00607310,
-    0x00609310, 0x0060b310, 0x0060d310, 0x0060f310,
-    0x00611310, 0x00613310, 0x00615310, 0x00617310,
-    0x00619310, 0x0061b310, 0x0061d310, 0x0061f310,
-    0x00621310, 0x00623310, 0x00625310, 0x00627310,
-    0x00629310, 0x0062b310, 0x0062d310, 0x0062f310,
-    0x00631310, 0x00633310, 0x00635310, 0x00637310,
-    0x00639310, 0x0063b310, 0x0063d310, 0x0063f310,
-    0x00641310, 0x00643310, 0x00645310, 0x00647310,
-    0x00649310, 0x0064b310, 0x0064d310, 0x0064f310,
-    0x00651310, 0x00653310, 0x00655310, 0x00657310,
-    0x00659310, 0x0065b310, 0x0065d310, 0x0065f310,
-    0x00661310, 0x00663310, 0x00665310, 0x00667310,
-    0x00669310, 0x0066b310, 0x0066d310, 0x0066f310,
-    0x00671310, 0x00673310, 0x00675310, 0x00677310,
-    0x00679310, 0x0067b310, 0x0067d310, 0x0067f310,
-    0x00681310, 0x00683310, 0x00685310, 0x00687310,
-    0x00689310, 0x0068b310, 0x0068d310, 0x0068f310,
-    0x00691310, 0x00693310, 0x00695310, 0x00697310,
-    0x00699310, 0x0069b310, 0x0069d310, 0x0069f310,
-    0x006a1310, 0x006a3310, 0x006a5310, 0x006a7310,
-    0x006a9310, 0x006ab310, 0x006ad310, 0x006af310,
-    0x006b1310, 0x006b3310, 0x006b5310, 0x006b7310,
-    0x006b9310, 0x006bb310, 0x006bd310, 0x006bf310,
-    0x006c1310, 0x006c3310, 0x006c5310, 0x006c7310,
-    0x006c9310, 0x006cb310, 0x006cd310, 0x006cf310,
-    0x006d1310, 0x006d3310, 0x006d5310, 0x006d7310,
-    0x006d9310, 0x006db310, 0x006dd310, 0x006df310,
-    0x006e1310, 0x006e3310, 0x006e5310, 0x006e7310,
-    0x006e9310, 0x006eb310, 0x006ed310, 0x006ef310,
-    0x006f1310, 0x006f3310, 0x006f5310, 0x006f7310,
-    0x006f9310, 0x006fb310, 0x006fd310, 0x006ff310,
-    0x00701310, 0x00703310, 0x00705310, 0x00707310,
-    0x00709310, 0x0070b310, 0x0070d310, 0x0070f310,
-    0x00711310, 0x00713310, 0x00715310, 0x00717310,
-    0x00719310, 0x0071b310, 0x0071d310, 0x0071f310,
-    0x00721310, 0x00723310, 0x00725310, 0x00727310,
-    0x00729310, 0x0072b310, 0x0072d310, 0x0072f310,
-    0x00731310, 0x00733310, 0x00735310, 0x00737310,
-    0x00739310, 0x0073b310, 0x0073d310, 0x0073f310,
-    0x00741310, 0x00743310, 0x00745310, 0x00747310,
-    0x00749310, 0x0074b310, 0x0074d310, 0x0074f310,
-    0x00751310, 0x00753310, 0x00755310, 0x00757310,
-    0x00759310, 0x0075b310, 0x0075d310, 0x0075f310,
-    0x00761310, 0x00763310, 0x00765310, 0x00767310,
-    0x00769310, 0x0076b310, 0x0076d310, 0x0076f310,
-    0x00771310, 0x00773310, 0x00775310, 0x00777310,
-    0x00779310, 0x0077b310, 0x0077d310, 0x0077f310,
-    0x00781310, 0x00783310, 0x00785310, 0x00787310,
-    0x00789310, 0x0078b310, 0x0078d310, 0x0078f310,
-    0x00791310, 0x00793310, 0x00795310, 0x00797310,
-    0x00799310, 0x0079b310, 0x0079d310, 0x0079f310,
-    0x007a1310, 0x007a3310, 0x007a5310, 0x007a7310,
-    0x007a9310, 0x007ab310, 0x007ad310, 0x007af310,
-    0x007b1310, 0x007b3310, 0x007b5310, 0x007b7310,
-    0x007b9310, 0x007bb310, 0x007bd310, 0x007bf310,
-    0x007c1310, 0x007c3310, 0x007c5310, 0x007c7310,
-    0x007c9310, 0x007cb310, 0x007cd310, 0x007cf310,
-    0x007d1310, 0x007d3310, 0x007d5310, 0x007d7310,
-    0x007d9310, 0x007db310, 0x007dd310, 0x007df310,
-    0x007e1310, 0x007e3310, 0x007e5310, 0x007e7310,
-    0x007e9310, 0x007eb310, 0x007ed310, 0x007ef310,
-    0x007f1310, 0x007f3310, 0x007f5310, 0x007f7310,
-    0x007f9310, 0x007fb310, 0x007fd310, 0x007ff310,
-    0x00801310, 0x00803310, 0x00805310, 0x00807310,
-    0x00809310, 0x0080b310, 0x0080d310, 0x0080f310,
-    0x00811310, 0x00813310, 0x00815310, 0x00817310,
-    0x00819310, 0x0081b310, 0x0081d310, 0x0081f310,
-    0x00821310, 0x00823310, 0x00825310, 0x00827310,
-    0x00829310, 0x0082b310, 0x0082d310, 0x0082f310,
-    0x00831310, 0x00833310, 0x00835310, 0x00837310,
-    0x00839310, 0x0083b310, 0x0083d310, 0x0083f310,
-    0x00841310, 0x00843310, 0x00845310, 0x00847310,
-    0x00849310, 0x0084b310, 0x0084d310, 0x0084f310,
-    0x00851310, 0x00853310, 0x00855310, 0x00857310,
-    0x00859310, 0x0085b310, 0x0085d310, 0x0085f310,
-    0x00861310, 0x00863310, 0x00865310, 0x00867310,
-    0x00869310, 0x0086b310, 0x0086d310, 0x0086f310,
-    0x00871310, 0x00873310, 0x00875310, 0x00877310,
-    0x00879310, 0x0087b310, 0x0087d310, 0x0087f310,
-    0x00881310, 0x00883310, 0x00885310, 0x00887310,
-    0x00889310, 0x0088b310, 0x0088d310, 0x0088f310,
-    0x00891310, 0x00893310, 0x00895310, 0x00897310,
-    0x00899310, 0x0089b310, 0x0089d310, 0x0089f310,
-    0x008a1310, 0x008a3310, 0x008a5310, 0x008a7310,
-    0x008a9310, 0x008ab310, 0x008ad310, 0x008af310,
-    0x008b1310, 0x008b3310, 0x008b5310, 0x008b7310,
-    0x008b9310, 0x008bb310, 0x008bd310, 0x008bf310,
-    0x008c1310, 0x008c3310, 0x008c5310, 0x008c7310,
-    0x008c9310, 0x008cb310, 0x008cd310, 0x008cf310,
-    0x008d1310, 0x008d3310, 0x008d5310, 0x008d7310,
-    0x008d9310, 0x008db310, 0x008dd310, 0x008df310,
-    0x008e1310, 0x008e3310, 0x008e5310, 0x008e7310,
-    0x008e9310, 0x008eb310, 0x008ed310, 0x008ef310,
-    0x008f1310, 0x008f3310, 0x008f5310, 0x008f7310,
-    0x008f9310, 0x008fb310, 0x008fd310, 0x008ff310,
-    0x00901310, 0x00903310, 0x00905310, 0x00907310,
-    0x00909310, 0x0090b310, 0x0090d310, 0x0090f310,
-    0x00911310, 0x00913310, 0x00915310, 0x00917310,
-    0x00919310, 0x0091b310, 0x0091d310, 0x0091f310,
-    0x00921310, 0x00923310, 0x00925310, 0x00927310,
-    0x00929310, 0x0092b310, 0x0092d310, 0x0092f310,
-    0x00931310, 0x00933310, 0x00935310, 0x00937310,
-    0x00939310, 0x0093b310, 0x0093d310, 0x0093f310,
-    0x00941310, 0x00943310, 0x00945310, 0x00947310,
-    0x00949310, 0x0094b310, 0x0094d310, 0x0094f310,
-    0x00951310, 0x00953310, 0x00955310, 0x00957310,
-    0x00959310, 0x0095b310, 0x0095d310, 0x0095f310,
-    0x00961310, 0x00963310, 0x00965310, 0x00967310,
-    0x00969310, 0x0096b310, 0x0096d310, 0x0096f310,
-    0x00971310, 0x00973310, 0x00975310, 0x00977310,
-    0x00979310, 0x0097b310, 0x0097d310, 0x0097f310,
-    0x00981310, 0x00983310, 0x00985310, 0x00987310,
-    0x00989310, 0x0098b310, 0x0098d310, 0x0098f310,
-    0x00991310, 0x00993310, 0x00995310, 0x00997310,
-    0x00999310, 0x0099b310, 0x0099d310, 0x0099f310,
-    0x009a1310, 0x009a3310, 0x009a5310, 0x009a7310,
-    0x009a9310, 0x009ab310, 0x009ad310, 0x009af310,
-    0x009b1310, 0x009b3310, 0x009b5310, 0x009b7310,
-    0x009b9310, 0x009bb310, 0x009bd310, 0x009bf310,
-    0x009c1310, 0x009c3310, 0x009c5310, 0x009c7310,
-    0x009c9310, 0x009cb310, 0x009cd310, 0x009cf310,
-    0x009d1310, 0x009d3310, 0x009d5310, 0x009d7310,
-    0x009d9310, 0x009db310, 0x009dd310, 0x009df310,
-    0x009e1310, 0x009e3310, 0x009e5310, 0x009e7310,
-    0x009e9310, 0x009eb310, 0x009ed310, 0x009ef310,
-    0x009f1310, 0x009f3310, 0x009f5310, 0x009f7310,
-    0x009f9310, 0x009fb310, 0x009fd310, 0x009ff310,
-    0x00a01310, 0x00a03310, 0x00a05310, 0x00a07310,
-    0x00a09310, 0x00a0b310, 0x00a0d310, 0x00a0f310,
-    0x00a11310, 0x00a13310, 0x00a15310, 0x00a17310,
-    0x00a19310, 0x00a1b310, 0x00a1d310, 0x00a1f310,
-    0x00a21310, 0x00a23310, 0x00a25310, 0x00a27310,
-    0x00a29310, 0x00a2b310, 0x00a2d310, 0x00a2f310,
-    0x00a31310, 0x00a33310, 0x00a35310, 0x00a37310,
-    0x00a39310, 0x00a3b310, 0x00a3d310, 0x00a3f310,
-    0x00a41310, 0x00a43310, 0x00a45310, 0x00a47310,
-    0x00a49310, 0x00a4b310, 0x00a4d310, 0x00a4f310,
-    0x00a51310, 0x00a53310, 0x00a55310, 0x00a57310,
-    0x00a59310, 0x00a5b310, 0x00a5d310, 0x00a5f310,
-    0x00a61310, 0x00a63310, 0x00a65310, 0x00a67310,
-    0x00a69310, 0x00a6b310, 0x00a6d310, 0x00a6f310,
-    0x00a71310, 0x00a73310, 0x00a75310, 0x00a77310,
-    0x00a79310, 0x00a7b310, 0x00a7d310, 0x00a7f310,
-    0x00a81310, 0x00a83310, 0x00a85310, 0x00a87310,
-    0x00a89310, 0x00a8b310, 0x00a8d310, 0x00a8f310,
-    0x00a91310, 0x00a93310, 0x00a95310, 0x00a97310,
-    0x00a99310, 0x00a9b310, 0x00a9d310, 0x00a9f310,
-    0x00aa1310, 0x00aa3310, 0x00aa5310, 0x00aa7310,
-    0x00aa9310, 0x00aab310, 0x00aad310, 0x00aaf310,
-    0x00ab1310, 0x00ab3310, 0x00ab5310, 0x00ab7310,
-    0x00ab9310, 0x00abb310, 0x00abd310, 0x00abf310,
-    0x00ac1310, 0x00ac3310, 0x00ac5310, 0x00ac7310,
-    0x00ac9310, 0x00acb310, 0x00acd310, 0x00acf310,
-    0x00ad1310, 0x00ad3310, 0x00ad5310, 0x00ad7310,
-    0x00ad9310, 0x00adb310, 0x00add310, 0x00adf310,
-    0x00ae1310, 0x00ae3310, 0x00ae5310, 0x00ae7310,
-    0x00ae9310, 0x00aeb310, 0x00aed310, 0x00aef310,
-    0x00af1310, 0x00af3310, 0x00af5310, 0x00af7310,
-    0x00af9310, 0x00afb310, 0x00afd310, 0x00aff310,
-    0x00b01310, 0x00b03310, 0x00b05310, 0x00b07310,
-    0x00b09310, 0x00b0b310, 0x00b0d310, 0x00b0f310,
-    0x00b11310, 0x00b13310, 0x00b15310, 0x00b17310,
-    0x00b19310, 0x00b1b310, 0x00b1d310, 0x00b1f310,
-    0x00b21310, 0x00b23310, 0x00b25310, 0x00b27310,
-    0x00b29310, 0x00b2b310, 0x00b2d310, 0x00b2f310,
-    0x00b31310, 0x00b33310, 0x00b35310, 0x00b37310,
-    0x00b39310, 0x00b3b310, 0x00b3d310, 0x00b3f310,
-    0x00b41310, 0x00b43310, 0x00b45310, 0x00b47310,
-    0x00b49310, 0x00b4b310, 0x00b4d310, 0x00b4f310,
-    0x00b51310, 0x00b53310, 0x00b55310, 0x00b57310,
-    0x00b59310, 0x00b5b310, 0x00b5d310, 0x00b5f310,
-    0x00b61310, 0x00b63310, 0x00b65310, 0x00b67310,
-    0x00b69310, 0x00b6b310, 0x00b6d310, 0x00b6f310,
-    0x00b71310, 0x00b73310, 0x00b75310, 0x00b77310,
-    0x00b79310, 0x00b7b310, 0x00b7d310, 0x00b7f310,
-    0x00b81310, 0x00b83310, 0x00b85310, 0x00b87310,
-    0x00b89310, 0x00b8b310, 0x00b8d310, 0x00b8f310,
-    0x00b91310, 0x00b93310, 0x00b95310, 0x00b97310,
-    0x00b99310, 0x00b9b310, 0x00b9d310, 0x00b9f310,
-    0x00ba1310, 0x00ba3310, 0x00ba5310, 0x00ba7310,
-    0x00ba9310, 0x00bab310, 0x00bad310, 0x00baf310,
-    0x00bb1310, 0x00bb3310, 0x00bb5310, 0x00bb7310,
-    0x00bb9310, 0x00bbb310, 0x00bbd310, 0x00bbf310,
-    0x00bc1310, 0x00bc3310, 0x00bc5310, 0x00bc7310,
-    0x00bc9310, 0x00bcb310, 0x00bcd310, 0x00bcf310,
-    0x00bd1310, 0x00bd3310, 0x00bd5310, 0x00bd7310,
-    0x00bd9310, 0x00bdb310, 0x00bdd310, 0x00bdf310,
-    0x00be1310, 0x00be3310, 0x00be5310, 0x00be7310,
-    0x00be9310, 0x00beb310, 0x00bed310, 0x00bef310,
-    0x00bf1310, 0x00bf3310, 0x00bf5310, 0x00bf7310,
-    0x00bf9310, 0x00bfb310, 0x00bfd310, 0x00bff310,
-    0x00c01310, 0x00c03310, 0x00c05310, 0x00c07310,
-    0x00c09310, 0x00c0b310, 0x00c0d310, 0x00c0f310,
-    0x00c11310, 0x00c13310, 0x00c15310, 0x00c17310,
-    0x00c19310, 0x00c1b310, 0x00c1d310, 0x00c1f310,
-    0x00c21310, 0x00c23310, 0x00c25310, 0x00c27310,
-    0x00c29310, 0x00c2b310, 0x00c2d310, 0x00c2f310,
-    0x00c31310, 0x00c33310, 0x00c35310, 0x00c37310,
-    0x00c39310, 0x00c3b310, 0x00c3d310, 0x00c3f310,
-    0x00c41310, 0x00c43310, 0x00c45310, 0x00c47310,
-    0x00c49310, 0x00c4b310, 0x00c4d310, 0x00c4f310,
-    0x00c51310, 0x00c53310, 0x00c55310, 0x00c57310,
-    0x00c59310, 0x00c5b310, 0x00c5d310, 0x00c5f310,
-    0x00c61310, 0x00c63310, 0x00c65310, 0x00c67310,
-    0x00c69310, 0x00c6b310, 0x00c6d310, 0x00c6f310,
-    0x00c71310, 0x00c73310, 0x00c75310, 0x00c77310,
-    0x00c79310, 0x00c7b310, 0x00c7d310, 0x00c7f310,
-    0x00c81310, 0x00c83310, 0x00c85310, 0x00c87310,
-    0x00c89310, 0x00c8b310, 0x00c8d310, 0x00c8f310,
-    0x00c91310, 0x00c93310, 0x00c95310, 0x00c97310,
-    0x00c99310, 0x00c9b310, 0x00c9d310, 0x00c9f310,
-    0x00ca1310, 0x00ca3310, 0x00ca5310, 0x00ca7310,
-    0x00ca9310, 0x00cab310, 0x00cad310, 0x00caf310,
-    0x00cb1310, 0x00cb3310, 0x00cb5310, 0x00cb7310,
-    0x00cb9310, 0x00cbb310, 0x00cbd310, 0x00cbf310,
-    0x00cc1310, 0x00cc3310, 0x00cc5310, 0x00cc7310,
-    0x00cc9310, 0x00ccb310, 0x00ccd310, 0x00ccf310,
-    0x00cd1310, 0x00cd3310, 0x00cd5310, 0x00cd7310,
-    0x00cd9310, 0x00cdb310, 0x00cdd310, 0x00cdf310,
-    0x00ce1310, 0x00ce3310, 0x00ce5310, 0x00ce7310,
-    0x00ce9310, 0x00ceb310, 0x00ced310, 0x00cef310,
-    0x00cf1310, 0x00cf3310, 0x00cf5310, 0x00cf7310,
-    0x00cf9310, 0x00cfb310, 0x00cfd310, 0x00cff310,
-    0x00d01310, 0x00d03310, 0x00d05310, 0x00d07310,
-    0x00d09310, 0x00d0b310, 0x00d0d310, 0x00d0f310,
-    0x00d11310, 0x00d13310, 0x00d15310, 0x00d17310,
-    0x00d19310, 0x00d1b310, 0x00d1d310, 0x00d1f310,
-    0x00d21310, 0x00d23310, 0x00d25310, 0x00d27310,
-    0x00d29310, 0x00d2b310, 0x00d2d310, 0x00d2f310,
-    0x00d31310, 0x00d33310, 0x00d35310, 0x00d37310,
-    0x00d39310, 0x00d3b310, 0x00d3d310, 0x00d3f310,
-    0x00d41310, 0x00d43310, 0x00d45310, 0x00d47310,
-    0x00d49310, 0x00d4b310, 0x00d4d310, 0x00d4f310,
-    0x00d51310, 0x00d53310, 0x00d55310, 0x00d57310,
-    0x00d59310, 0x00d5b310, 0x00d5d310, 0x00d5f310,
-    0x00d61310, 0x00d63310, 0x00d65310, 0x00d67310,
-    0x00d69310, 0x00d6b310, 0x00d6d310, 0x00d6f310,
-    0x00d71310, 0x00d73310, 0x00d75310, 0x00d77310,
-    0x00d79310, 0x00d7b310, 0x00d7d310, 0x00d7f310,
-    0x00d81310, 0x00d83310, 0x00d85310, 0x00d87310,
-    0x00d89310, 0x00d8b310, 0x00d8d310, 0x00d8f310,
-    0x00d91310, 0x00d93310, 0x00d95310, 0x00d97310,
-    0x00d99310, 0x00d9b310, 0x00d9d310, 0x00d9f310,
-    0x00da1310, 0x00da3310, 0x00da5310, 0x00da7310,
-    0x00da9310, 0x00dab310, 0x00dad310, 0x00daf310,
-    0x00db1310, 0x00db3310, 0x00db5310, 0x00db7310,
-    0x00db9310, 0x00dbb310, 0x00dbd310, 0x00dbf310,
-    0x00dc1310, 0x00dc3310, 0x00dc5310, 0x00dc7310,
-    0x00dc9310, 0x00dcb310, 0x00dcd310, 0x00dcf310,
-    0x00dd1310, 0x00dd3310, 0x00dd5310, 0x00dd7310,
-    0x00dd9310, 0x00ddb310, 0x00ddd310, 0x00ddf310,
-    0x00de1310, 0x00de3310, 0x00de5310, 0x00de7310,
-    0x00de9310, 0x00deb310, 0x00ded310, 0x00def310,
-    0x00df1310, 0x00df3310, 0x00df5310, 0x00df7310,
-    0x00df9310, 0x00dfb310, 0x00dfd310, 0x00dff310,
-    0x00e01310, 0x00e03310, 0x00e05310, 0x00e07310,
-    0x00e09310, 0x00e0b310, 0x00e0d310, 0x00e0f310,
-    0x00e11310, 0x00e13310, 0x00e15310, 0x00e17310,
-    0x00e19310, 0x00e1b310, 0x00e1d310, 0x00e1f310,
-    0x00e21310, 0x00e23310, 0x00e25310, 0x00e27310,
-    0x00e29310, 0x00e2b310, 0x00e2d310, 0x00e2f310,
-    0x00e31310, 0x00e33310, 0x00e35310, 0x00e37310,
-    0x00e39310, 0x00e3b310, 0x00e3d310, 0x00e3f310,
-    0x00e41310, 0x00e43310, 0x00e45310, 0x00e47310,
-    0x00e49310, 0x00e4b310, 0x00e4d310, 0x00e4f310,
-    0x00e51310, 0x00e53310, 0x00e55310, 0x00e57310,
-    0x00e59310, 0x00e5b310, 0x00e5d310, 0x00e5f310,
-    0x00e61310, 0x00e63310, 0x00e65310, 0x00e67310,
-    0x00e69310, 0x00e6b310, 0x00e6d310, 0x00e6f310,
-    0x00e71310, 0x00e73310, 0x00e75310, 0x00e77310,
-    0x00e79310, 0x00e7b310, 0x00e7d310, 0x00e7f310,
-    0x00e81310, 0x00e83310, 0x00e85310, 0x00e87310,
-    0x00e89310, 0x00e8b310, 0x00e8d310, 0x00e8f310,
-    0x00e91310, 0x00e93310, 0x00e95310, 0x00e97310,
-    0x00e99310, 0x00e9b310, 0x00e9d310, 0x00e9f310,
-    0x00ea1310, 0x00ea3310, 0x00ea5310, 0x00ea7310,
-    0x00ea9310, 0x00eab310, 0x00ead310, 0x00eaf310,
-    0x00eb1310, 0x00eb3310, 0x00eb5310, 0x00eb7310,
-    0x00eb9310, 0x00ebb310, 0x00ebd310, 0x00ebf310,
-    0x00ec1310, 0x00ec3310, 0x00ec5310, 0x00ec7310,
-    0x00ec9310, 0x00ecb310, 0x00ecd310, 0x00ecf310,
-    0x00ed1310, 0x00ed3310, 0x00ed5310, 0x00ed7310,
-    0x00ed9310, 0x00edb310, 0x00edd310, 0x00edf310,
-    0x00ee1310, 0x00ee3310, 0x00ee5310, 0x00ee7310,
-    0x00ee9310, 0x00eeb310, 0x00eed310, 0x00eef310,
-    0x00ef1310, 0x00ef3310, 0x00ef5310, 0x00ef7310,
-    0x00ef9310, 0x00efb310, 0x00efd310, 0x00eff310,
-    0x00f01310, 0x00f03310, 0x00f05310, 0x00f07310,
-    0x00f09310, 0x00f0b310, 0x00f0d310, 0x00f0f310,
-    0x00f11310, 0x00f13310, 0x00f15310, 0x00f17310,
-    0x00f19310, 0x00f1b310, 0x00f1d310, 0x00f1f310,
-    0x00f21310, 0x00f23310, 0x00f25310, 0x00f27310,
-    0x00f29310, 0x00f2b310, 0x00f2d310, 0x00f2f310,
-    0x00f31310, 0x00f33310, 0x00f35310, 0x00f37310,
-    0x00f39310, 0x00f3b310, 0x00f3d310, 0x00f3f310,
-    0x00f41310, 0x00f43310, 0x00f45310, 0x00f47310,
-    0x00f49310, 0x00f4b310, 0x00f4d310, 0x00f4f310,
-    0x00f51310, 0x00f53310, 0x00f55310, 0x00f57310,
-    0x00f59310, 0x00f5b310, 0x00f5d310, 0x00f5f310,
-    0x00f61310, 0x00f63310, 0x00f65310, 0x00f67310,
-    0x00f69310, 0x00f6b310, 0x00f6d310, 0x00f6f310,
-    0x00f71310, 0x00f73310, 0x00f75310, 0x00f77310,
-    0x00f79310, 0x00f7b310, 0x00f7d310, 0x00f7f310,
-    0x00f81310, 0x00f83310, 0x00f85310, 0x00f87310,
-    0x00f89310, 0x00f8b310, 0x00f8d310, 0x00f8f310,
-    0x00f91310, 0x00f93310, 0x00f95310, 0x00f97310,
-    0x00f99310, 0x00f9b310, 0x00f9d310, 0x00f9f310,
-    0x00fa1310, 0x00fa3310, 0x00fa5310, 0x00fa7310,
-    0x00fa9310, 0x00fab310, 0x00fad310, 0x00faf310,
-    0x00fb1310, 0x00fb3310, 0x00fb5310, 0x00fb7310,
-    0x00fb9310, 0x00fbb310, 0x00fbd310, 0x00fbf310,
-    0x00fc1310, 0x00fc3310, 0x00fc5310, 0x00fc7310,
-    0x00fc9310, 0x00fcb310, 0x00fcd310, 0x00fcf310,
-    0x00fd1310, 0x00fd3310, 0x00fd5310, 0x00fd7310,
-    0x00fd9310, 0x00fdb310, 0x00fdd310, 0x00fdf310,
-    0x00fe1310, 0x00fe3310, 0x00fe5310, 0x00fe7310,
-    0x00fe9310, 0x00feb310, 0x00fed310, 0x00fef310,
-    0x00ff1310, 0x00ff3310, 0x00ff5310, 0x00ff7310,
-    0x00ff9310, 0x00ffb310, 0x00ffd310, 0x00fff310,
-};
diff --git a/contrib/libzlib-ng/arch/x86/fill_window_sse.c b/contrib/libzlib-ng/arch/x86/fill_window_sse.c
deleted file mode 100644
index d82b1d1bcb8..00000000000
--- a/contrib/libzlib-ng/arch/x86/fill_window_sse.c
+++ /dev/null
@@ -1,165 +0,0 @@
-/*
- * Fill Window with SSE2-optimized hash shifting
- *
- * Copyright (C) 2013 Intel Corporation
- * Authors:
- *  Arjan van de Ven    <arjan@linux.intel.com>
- *  Jim Kukunas         <james.t.kukunas@linux.intel.com>
- *
- * For conditions of distribution and use, see copyright notice in zlib.h
- */
-#ifdef X86_SSE2_FILL_WINDOW
-
-#include <immintrin.h>
-#include "deflate.h"
-
-extern int read_buf(z_stream *strm, unsigned char *buf, unsigned size);
-
-ZLIB_INTERNAL void fill_window_sse(deflate_state *s) {
-    const __m128i xmm_wsize = _mm_set1_epi16(s->w_size);
-
-    register unsigned n;
-    register Pos *p;
-    unsigned more;    /* Amount of free space at the end of the window. */
-    unsigned int wsize = s->w_size;
-
-    Assert(s->lookahead < MIN_LOOKAHEAD, "already enough lookahead");
-
-    do {
-        more = (unsigned)(s->window_size -(unsigned long)s->lookahead -(unsigned long)s->strstart);
-
-        /* Deal with !@#$% 64K limit: */
-        if (sizeof(int) <= 2) {
-            if (more == 0 && s->strstart == 0 && s->lookahead == 0) {
-                more = wsize;
-
-            } else if (more == (unsigned)(-1)) {
-                /* Very unlikely, but possible on 16 bit machine if
-                 * strstart == 0 && lookahead == 1 (input done a byte at time)
-                 */
-                more--;
-            }
-        }
-
-        /* If the window is almost full and there is insufficient lookahead,
-         * move the upper half to the lower one to make room in the upper half.
-         */
-        if (s->strstart >= wsize+MAX_DIST(s)) {
-            memcpy(s->window, s->window+wsize, (unsigned)wsize);
-            s->match_start -= wsize;
-            s->strstart    -= wsize; /* we now have strstart >= MAX_DIST */
-            s->block_start -= (long) wsize;
-
-            /* Slide the hash table (could be avoided with 32 bit values
-               at the expense of memory usage). We slide even when level == 0
-               to keep the hash table consistent if we switch back to level > 0
-               later. (Using level 0 permanently is not an optimal usage of
-               zlib, so we don't care about this pathological case.)
-             */
-            n = s->hash_size;
-            p = &s->head[n];
-            p -= 8;
-            do {
-                __m128i value, result;
-
-                value = _mm_loadu_si128((__m128i *)p);
-                result = _mm_subs_epu16(value, xmm_wsize);
-                _mm_storeu_si128((__m128i *)p, result);
-
-                p -= 8;
-                n -= 8;
-            } while (n > 0);
-
-            n = wsize;
-            p = &s->prev[n];
-            p -= 8;
-            do {
-                __m128i value, result;
-
-                value = _mm_loadu_si128((__m128i *)p);
-                result = _mm_subs_epu16(value, xmm_wsize);
-                _mm_storeu_si128((__m128i *)p, result);
-
-                p -= 8;
-                n -= 8;
-            } while (n > 0);
-            more += wsize;
-        }
-        if (s->strm->avail_in == 0) break;
-
-        /* If there was no sliding:
-         *    strstart <= WSIZE+MAX_DIST-1 && lookahead <= MIN_LOOKAHEAD - 1 &&
-         *    more == window_size - lookahead - strstart
-         * => more >= window_size - (MIN_LOOKAHEAD-1 + WSIZE + MAX_DIST-1)
-         * => more >= window_size - 2*WSIZE + 2
-         * In the BIG_MEM or MMAP case (not yet supported),
-         *   window_size == input_size + MIN_LOOKAHEAD  &&
-         *   strstart + s->lookahead <= input_size => more >= MIN_LOOKAHEAD.
-         * Otherwise, window_size == 2*WSIZE so more >= 2.
-         * If there was sliding, more >= WSIZE. So in all cases, more >= 2.
-         */
-        Assert(more >= 2, "more < 2");
-
-        n = read_buf(s->strm, s->window + s->strstart + s->lookahead, more);
-        s->lookahead += n;
-
-        /* Initialize the hash value now that we have some input: */
-        if (s->lookahead + s->insert >= MIN_MATCH) {
-            unsigned int str = s->strstart - s->insert;
-            s->ins_h = s->window[str];
-            if (str >= 1)
-                UPDATE_HASH(s, s->ins_h, str + 1 - (MIN_MATCH-1));
-#if MIN_MATCH != 3
-            Call UPDATE_HASH() MIN_MATCH-3 more times
-#endif
-            while (s->insert) {
-                UPDATE_HASH(s, s->ins_h, str);
-                s->prev[str & s->w_mask] = s->head[s->ins_h];
-                s->head[s->ins_h] = (Pos)str;
-                str++;
-                s->insert--;
-                if (s->lookahead + s->insert < MIN_MATCH)
-                    break;
-            }
-        }
-        /* If the whole input has less than MIN_MATCH bytes, ins_h is garbage,
-         * but this is not important since only literal bytes will be emitted.
-         */
-    } while (s->lookahead < MIN_LOOKAHEAD && s->strm->avail_in != 0);
-
-    /* If the WIN_INIT bytes after the end of the current data have never been
-     * written, then zero those bytes in order to avoid memory check reports of
-     * the use of uninitialized (or uninitialised as Julian writes) bytes by
-     * the longest match routines.  Update the high water mark for the next
-     * time through here.  WIN_INIT is set to MAX_MATCH since the longest match
-     * routines allow scanning to strstart + MAX_MATCH, ignoring lookahead.
-     */
-    if (s->high_water < s->window_size) {
-        unsigned long curr = s->strstart + (unsigned long)(s->lookahead);
-        unsigned long init;
-
-        if (s->high_water < curr) {
-            /* Previous high water mark below current data -- zero WIN_INIT
-             * bytes or up to end of window, whichever is less.
-             */
-            init = s->window_size - curr;
-            if (init > WIN_INIT)
-                init = WIN_INIT;
-            memset(s->window + curr, 0, (unsigned)init);
-            s->high_water = curr + init;
-        } else if (s->high_water < (unsigned long)curr + WIN_INIT) {
-            /* High water mark at or above current data, but below current data
-             * plus WIN_INIT -- zero out to current data plus WIN_INIT, or up
-             * to end of window, whichever is less.
-             */
-            init = (unsigned long)curr + WIN_INIT - s->high_water;
-            if (init > s->window_size - s->high_water)
-                init = s->window_size - s->high_water;
-            memset(s->window + s->high_water, 0, (unsigned)init);
-            s->high_water += init;
-        }
-    }
-
-    Assert((unsigned long)s->strstart <= s->window_size - MIN_LOOKAHEAD, "not enough room for search");
-}
-#endif
diff --git a/contrib/libzlib-ng/arch/x86/insert_string_sse.c b/contrib/libzlib-ng/arch/x86/insert_string_sse.c
deleted file mode 100644
index 6d4ddaea519..00000000000
--- a/contrib/libzlib-ng/arch/x86/insert_string_sse.c
+++ /dev/null
@@ -1,50 +0,0 @@
-/* insert_string_sse -- insert_string variant using SSE4.2's CRC instructions
- *
- * Copyright (C) 1995-2013 Jean-loup Gailly and Mark Adler
- * For conditions of distribution and use, see copyright notice in zlib.h
- *
- */
-
-#include "deflate.h"
-
-/* ===========================================================================
- * Insert string str in the dictionary and set match_head to the previous head
- * of the hash chain (the most recent string with same hash key). Return
- * the previous length of the hash chain.
- * IN  assertion: all calls to to INSERT_STRING are made with consecutive
- *    input characters and the first MIN_MATCH bytes of str are valid
- *    (except for the last MIN_MATCH-1 bytes of the input file).
- */
-#ifdef X86_SSE4_2_CRC_HASH
-Pos insert_string_sse(deflate_state *const s, const Pos str, unsigned int count) {
-    Pos ret = 0;
-    unsigned int idx;
-    unsigned *ip, val, h = 0;
-
-    for (idx = 0; idx < count; idx++) {
-        ip = (unsigned *)&s->window[str+idx];
-        val = *ip;
-        h = 0;
-
-        if (s->level >= 6)
-            val &= 0xFFFFFF;
-
-#ifdef _MSC_VER
-        h = _mm_crc32_u32(h, val);
-#else
-        __asm__ __volatile__ (
-            "crc32 %1,%0\n\t"
-            : "+r" (h)
-            : "r" (val)
-        );
-#endif
-
-        if (s->head[h & s->hash_mask] != str+idx) {
-            s->prev[(str+idx) & s->w_mask] = s->head[h & s->hash_mask];
-            s->head[h & s->hash_mask] = str+idx;
-        }
-    }
-    ret = s->prev[(str+count-1) & s->w_mask];
-    return ret;
-}
-#endif
diff --git a/contrib/libzlib-ng/arch/x86/x86.c b/contrib/libzlib-ng/arch/x86/x86.c
deleted file mode 100644
index c932627f163..00000000000
--- a/contrib/libzlib-ng/arch/x86/x86.c
+++ /dev/null
@@ -1,53 +0,0 @@
-/*
- * x86 feature check
- *
- * Copyright (C) 2013 Intel Corporation. All rights reserved.
- * Author:
- *  Jim Kukunas
- *
- * For conditions of distribution and use, see copyright notice in zlib.h
- */
-
-#include "x86.h"
-
-ZLIB_INTERNAL int x86_cpu_has_sse2;
-ZLIB_INTERNAL int x86_cpu_has_sse42;
-ZLIB_INTERNAL int x86_cpu_has_pclmulqdq;
-
-#ifdef _MSC_VER
-#include <intrin.h>
-#else
-// Newer versions of GCC and clang come with cpuid.h
-#include <cpuid.h>
-#endif
-
-static void cpuid(int info, unsigned* eax, unsigned* ebx, unsigned* ecx, unsigned* edx) {
-#ifdef _MSC_VER
-	unsigned int registers[4];
-	__cpuid(registers, info);
-
-	*eax = registers[0];
-	*ebx = registers[1];
-	*ecx = registers[2];
-	*edx = registers[3];
-#else
-	unsigned int _eax;
-	unsigned int _ebx;
-	unsigned int _ecx;
-	unsigned int _edx;
-	__cpuid(info, _eax, _ebx, _ecx, _edx);
-	*eax = _eax;
-	*ebx = _ebx;
-	*ecx = _ecx;
-	*edx = _edx;
-#endif
-}
-
-void ZLIB_INTERNAL x86_check_features(void) {
-	unsigned eax, ebx, ecx, edx;
-	cpuid(1 /*CPU_PROCINFO_AND_FEATUREBITS*/, &eax, &ebx, &ecx, &edx);
-
-	x86_cpu_has_sse2 = edx & 0x4000000;
-	x86_cpu_has_sse42 = ecx & 0x100000;
-	x86_cpu_has_pclmulqdq = ecx & 0x2;
-}
diff --git a/contrib/libzlib-ng/arch/x86/x86.h b/contrib/libzlib-ng/arch/x86/x86.h
deleted file mode 100644
index 78be0a661a1..00000000000
--- a/contrib/libzlib-ng/arch/x86/x86.h
+++ /dev/null
@@ -1,23 +0,0 @@
- /* cpu.h -- check for CPU features
- * Copyright (C) 2013 Intel Corporation Jim Kukunas
- * For conditions of distribution and use, see copyright notice in zlib.h
- */
-
-#ifndef CPU_H_
-#define CPU_H_
-
-#if defined(HAVE_INTERNAL)
-#  define ZLIB_INTERNAL __attribute__((visibility ("internal")))
-#elif defined(HAVE_HIDDEN)
-# define ZLIB_INTERNAL __attribute__((visibility ("hidden")))
-#else
-# define ZLIB_INTERNAL
-#endif
-
-extern int x86_cpu_has_sse2;
-extern int x86_cpu_has_sse42;
-extern int x86_cpu_has_pclmulqdq;
-
-void ZLIB_INTERNAL x86_check_features(void);
-
-#endif /* CPU_H_ */
diff --git a/contrib/libzlib-ng/compress.c b/contrib/libzlib-ng/compress.c
deleted file mode 100644
index 9f6f140298f..00000000000
--- a/contrib/libzlib-ng/compress.c
+++ /dev/null
@@ -1,74 +0,0 @@
-/* compress.c -- compress a memory buffer
- * Copyright (C) 1995-2005, 2014 Jean-loup Gailly, Mark Adler.
- * For conditions of distribution and use, see copyright notice in zlib.h
- */
-
-/* @(#) $Id$ */
-
-#define ZLIB_INTERNAL
-#include "zlib.h"
-
-/* ===========================================================================
-     Compresses the source buffer into the destination buffer. The level
-   parameter has the same meaning as in deflateInit.  sourceLen is the byte
-   length of the source buffer. Upon entry, destLen is the total size of the
-   destination buffer, which must be at least 0.1% larger than sourceLen plus
-   12 bytes. Upon exit, destLen is the actual size of the compressed buffer.
-
-     compress2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
-   memory, Z_BUF_ERROR if there was not enough room in the output buffer,
-   Z_STREAM_ERROR if the level parameter is invalid.
-*/
-int ZEXPORT compress2(unsigned char *dest, size_t *destLen, const unsigned char *source,
-                        size_t sourceLen, int level) {
-    z_stream stream;
-    int err;
-    const unsigned int max = (unsigned int)0 - 1;
-    size_t left;
-
-    left = *destLen;
-    *destLen = 0;
-
-    stream.zalloc = (alloc_func)0;
-    stream.zfree = (free_func)0;
-    stream.opaque = NULL;
-
-    err = deflateInit(&stream, level);
-    if (err != Z_OK)
-        return err;
-
-    stream.next_out = dest;
-    stream.avail_out = 0;
-    stream.next_in = (const unsigned char *)source;
-    stream.avail_in = 0;
-
-    do {
-        if (stream.avail_out == 0) {
-            stream.avail_out = left > (unsigned long)max ? max : (unsigned int)left;
-            left -= stream.avail_out;
-        }
-        if (stream.avail_in == 0) {
-            stream.avail_in = sourceLen > (unsigned long)max ? max : (unsigned int)sourceLen;
-            sourceLen -= stream.avail_in;
-        }
-        err = deflate(&stream, sourceLen ? Z_NO_FLUSH : Z_FINISH);
-    } while (err == Z_OK);
-
-    *destLen = stream.total_out;
-    deflateEnd(&stream);
-    return err == Z_STREAM_END ? Z_OK : err;
-}
-
-/* ===========================================================================
- */
-int ZEXPORT compress(unsigned char *dest, size_t *destLen, const unsigned char *source, size_t sourceLen) {
-    return compress2(dest, destLen, source, sourceLen, Z_DEFAULT_COMPRESSION);
-}
-
-/* ===========================================================================
-   If the default memLevel or windowBits for deflateInit() is changed, then
-   this function needs to be updated.
- */
-size_t ZEXPORT compressBound(size_t sourceLen) {
-    return sourceLen + (sourceLen >> 12) + (sourceLen >> 14) + (sourceLen >> 25) + 13;
-}
diff --git a/contrib/libzlib-ng/configure b/contrib/libzlib-ng/configure
deleted file mode 100755
index de55744c6f2..00000000000
--- a/contrib/libzlib-ng/configure
+++ /dev/null
@@ -1,923 +0,0 @@
-#!/bin/sh
-# configure script for zlib.
-#
-# Normally configure builds both a static and a shared library.
-# If you want to build just a static library, use: ./configure --static
-#
-# To impose specific compiler or flags or install directory, use for example:
-#    prefix=$HOME CC=cc CFLAGS="-O4" ./configure
-# or for csh/tcsh users:
-#    (setenv prefix $HOME; setenv CC cc; setenv CFLAGS "-O4"; ./configure)
-
-# Incorrect settings of CC or CFLAGS may prevent creating a shared library.
-# If you have problems, try without defining CC and CFLAGS before reporting
-# an error.
-
-# start off configure.log
-echo -------------------- >> configure.log
-echo $0 $* >> configure.log
-date >> configure.log
-
-SRCDIR=$(cd $(dirname $0); pwd)
-BUILDDIR=$(pwd)
-
-# set command prefix for cross-compilation
-if [ -n "${CHOST}" ]; then
-    uname="`echo "${CHOST}" | sed -e 's/^[^-]*-\([^-]*\)$/\1/' -e 's/^[^-]*-[^-]*-\([^-]*\)$/\1/' -e 's/^[^-]*-[^-]*-\([^-]*\)-.*$/\1/'`"
-    CROSS_PREFIX="${CHOST}-"
-    ARCH="`echo "${CHOST}" | sed -e 's/-.*//'`"
-else
-    ARCH="`uname -m`"
-fi
-
-case "${ARCH}" in
-    x86_64)
-        case "${CFLAGS}" in
-            *-m32*)
-                ARCH=i686
-            ;;
-        esac
-    ;;
-    i386 | i486 | i586 | i686)
-        case "${CFLAGS}" in
-            *-m64*)
-                ARCH=x86_64
-            ;;
-        esac
-    ;;
-esac
-
-# destination name for static library
-STATICLIB=libz.a
-
-# destination name for windows import library
-IMPORTLIB=
-
-# extract zlib version numbers from zlib.h
-VER=`sed -n -e '/ZLIB_VERSION "/s/.*"\(.*\)".*/\1/p' < ${SRCDIR}/zlib.h`
-VER3=`sed -n -e '/ZLIB_VERSION "/s/.*"\([0-9]*\\.[0-9]*\\.[0-9]*\).*/\1/p' < ${SRCDIR}/zlib.h`
-VER2=`sed -n -e '/ZLIB_VERSION "/s/.*"\([0-9]*\\.[0-9]*\)\\..*/\1/p' < ${SRCDIR}/zlib.h`
-VER1=`sed -n -e '/ZLIB_VERSION "/s/.*"\([0-9]*\)\\..*/\1/p' < ${SRCDIR}/zlib.h`
-
-# establish commands for library building
-if "${CROSS_PREFIX}ar" --version >/dev/null 2>/dev/null || test $? -lt 126; then
-    AR=${AR-"${CROSS_PREFIX}ar"}
-    test -n "${CROSS_PREFIX}" && echo Using ${AR} | tee -a configure.log
-else
-    AR=${AR-"ar"}
-    test -n "${CROSS_PREFIX}" && echo Using ${AR} | tee -a configure.log
-fi
-ARFLAGS=${ARFLAGS-"rc"}
-if "${CROSS_PREFIX}ranlib" --version >/dev/null 2>/dev/null || test $? -lt 126; then
-    RANLIB=${RANLIB-"${CROSS_PREFIX}ranlib"}
-    test -n "${CROSS_PREFIX}" && echo Using ${RANLIB} | tee -a configure.log
-else
-    RANLIB=${RANLIB-"ranlib"}
-fi
-if "${CROSS_PREFIX}nm" --version >/dev/null 2>/dev/null || test $? -lt 126; then
-    NM=${NM-"${CROSS_PREFIX}nm"}
-    test -n "${CROSS_PREFIX}" && echo Using ${NM} | tee -a configure.log
-else
-    NM=${NM-"nm"}
-fi
-
-# set defaults before processing command line options
-LDCONFIG=${LDCONFIG-"ldconfig"}
-LDSHAREDLIBC="${LDSHAREDLIBC--lc}"
-DEFFILE=
-RC=
-RCFLAGS=
-RCOBJS=
-STRIP=
-ARCHS=
-prefix=${prefix-/usr/local}
-exec_prefix=${exec_prefix-'${prefix}'}
-bindir=${bindir-'${exec_prefix}/bin'}
-libdir=${libdir-'${exec_prefix}/lib'}
-sharedlibdir=${sharedlibdir-'${libdir}'}
-includedir=${includedir-'${prefix}/include'}
-mandir=${mandir-'${prefix}/share/man'}
-shared_ext='.so'
-shared=1
-gzfileops=0
-compat=0
-cover=0
-build32=0
-build64=0
-without_optimizations=0
-without_new_strategies=0
-gcc=0
-old_cc="$CC"
-old_cflags="$CFLAGS"
-OBJC='$(OBJZ)'
-PIC_OBJC='$(PIC_OBJZ)'
-INSTALLTARGETS="install-shared install-static"
-UNINSTALLTARGETS="uninstall-shared uninstall-static"
-
-TEST="teststatic"
-
-# leave this script, optionally in a bad way
-leave()
-{
-  if test "$*" != "0"; then
-    echo "** $0 aborting." | tee -a configure.log
-  fi
-  rm -f $test.[co] $test $test$shared_ext $test.gcno ./--version
-  echo -------------------- >> configure.log
-  echo >> configure.log
-  echo >> configure.log
-  exit $1
-}
-
-# process command line options
-while test $# -ge 1
-do
-case "$1" in
-    -h* | --help)
-      echo 'usage:' | tee -a configure.log
-      echo '  configure [--zlib-compat] [--prefix=PREFIX]  [--eprefix=EXPREFIX]' | tee -a configure.log
-      echo '    [--static] [--32] [--64] [--libdir=LIBDIR] [--sharedlibdir=LIBDIR]' | tee -a configure.log
-      echo '    [--includedir=INCLUDEDIR] [--archs="-arch i386 -arch x86_64"]' | tee -a configure.log
-        exit 0 ;;
-    -p*=* | --prefix=*) prefix=`echo $1 | sed 's/.*=//'`; shift ;;
-    -e*=* | --eprefix=*) exec_prefix=`echo $1 | sed 's/.*=//'`; shift ;;
-    -l*=* | --libdir=*) libdir=`echo $1 | sed 's/.*=//'`; shift ;;
-    --sharedlibdir=*) sharedlibdir=`echo $1 | sed 's/.*=//'`; shift ;;
-    -i*=* | --includedir=*) includedir=`echo $1 | sed 's/.*=//'`;shift ;;
-    -u*=* | --uname=*) uname=`echo $1 | sed 's/.*=//'`;shift ;;
-    -p* | --prefix) prefix="$2"; shift; shift ;;
-    -e* | --eprefix) exec_prefix="$2"; shift; shift ;;
-    -l* | --libdir) libdir="$2"; shift; shift ;;
-    -i* | --includedir) includedir="$2"; shift; shift ;;
-    -s* | --shared | --enable-shared) shared=1; shift ;;
-    -t | --static) shared=0; shift ;;
-    --zlib-compat) compat=1; shift ;;
-    --cover) cover=1; shift ;;
-    -3* | --32) build32=1; shift ;;
-    -6* | --64) build64=1; shift ;;
-    -a*=* | --archs=*) ARCHS=`echo $1 | sed 's/.*=//'`; shift ;;
-    --sysconfdir=*) echo "ignored option: --sysconfdir" | tee -a configure.log; shift ;;
-    --localstatedir=*) echo "ignored option: --localstatedir" | tee -a configure.log; shift ;;
-    -noopt | --without-optimizations) without_optimizations=1; shift;;
-    -oldstrat | --without-new-strategies) without_new_strategies=1; shift;;
-    *)
-      echo "unknown option: $1" | tee -a configure.log
-      echo "$0 --help for help" | tee -a configure.log
-      leave 1;;
-    esac
-done
-
-# temporary file name
-test=ztest$$
-
-# put arguments in log, also put test file in log if used in arguments
-show()
-{
-  case "$*" in
-    *$test.c*)
-      echo === $test.c === >> configure.log
-      cat $test.c >> configure.log
-      echo === >> configure.log;;
-  esac
-  echo $* >> configure.log
-}
-
-# check for gcc vs. cc and set compile and link flags based on the system identified by uname
-cat > $test.c <<EOF
-extern int getchar();
-int hello() {return getchar();}
-EOF
-
-test -z "$CC" && echo Checking for ${CROSS_PREFIX}gcc... | tee -a configure.log
-cc=${CC-${CROSS_PREFIX}gcc}
-cflags=${CFLAGS-"-O3"}
-case "$cc" in
-  *gcc*) gcc=1 ;;
-  *clang*) gcc=1 ;;
-esac
-case `$cc -v 2>&1` in
-  *gcc*) gcc=1 ;;
-esac
-
-show $cc -c $test.c
-if test "$gcc" -eq 1 && ($cc -c $test.c) >> configure.log 2>&1; then
-  echo ... using gcc >> configure.log
-  CC="$cc"
-# Re-check arch if gcc is a cross-compiler
-  GCC_ARCH=`$CC -dumpmachine | sed 's/-.*//g'`
-  case $GCC_ARCH in
-    i386 | i486 | i586 | i686)
-# Honor user choice if gcc is multilib and 64-bit is requested 
-      if test $build64 -eq 1; then
-        ARCH=x86_64
-      else
-        ARCH=$GCC_ARCH 
-      fi ;;
-# Honor user choice if gcc is multilib and 32-bit is requested
-    x86_64)
-      if test $build32 -ne 1; then
-        ARCH=$GCC_ARCH
-      fi ;;
-  esac
-  CFLAGS="${CFLAGS--O3} ${ARCHS} -Wall"
-  SFLAGS="${CFLAGS--O3} -fPIC"
-  LDFLAGS="${LDFLAGS} ${ARCHS}"
-  if test $build64 -eq 1; then
-    CFLAGS="${CFLAGS} -m64"
-    SFLAGS="${SFLAGS} -m64"
-  fi
-  if test "${ZLIBGCCWARN}" = "YES"; then
-    CFLAGS="${CFLAGS} -Wextra -pedantic"
-  fi
-  if test -z "$uname"; then
-    uname=`(uname -s || echo unknown) 2>/dev/null`
-  fi
-  case "$uname" in
-  Linux* | linux* | GNU | GNU/* | solaris*)
-        LDSHARED=${LDSHARED-"$cc -shared -Wl,-soname,libz.so.1,--version-script,${SRCDIR}/zlib.map"} ;;
-  *BSD | *bsd* | DragonFly)
-        LDSHARED=${LDSHARED-"$cc -shared -Wl,-soname,libz.so.1,--version-script,${SRCDIR}/zlib.map"}
-        LDCONFIG="ldconfig -m" ;;
-  CYGWIN* | Cygwin* | cygwin*)
-        ARFLAGS="rcs"
-        CFLAGS="${CFLAGS} -D_LARGEFILE_SOURCE -D_FILE_OFFSET_BITS=64"
-        SFLAGS="${CFLAGS}"
-        shared_ext='.dll'
-        sharedlibdir='${bindir}'
-        SHAREDLIB=cygz$shared_ext
-        SHAREDLIBM=''
-        SHAREDLIBV=''
-        SHAREDTARGET=$SHAREDLIB
-        IMPORTLIB='libz.dll.a'
-        LDSHARED=${LDSHARED-"$cc -shared -Wl,--out-implib,${IMPORTLIB},--version-script,${SRCDIR}/zlib.map"}
-        LDSHAREDLIBC=""
-        DEFFILE='win32/zlib.def'
-        RC='windres'
-        RCFLAGS='--define GCC_WINDRES'
-        RCOBJS='zlibrc.o'
-        STRIP='strip'
-        EXE='.exe' ;;
-  MSYS* | msys*)
-        ARFLAGS="rcs"
-        SFLAGS="${CFLAGS}"
-        shared_ext='.dll'
-        sharedlibdir='${bindir}'
-        SHAREDLIB=msys-z$shared_ext
-        SHAREDLIBM=''
-        SHAREDLIBV=''
-        SHAREDTARGET=$SHAREDLIB
-        IMPORTLIB='libz.dll.a'
-        LDSHARED=${LDSHARED-"$cc -shared -Wl,--out-implib,${IMPORTLIB}"}
-        LDSHAREDLIBC=""
-        DEFFILE='win32/zlib.def'
-        RC='windres'
-        RCFLAGS='--define GCC_WINDRES'
-        RCOBJS='zlibrc.o'
-        STRIP='strip'
-        EXE='.exe' ;;
-  MINGW* | mingw*)
-        ARFLAGS="rcs"
-        CFLAGS="${CFLAGS} -D_LARGEFILE_SOURCE -D_FILE_OFFSET_BITS=64 -D_POSIX_C_SOURCE=200809L -D_GNU_SOURCE=1"
-        SFLAGS="${CFLAGS}"
-        shared_ext='.dll'
-        sharedlibdir='${bindir}'
-        SHAREDLIB=libz-$VER1$shared_ext
-        SHAREDLIBM=''
-        SHAREDLIBV=''
-        SHAREDTARGET=$SHAREDLIB
-        IMPORTLIB='libz.dll.a'
-        LDSHARED=${LDSHARED-"$cc -shared -Wl,--out-implib=${IMPORTLIB} -Wl,--version-script=${SRCDIR}/zlib.map"}
-        LDSHAREDLIBC=""
-        DEFFILE='win32/zlib.def'
-        RC='windres'
-        RCFLAGS='--define GCC_WINDRES'
-        if [ "$CC" == "mingw32-gcc" ]; then
-          case $ARCH in
-          i386 | i486 | i586 | i686) RCFLAGS="${RCFLAGS} -F pe-i386";;
-          esac;
-        fi
-        RCOBJS='zlibrc.o'
-        STRIP='strip'
-        EXE='.exe' ;;
-  QNX*)  # This is for QNX6. I suppose that the QNX rule below is for QNX2,QNX4
-         # (alain.bonnefoy@icbt.com)
-                 LDSHARED=${LDSHARED-"$cc -shared -Wl,-hlibz.so.1"} ;;
-  HP-UX*)
-         LDSHARED=${LDSHARED-"$cc -shared $SFLAGS"}
-         case `(uname -m || echo unknown) 2>/dev/null` in
-         ia64)
-                 shared_ext='.so'
-                 SHAREDLIB='libz.so' ;;
-         *)
-                 shared_ext='.sl'
-                 SHAREDLIB='libz.sl' ;;
-         esac ;;
-  Darwin* | darwin*)
-             shared_ext='.dylib'
-             SHAREDLIB=libz$shared_ext
-             SHAREDLIBV=libz.$VER$shared_ext
-             SHAREDLIBM=libz.$VER1$shared_ext
-             SHAREDTARGET=$SHAREDLIBV
-             LDSHARED=${LDSHARED-"$cc -dynamiclib -install_name $libdir/$SHAREDLIBM -compatibility_version $VER1 -current_version $VER3"}
-             if libtool -V 2>&1 | grep Apple > /dev/null; then
-                 AR="libtool"
-             else
-                 AR="/usr/bin/libtool"
-             fi
-             ARFLAGS="-o" ;;
-  *)             LDSHARED=${LDSHARED-"$cc -shared"} ;;
-  esac
-else
-  # find system name and corresponding cc options
-  CC=${CC-cc}
-  gcc=0
-  echo ... using $CC >> configure.log
-  if test -z "$uname"; then
-    uname=`(uname -sr || echo unknown) 2>/dev/null`
-  fi
-  case "$uname" in
-  HP-UX*)    SFLAGS=${CFLAGS-"-O +z"}
-             CFLAGS=${CFLAGS-"-O"}
-#            LDSHARED=${LDSHARED-"ld -b +vnocompatwarnings"}
-             LDSHARED=${LDSHARED-"ld -b"}
-         case `(uname -m || echo unknown) 2>/dev/null` in
-         ia64)
-             shared_ext='.so'
-             SHAREDLIB='libz.so' ;;
-         *)
-             shared_ext='.sl'
-             SHAREDLIB='libz.sl' ;;
-         esac ;;
-  AIX*)  # Courtesy of dbakker@arrayasolutions.com
-             SFLAGS=${CFLAGS-"-O -qmaxmem=8192"}
-             CFLAGS=${CFLAGS-"-O -qmaxmem=8192"}
-             LDSHARED=${LDSHARED-"xlc -G"} ;;
-  # send working options for other systems to zlib@gzip.org
-  *)         SFLAGS=${CFLAGS-"-O"}
-             CFLAGS=${CFLAGS-"-O"}
-             LDSHARED=${LDSHARED-"cc -shared"} ;;
-  esac
-fi
-
-# destination names for shared library if not defined above
-SHAREDLIB=${SHAREDLIB-"libz$shared_ext"}
-SHAREDLIBV=${SHAREDLIBV-"libz$shared_ext.$VER"}
-SHAREDLIBM=${SHAREDLIBM-"libz$shared_ext.$VER1"}
-SHAREDTARGET=${SHAREDTARGET-"libz$shared_ext.$VER"}
-
-echo >> configure.log
-
-# define functions for testing compiler and library characteristics and logging the results
-
-cat > $test.c <<EOF
-#error error
-EOF
-if ($CC -c $CFLAGS $test.c) 2>/dev/null; then
-  try()
-  {
-    show $*
-    test "`( $* ) 2>&1 | tee -a configure.log`" = ""
-  }
-  echo - using any output from compiler to indicate an error >> configure.log
-else
-try()
-{
-  show $*
-  ( $* ) >> configure.log 2>&1
-  ret=$?
-  if test $ret -ne 0; then
-    echo "(exit code "$ret")" >> configure.log
-  fi
-  return $ret
-}
-fi
-
-tryboth()
-{
-  show $*
-  got=`( $* ) 2>&1`
-  ret=$?
-  printf %s "$got" >> configure.log
-  if test $ret -ne 0; then
-    return $ret
-  fi
-  test "$got" = ""
-}
-
-cat > $test.c << EOF
-int foo() { return 0; }
-EOF
-echo "Checking for obsessive-compulsive compiler options..." >> configure.log
-if try $CC -c $CFLAGS $test.c; then
-  :
-else
-  echo "Compiler error reporting is too harsh for $0 (perhaps remove -Werror)." | tee -a configure.log
-  leave 1
-fi
-
-echo >> configure.log
-
-# see if shared library build supported
-cat > $test.c <<EOF
-extern int getchar();
-int hello() {return getchar();}
-EOF
-if test $shared -eq 1; then
-  echo Checking for shared library support... | tee -a configure.log
-  # we must test in two steps (cc then ld), required at least on SunOS 4.x
-  if try $CC -w -c $SFLAGS $test.c &&
-     try $LDSHARED $SFLAGS -o $test$shared_ext $test.o; then
-    echo Building shared library $SHAREDTARGET with $CC. | tee -a configure.log
-  elif test -z "$old_cc" -a -z "$old_cflags"; then
-    echo No shared library support. | tee -a configure.log
-    shared=0;
-  else
-    echo 'No shared library support; try without defining CC and CFLAGS' | tee -a configure.log
-    shared=0;
-  fi
-fi
-if test $shared -eq 0; then
-  LDSHARED="$CC"
-  ALL="static"
-  SHAREDLIB=""
-  SHAREDLIBV=""
-  SHAREDLIBM=""
-  SHAREDTARGET=""
-  INSTALLTARGETS=install-static
-  UNINSTALLTARGETS=uninstall-static
-  echo Building static library $STATICLIB version $VER with $CC. | tee -a configure.log
-else
-  ALL="static shared"
-  TEST="${TEST} testshared"
-fi
-
-echo >> configure.log
-
-# check for large file support, and if none, check for fseeko()
-cat > $test.c <<EOF
-#include <sys/types.h>
-#ifdef __MSYS__
-#  define off64_t _off64_t
-#endif
-off64_t dummy = 0;
-EOF
-if try $CC -c $CFLAGS -D_LARGEFILE64_SOURCE=1 $test.c; then
-  CFLAGS="${CFLAGS} -D_LARGEFILE64_SOURCE=1"
-  SFLAGS="${SFLAGS} -D_LARGEFILE64_SOURCE=1"
-  ALL="${ALL} all64"
-  TEST="${TEST} test64"
-  echo "Checking for off64_t... Yes." | tee -a configure.log
-  echo "Checking for fseeko... Yes." | tee -a configure.log
-else
-  echo "Checking for off64_t... No." | tee -a configure.log
-  echo >> configure.log
-  cat > $test.c <<EOF
-#include <stdio.h>
-int main(void) {
-  fseeko(NULL, 0, 0);
-  return 0;
-}
-EOF
-  if try $CC $CFLAGS -o $test $test.c; then
-    echo "Checking for fseeko... Yes." | tee -a configure.log
-  else
-    CFLAGS="${CFLAGS} -DNO_FSEEKO"
-    SFLAGS="${SFLAGS} -DNO_FSEEKO"
-    echo "Checking for fseeko... No." | tee -a configure.log
-  fi
-fi
-
-echo >> configure.log
-
-# check for strerror() for use by gz* functions
-cat > $test.c <<EOF
-#include <string.h>
-#include <errno.h>
-int main() { return strlen(strerror(errno)); }
-EOF
-if try $CC $CFLAGS -o $test $test.c; then
-  echo "Checking for strerror... Yes." | tee -a configure.log
-else
-  CFLAGS="${CFLAGS} -DNO_STRERROR"
-  SFLAGS="${SFLAGS} -DNO_STRERROR"
-  echo "Checking for strerror... No." | tee -a configure.log
-fi
-
-# We need to remove zconf.h from source directory if building outside of it
-if [ "$SRCDIR" != "$BUILDDIR" ]; then rm -f $SRCDIR/zconf.h; fi
-
-# copy clean zconf.h for subsequent edits
-cp -p $SRCDIR/zconf.h.in zconf.h
-
-echo >> configure.log
-
-# check for unistd.h and save result in zconf.h
-cat > $test.c <<EOF
-#include <unistd.h>
-int main() { return 0; }
-EOF
-if try $CC -c $CFLAGS $test.c; then
-  sed < zconf.h "/^#ifdef HAVE_UNISTD_H.* may be/s/def HAVE_UNISTD_H\(.*\) may be/ 1\1 was/" > zconf.temp.h
-  mv zconf.temp.h zconf.h
-  echo "Checking for unistd.h... Yes." | tee -a configure.log
-else
-  echo "Checking for unistd.h... No." | tee -a configure.log
-fi
-
-echo >> configure.log
-
-# check for stdarg.h and save result in zconf.h
-cat > $test.c <<EOF
-#include <stdarg.h>
-int main() { return 0; }
-EOF
-if try $CC -c $CFLAGS $test.c; then
-  sed < zconf.h "/^#ifdef HAVE_STDARG_H.* may be/s/def HAVE_STDARG_H\(.*\) may be/ 1\1 was/" > zconf.temp.h
-  mv zconf.temp.h zconf.h
-  echo "Checking for stdarg.h... Yes." | tee -a configure.log
-else
-  echo "Checking for stdarg.h... No." | tee -a configure.log
-fi
-
-# if --zlib-compat was requested
-if test $compat -eq 1; then
-  CFLAGS="${CFLAGS} -DZLIB_COMPAT -DWITH_GZFILEOP"
-  SFLAGS="${SFLAGS} -DZLIB_COMPAT -DWITH_GZFILEOP"
-  OBJC="${OBJC} \$(OBJG)"
-  PIC_OBJC="${PIC_OBJC} \$(PIC_OBJG)"
-  case "$uname" in
-  CYGWIN* | Cygwin* | cygwin* | MSYS* | msys* | MINGW* | mingw*)
-    DEFFILE="win32/zlibcompat.def" ;;
-  esac
-fi
-
-# if code coverage testing was requested, use older gcc if defined, e.g. "gcc-4.2" on Mac OS X
-if test $cover -eq 1; then
-  CFLAGS="${CFLAGS} -fprofile-arcs -ftest-coverage"
-  if test -n "$GCC_CLASSIC"; then
-    CC=$GCC_CLASSIC
-  fi
-fi
-
-echo >> configure.log
-
-# Check for ANSI C compliant compiler
-cat > $test.c <<EOF
-#include <stdio.h>
-#include <stdarg.h>
-#include "zconf.h"
-int main()
-{
-#ifdef STDC
-  return 0;
-#endif
-  return 1;
-}
-EOF
-if try $CC -c $CFLAGS $test.c; then
-  echo "Checking for ANSI C compliant compiler...  Yes." | tee -a configure.log
-  :
-else
-  echo "Checking for ANSI C compliant compiler...  No." | tee -a configure.log
-  echo "Error: ANSI C compatible compiler needed, cannot continue." | tee -a configure.log
-  leave 1
-fi
-
-# see if we can hide zlib internal symbols that are linked between separate source files using hidden
-if test "$gcc" -eq 1; then
-  echo >> configure.log
-  cat > $test.c <<EOF
-#define ZLIB_INTERNAL __attribute__((visibility ("hidden")))
-int ZLIB_INTERNAL foo;
-int main()
-{
-  return 0;
-}
-EOF
-  if tryboth $CC -c $CFLAGS $test.c; then
-    CFLAGS="$CFLAGS -DHAVE_HIDDEN"
-    SFLAGS="$SFLAGS -DHAVE_HIDDEN"
-    echo >> configure.log
-    echo "Checking for attribute(visibility(hidden)) support... Yes." | tee -a configure.log
-  else
-    echo >> configure.log
-    echo "Checking for attribute(visibility(hidden)) support... No." | tee -a configure.log
-  fi
-fi
-
-# see if we can hide zlib internal symbols that are linked between separate source files using internal
-if test "$gcc" -eq 1; then
-  echo >> configure.log
-  cat > $test.c <<EOF
-#define ZLIB_INTERNAL __attribute__((visibility ("internal")))
-int ZLIB_INTERNAL foo;
-int main()
-{
-  return 0;
-}
-EOF
-  if tryboth $CC -c $CFLAGS $test.c; then
-    CFLAGS="$CFLAGS -DHAVE_INTERNAL"
-    SFLAGS="$SFLAGS -DHAVE_INTERNAL"
-    echo >> configure.log
-    echo "Checking for attribute(visibility(internal)) support... Yes." | tee -a configure.log
-  else
-    echo >> configure.log
-    echo "Checking for attribute(visibility(internal)) support... No." | tee -a configure.log
-  fi
-fi
-
-# Check for __builtin_ctzl() support in compiler
-cat > $test.c << EOF
-int main(void)
-{
-    unsigned int zero = 0;
-    long test = __builtin_ctzl(zero);
-    (void)test;
-    return 0;
-}
-EOF
-if try ${CC} ${CFLAGS} $test.c; then
-    echo "Checking for __builtin_ctzl ... Yes." | tee -a configure.log
-    CFLAGS="$CFLAGS -DHAVE_BUILTIN_CTZL"
-    SFLAGS="$SFLAGS -DHAVE_BUILTIN_CTZL"
-else
-    echo "Checking for __builtin_ctzl ... No." | tee -a configure.log
-fi
-
-# Check for SSE2 intrinsics
-cat > $test.c << EOF
-#include <immintrin.h>
-int main(void)
-{
-    __m128i zero = _mm_setzero_si128();
-    (void)zero;
-    return 0;
-}
-EOF
-if try ${CC} ${CFLAGS} -msse2 $test.c; then
-    echo "Checking for SSE2 intrinsics ... Yes." | tee -a configure.log
-    HAVE_SSE2_INTRIN=1
-else
-    echo "Checking for SSE2 intrinsics ... No." | tee -a configure.log
-    HAVE_SSE2_INTRIN=0
-fi
-
-# Check for PCLMULQDQ intrinsics
-cat > $test.c << EOF
-#include <immintrin.h>
-#include <wmmintrin.h>
-int main(void)
-{
-    __m128i a = _mm_setzero_si128();
-    __m128i b = _mm_setzero_si128();
-    __m128i c = _mm_clmulepi64_si128(a, b, 0x10);
-    (void)c;
-    return 0;
-}
-EOF
-if try ${CC} ${CFLAGS} -mpclmul $test.c; then
-    echo "Checking for PCLMULQDQ intrinsics ... Yes." | tee -a configure.log
-    HAVE_PCLMULQDQ_INTRIN=1
-else
-    echo "Checking for PCLMULQDQ intrinsics ... No." | tee -a configure.log
-    HAVE_PCLMULQDQ_INTRIN=0
-fi
-
-# Enable deflate_medium at level 4-6
-if test $without_new_strategies -eq 0; then
-    CFLAGS="${CFLAGS} -DMEDIUM_STRATEGY"
-    SFLAGS="${SFLAGS} -DMEDIUM_STRATEGY"
-fi
-
-ARCHDIR='arch/generic'
-ARCH_STATIC_OBJS=''
-ARCH_SHARED_OBJS=''
-
-# Set ARCH specific FLAGS
-case "${ARCH}" in
-
-    # x86 and x86_64 specific optimizations
-    i386 | i486 | i586 | i686 | x86_64)
-	ARCHDIR=arch/x86
-
-        case "${ARCH}" in
-            x86_64)
-                CFLAGS="${CFLAGS} -DX86_64 -DX86_NOCHECK_SSE2"
-                SFLAGS="${SFLAGS} -DX86_64 -DX86_NOCHECK_SSE2"
-            ;;
-            i386 | i486 | i586 | i686)
-                CFLAGS="${CFLAGS} -DX86"
-                SFLAGS="${SFLAGS} -DX86"
-            ;;
-        esac
-
-        CFLAGS="${CFLAGS} -DUNALIGNED_OK -DUNROLL_LESS -DX86_CPUID"
-        SFLAGS="${SFLAGS} -DUNALIGNED_OK -DUNROLL_LESS -DX86_CPUID"
-
-	# Enable arch-specific optimizations?
-	if test $without_optimizations -eq 0; then
-            ARCH_STATIC_OBJS="${ARCH_STATIC_OBJS} x86.o"
-            ARCH_SHARED_OBJS="${ARCH_SHARED_OBJS} x86.lo"
-
-            if test ${HAVE_SSE2_INTRIN} -eq 1; then
-                CFLAGS="${CFLAGS} -DX86_SSE2_FILL_WINDOW"
-                SFLAGS="${SFLAGS} -DX86_SSE2_FILL_WINDOW"
-                ARCH_STATIC_OBJS="${ARCH_STATIC_OBJS} fill_window_sse.o"
-                ARCH_SHARED_OBJS="${ARCH_SHARED_OBJS} fill_window_sse.lo"
-            fi
-
-            CFLAGS="${CFLAGS} -DX86_SSE4_2_CRC_HASH"
-            SFLAGS="${SFLAGS} -DX86_SSE4_2_CRC_HASH"
-            ARCH_STATIC_OBJS="${ARCH_STATIC_OBJS} insert_string_sse.o"
-            ARCH_SHARED_OBJS="${ARCH_SHARED_OBJS} insert_string_sse.lo"
-
-            if test ${HAVE_PCLMULQDQ_INTRIN} -eq 1; then
-                CFLAGS="${CFLAGS} -DX86_PCLMULQDQ_CRC"
-                SFLAGS="${SFLAGS} -DX86_PCLMULQDQ_CRC"
-                ARCH_STATIC_OBJS="${ARCH_STATIC_OBJS} crc_folding.o"
-                ARCH_SHARED_OBJS="${ARCH_SHARED_OBJS} crc_folding.lo"
-            fi
-
-	    # Enable deflate_quick at level 1?
-	    # requires SSE2: code uses fill_window_sse
-            if test ${HAVE_SSE2_INTRIN} -eq 1 && test $without_new_strategies -eq 0; then
-                CFLAGS="${CFLAGS} -DX86_QUICK_STRATEGY"
-                SFLAGS="${SFLAGS} -DX86_QUICK_STRATEGY"
-
-                ARCH_STATIC_OBJS="${ARCH_STATIC_OBJS} deflate_quick.o"
-                ARCH_SHARED_OBJS="${ARCH_SHARED_OBJS} deflate_quick.lo"
-            fi
-        fi
-    ;;
-
-    # ARM specific optimizations
-    armv3l | armv4b | armv4l | armv4tl | armv5tel | armv5tejl | armv6l | armv6hl | armv7l | armv7hl | armv7hnl)
-	ARCHDIR=arch/arm
-
-        case "${ARCH}" in
-            armv6l | armv6hl)
-                # Tests done on Raspberry pi (armv6hl) indicate that UNALIGNED_OK and UNROLL_LESS both
-                # provide performance improvements, totaling about 1.5% for the two.
-                CFLAGS="${CFLAGS} -DUNALIGNED_OK -DUNROLL_LESS"
-                SFLAGS="${SFLAGS} -DUNALIGNED_OK -DUNROLL_LESS"
-            ;;
-        esac
-
-    ;;
-esac
-
-echo "ARCH: ${ARCH}"
-echo "Using arch directory: ${ARCHDIR}"
-
-# show the results in the log
-echo >> configure.log
-echo ALL = $ALL >> configure.log
-echo AR = $AR >> configure.log
-echo ARFLAGS = $ARFLAGS >> configure.log
-echo CC = $CC >> configure.log
-echo CFLAGS = $CFLAGS >> configure.log
-echo EXE = $EXE >> configure.log
-echo LDCONFIG = $LDCONFIG >> configure.log
-echo LDFLAGS = $LDFLAGS >> configure.log
-echo LDSHARED = $LDSHARED >> configure.log
-echo LDSHAREDLIBC = $LDSHAREDLIBC >> configure.log
-echo DEFFILE = $DEFFILE >> configure.log
-echo RC = $RC >> configure.log
-echo RCFLAGS = $RCFLAGS >> configure.log
-echo RCOBJS = $RCOBJS >> configure.log
-echo STRIP = $STRIP >> configure.log
-echo OBJC = $OBJC >> configure.log
-echo PIC_OBJC = $PIC_OBJC >> configure.log
-echo RANLIB = $RANLIB >> configure.log
-echo SFLAGS = $SFLAGS >> configure.log
-echo SHAREDLIB = $SHAREDLIB >> configure.log
-echo SHAREDLIBM = $SHAREDLIBM >> configure.log
-echo SHAREDLIBV = $SHAREDLIBV >> configure.log
-echo SHAREDTARGET = $SHAREDTARGET >> configure.log
-echo IMPORTLIB = $IMPORTLIB >> configure.log
-echo INSTALLTARGETS = $INSTALLTARGETS >> configure.log
-echo UNINSTALLTARGETS = $UNINSTALLTARGETS >> configure.log
-echo SRCDIR = $SRCDIR >> configure.log
-echo BUILDDIR = $BUILDDIR >> configure.log
-echo STATICLIB = $STATICLIB >> configure.log
-echo TEST = $TEST >> configure.log
-echo VER = $VER >> configure.log
-echo exec_prefix = $exec_prefix >> configure.log
-echo includedir = $includedir >> configure.log
-echo bindir = $bindir >> configure.log
-echo libdir = $libdir >> configure.log
-echo mandir = $mandir >> configure.log
-echo prefix = $prefix >> configure.log
-echo sharedlibdir = $sharedlibdir >> configure.log
-echo uname = $uname >> configure.log
-echo ARCHDIR = ${ARCHDIR} >> configure.log
-echo ARCH_STATIC_OBJS = ${ARCH_STATIC_OBJS} >> configure.log
-echo ARCH_SHARED_OBJS = ${ARCH_SHARED_OBJS} >> configure.log
-
-# update Makefile with the configure results
-
-INCLUDES="-I$SRCDIR"
-if [ "$SRCDIR" != "$BUILDDIR" ]; then INCLUDES="-I$BUILDDIR ${INCLUDES}"; fi
-
-sed < $SRCDIR/Makefile.in "
-/^CC *=/s#=.*#=$CC#
-/^CFLAGS *=/s#=.*#=$CFLAGS#
-/^SFLAGS *=/s#=.*#=$SFLAGS#
-/^LDFLAGS *=/s#=.*#=$LDFLAGS#
-/^LDSHARED *=/s#=.*#=$LDSHARED#
-/^STATICLIB *=/s#=.*#=$STATICLIB#
-/^SHAREDLIB *=/s#=.*#=$SHAREDLIB#
-/^SHAREDLIBV *=/s#=.*#=$SHAREDLIBV#
-/^SHAREDLIBM *=/s#=.*#=$SHAREDLIBM#
-/^SHAREDTARGET *=/s#=.*#=$SHAREDTARGET#
-/^IMPORTLIB *=/s#=.*#=$IMPORTLIB#
-/^AR *=/s#=.*#=$AR#
-/^ARFLAGS *=/s#=.*#=$ARFLAGS#
-/^RANLIB *=/s#=.*#=$RANLIB#
-/^LDCONFIG *=/s#=.*#=$LDCONFIG#
-/^LDSHAREDLIBC *=/s#=.*#=$LDSHAREDLIBC#
-/^DEFFILE *=/s#=.*#=$DEFFILE#
-/^RC *=/s#=.*#=$RC#
-/^RCFLAGS *=/s#=.*#=$RCFLAGS#
-/^RCOBJS *=/s#=.*#=$RCOBJS#
-/^STRIP *=/s#=.*#=$STRIP#
-/^EXE *=/s#=.*#=$EXE#
-/^prefix *=/s#=.*#= $prefix#
-/^exec_prefix *=/s#=.*#= $exec_prefix#
-/^bindir *=/s#=.*#= $bindir#
-/^libdir *=/s#=.*#= $libdir#
-/^sharedlibdir *=/s#=.*#= $sharedlibdir#
-/^includedir *=/s#=.*#= $includedir#
-/^mandir *=/s#=.*#= $mandir#
-/^SRCDIR *=/s#=.*#=$SRCDIR#
-/^INCLUDES *=/s#=.*#=$INCLUDES#
-/^OBJC *=/s#=.*#= $OBJC#
-/^PIC_OBJC *=/s#=.*#= $PIC_OBJC#
-/^all: */s#:.*#: $ALL#
-/^install-libs: */s#:.*#: $INSTALLTARGETS#
-/^uninstall-libs: */s#:.*#: $UNINSTALLTARGETS#
-/^ARCHDIR *=/s#=.*#=$ARCHDIR#
-/^ARCH_STATIC_OBJS *=/s#=.*#=$ARCH_STATIC_OBJS#
-/^ARCH_SHARED_OBJS *=/s#=.*#=$ARCH_SHARED_OBJS#
-" > Makefile
-
-# Generate Makefile in arch dir
-mkdir -p $ARCHDIR
-
-ARCHINCLUDES="-I$SRCDIR/$ARCHDIR -I$SRCDIR"
-if [ "$SRCDIR" != "$BUILDDIR" ]; then ARCHINCLUDES="-I$BUILDDIR ${ARCHINCLUDES}"; fi
-
-sed < $SRCDIR/$ARCHDIR/Makefile.in "
-/^CC *=/s#=.*#=$CC#
-/^CFLAGS *=/s#=.*#=$CFLAGS#
-/^SFLAGS *=/s#=.*#=$SFLAGS#
-/^INCLUDES *=/s#=.*#=$ARCHINCLUDES#
-/^SRCDIR *=/s#=.*#=$SRCDIR/$ARCHDIR#
-/^SRCTOP *=/s#=.*#=$SRCDIR#
-" > $ARCHDIR/Makefile
-
-# Generate Makefile in test dir
-mkdir -p test
-TESTINCLUDES="-I$SRCDIR"
-if [ "$SRCDIR" != "$BUILDDIR" ]; then TESTINCLUDES="${TESTINCLUDES} -I$BUILDDIR"; fi
-if test $compat -eq 1; then COMPATTESTS="compattests"; fi
-sed < $SRCDIR/test/Makefile.in "
-/^CC *=/s#=.*#=$CC#
-/^CFLAGS *=/s#=.*#=$CFLAGS#
-/^EXE *=/s#=.*#=$EXE#
-/^oldtests: */s#:.*#: $TEST#
-/^INCLUDES *=/s#=.*#=$TESTINCLUDES#
-/^SRCDIR *=/s#=.*#=$SRCDIR/test#
-/^SRCTOP *=/s#=.*#=$SRCDIR#
-/^COMPATTESTS *=/s#=.*#=$COMPATTESTS#
-" > test/Makefile
-
-# create zlib.pc with the configure results
-sed < $SRCDIR/zlib.pc.in "
-/^CC *=/s#=.*#=$CC#
-/^CFLAGS *=/s#=.*#=$CFLAGS#
-/^LDSHARED *=/s#=.*#=$LDSHARED#
-/^STATICLIB *=/s#=.*#=$STATICLIB#
-/^SHAREDLIB *=/s#=.*#=$SHAREDLIB#
-/^SHAREDLIBV *=/s#=.*#=$SHAREDLIBV#
-/^SHAREDLIBM *=/s#=.*#=$SHAREDLIBM#
-/^IMPORTLIB *=/s#=.*#=$IMPORTLIB#
-/^AR *=/s#=.*#=$AR#
-/^ARFLAGS *=/s#=.*#=$ARFLAGS#
-/^RANLIB *=/s#=.*#=$RANLIB#
-/^EXE *=/s#=.*#=$EXE#
-/^prefix *=/s#=.*#=$prefix#
-/^exec_prefix *=/s#=.*#=$exec_prefix#
-/^bindir *=/s#=.*#=$bindir#
-/^libdir *=/s#=.*#=$libdir#
-/^sharedlibdir *=/s#=.*#=$sharedlibdir#
-/^includedir *=/s#=.*#=$includedir#
-/^mandir *=/s#=.*#=$mandir#
-/^LDFLAGS *=/s#=.*#=$LDFLAGS#
-" | sed -e "
-s/\@VERSION\@/$VER/g;
-" > zlib.pc
-
-# done
-leave 0
diff --git a/contrib/libzlib-ng/crc32.c b/contrib/libzlib-ng/crc32.c
deleted file mode 100644
index 937f48d211e..00000000000
--- a/contrib/libzlib-ng/crc32.c
+++ /dev/null
@@ -1,458 +0,0 @@
-/* crc32.c -- compute the CRC-32 of a data stream
- * Copyright (C) 1995-2006, 2010, 2011, 2012 Mark Adler
- * For conditions of distribution and use, see copyright notice in zlib.h
- *
- * Thanks to Rodney Brown <rbrown64@csc.com.au> for his contribution of faster
- * CRC methods: exclusive-oring 32 bits of data at a time, and pre-computing
- * tables for updating the shift register in one step with three exclusive-ors
- * instead of four steps with four exclusive-ors.  This results in about a
- * factor of two increase in speed on a Power PC G4 (PPC7455) using gcc -O3.
- */
-
-/* @(#) $Id$ */
-
-#ifdef __MINGW32__
-# include <sys/param.h>
-#elif defined(WIN32) || defined(_WIN32)
-# define LITTLE_ENDIAN 1234
-# define BIG_ENDIAN 4321
-# if defined(_M_IX86) || defined(_M_AMD64) || defined(_M_IA64)
-#  define BYTE_ORDER LITTLE_ENDIAN
-# else
-#  error Unknown endianness!
-# endif
-#elif __APPLE__
-# include <machine/endian.h>
-#elif defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__bsdi__) || defined(__DragonFly__)
-# include <sys/endian.h>
-#elif defined(__sun) || defined(sun)
-# include <sys/byteorder.h>
-# if !defined(LITTLE_ENDIAN)
-#  define LITTLE_ENDIAN 4321
-# endif
-# if !defined(BIG_ENDIAN)
-#  define BIG_ENDIAN 1234
-# endif
-# if !defined(BYTE_ORDER)
-#  if defined(_BIG_ENDIAN)
-#   define BYTE_ORDER BIG_ENDIAN
-#  else
-#   define BYTE_ORDER LITTLE_ENDIAN
-#  endif
-# endif
-#else
-# include <endian.h>
-#endif
-
-/*
-  Note on the use of DYNAMIC_CRC_TABLE: there is no mutex or semaphore
-  protection on the static variables used to control the first-use generation
-  of the crc tables.  Therefore, if you #define DYNAMIC_CRC_TABLE, you should
-  first call get_crc_table() to initialize the tables before allowing more than
-  one thread to use crc32().
-
-  DYNAMIC_CRC_TABLE and MAKECRCH can be #defined to write out crc32.h.
- */
-
-#ifdef MAKECRCH
-#  include <stdio.h>
-#  ifndef DYNAMIC_CRC_TABLE
-#    define DYNAMIC_CRC_TABLE
-#  endif /* !DYNAMIC_CRC_TABLE */
-#endif /* MAKECRCH */
-
-#include "deflate.h"
-
-#if BYTE_ORDER == LITTLE_ENDIAN
-static uint32_t crc32_little(uint32_t, const unsigned char *, z_off64_t);
-#elif BYTE_ORDER == BIG_ENDIAN
-static uint32_t crc32_big(uint32_t, const unsigned char *, z_off64_t);
-#endif
-
-/* Local functions for crc concatenation */
-static uint32_t gf2_matrix_times(uint32_t *mat, uint32_t vec);
-static void gf2_matrix_square(uint32_t *square, uint32_t *mat);
-static uint32_t crc32_combine_(uint32_t crc1, uint32_t crc2, z_off64_t len2);
-
-
-#ifdef DYNAMIC_CRC_TABLE
-static volatile int crc_table_empty = 1;
-static uint32_t crc_table[8][256];
-static void make_crc_table(void);
-#ifdef MAKECRCH
-static void write_table(FILE *, const uint32_t *);
-#endif /* MAKECRCH */
-/*
-  Generate tables for a byte-wise 32-bit CRC calculation on the polynomial:
-  x^32+x^26+x^23+x^22+x^16+x^12+x^11+x^10+x^8+x^7+x^5+x^4+x^2+x+1.
-
-  Polynomials over GF(2) are represented in binary, one bit per coefficient,
-  with the lowest powers in the most significant bit.  Then adding polynomials
-  is just exclusive-or, and multiplying a polynomial by x is a right shift by
-  one.  If we call the above polynomial p, and represent a byte as the
-  polynomial q, also with the lowest power in the most significant bit (so the
-  byte 0xb1 is the polynomial x^7+x^3+x+1), then the CRC is (q*x^32) mod p,
-  where a mod b means the remainder after dividing a by b.
-
-  This calculation is done using the shift-register method of multiplying and
-  taking the remainder.  The register is initialized to zero, and for each
-  incoming bit, x^32 is added mod p to the register if the bit is a one (where
-  x^32 mod p is p+x^32 = x^26+...+1), and the register is multiplied mod p by
-  x (which is shifting right by one and adding x^32 mod p if the bit shifted
-  out is a one).  We start with the highest power (least significant bit) of
-  q and repeat for all eight bits of q.
-
-  The first table is simply the CRC of all possible eight bit values.  This is
-  all the information needed to generate CRCs on data a byte at a time for all
-  combinations of CRC register values and incoming bytes.  The remaining tables
-  allow for word-at-a-time CRC calculation for both big-endian and little-
-  endian machines, where a word is four bytes.
-*/
-static void make_crc_table() {
-    uint32_t c;
-    int n, k;
-    uint32_t poly;                       /* polynomial exclusive-or pattern */
-    /* terms of polynomial defining this crc (except x^32): */
-    static volatile int first = 1;      /* flag to limit concurrent making */
-    static const unsigned char p[] = {0, 1, 2, 4, 5, 7, 8, 10, 11, 12, 16, 22, 23, 26};
-
-    /* See if another task is already doing this (not thread-safe, but better
-       than nothing -- significantly reduces duration of vulnerability in
-       case the advice about DYNAMIC_CRC_TABLE is ignored) */
-    if (first) {
-        first = 0;
-
-        /* make exclusive-or pattern from polynomial (0xedb88320) */
-        poly = 0;
-        for (n = 0; n < (int)(sizeof(p)/sizeof(unsigned char)); n++)
-            poly |= (uint32_t)1 << (31 - p[n]);
-
-        /* generate a crc for every 8-bit value */
-        for (n = 0; n < 256; n++) {
-            c = (uint32_t)n;
-            for (k = 0; k < 8; k++)
-                c = c & 1 ? poly ^ (c >> 1) : c >> 1;
-            crc_table[0][n] = c;
-        }
-
-        /* generate crc for each value followed by one, two, and three zeros,
-           and then the byte reversal of those as well as the first table */
-        for (n = 0; n < 256; n++) {
-            c = crc_table[0][n];
-            crc_table[4][n] = ZSWAP32(c);
-            for (k = 1; k < 4; k++) {
-                c = crc_table[0][c & 0xff] ^ (c >> 8);
-                crc_table[k][n] = c;
-                crc_table[k + 4][n] = ZSWAP32(c);
-            }
-        }
-
-        crc_table_empty = 0;
-    } else {      /* not first */
-        /* wait for the other guy to finish (not efficient, but rare) */
-        while (crc_table_empty)
-            {}
-    }
-
-#ifdef MAKECRCH
-    /* write out CRC tables to crc32.h */
-    {
-        FILE *out;
-
-        out = fopen("crc32.h", "w");
-        if (out == NULL) return;
-        fprintf(out, "/* crc32.h -- tables for rapid CRC calculation\n");
-        fprintf(out, " * Generated automatically by crc32.c\n */\n\n");
-        fprintf(out, "static const uint32_t ");
-        fprintf(out, "crc_table[8][256] =\n{\n  {\n");
-        write_table(out, crc_table[0]);
-        for (k = 1; k < 8; k++) {
-            fprintf(out, "  },\n  {\n");
-            write_table(out, crc_table[k]);
-        }
-        fprintf(out, "  }\n};\n");
-        fclose(out);
-    }
-#endif /* MAKECRCH */
-}
-
-#ifdef MAKECRCH
-static void write_table(FILE *out, const uint32_t *table) {
-    int n;
-
-    for (n = 0; n < 256; n++)
-        fprintf(out, "%s0x%08lx%s", n % 5 ? "" : "    ",
-                (uint32_t)(table[n]),
-                n == 255 ? "\n" : (n % 5 == 4 ? ",\n" : ", "));
-}
-#endif /* MAKECRCH */
-
-#else /* !DYNAMIC_CRC_TABLE */
-/* ========================================================================
- * Tables of CRC-32s of all single-byte values, made by make_crc_table().
- */
-#include "crc32.h"
-#endif /* DYNAMIC_CRC_TABLE */
-
-/* =========================================================================
- * This function can be used by asm versions of crc32()
- */
-const uint32_t * ZEXPORT get_crc_table(void) {
-#ifdef DYNAMIC_CRC_TABLE
-    if (crc_table_empty)
-        make_crc_table();
-#endif /* DYNAMIC_CRC_TABLE */
-    return (const uint32_t *)crc_table;
-}
-
-/* ========================================================================= */
-#define DO1 crc = crc_table[0][((int)crc ^ (*buf++)) & 0xff] ^ (crc >> 8)
-#define DO8 DO1; DO1; DO1; DO1; DO1; DO1; DO1; DO1
-#define DO4 DO1; DO1; DO1; DO1
-
-/* ========================================================================= */
-uint32_t ZEXPORT crc32(uint32_t crc, const unsigned char *buf, z_off64_t len) {
-    if (buf == Z_NULL) return 0;
-
-#ifdef DYNAMIC_CRC_TABLE
-    if (crc_table_empty)
-        make_crc_table();
-#endif /* DYNAMIC_CRC_TABLE */
-
-    if (sizeof(void *) == sizeof(ptrdiff_t)) {
-#if BYTE_ORDER == LITTLE_ENDIAN
-        return crc32_little(crc, buf, len);
-#elif BYTE_ORDER == BIG_ENDIAN
-        return crc32_big(crc, buf, len);
-#endif
-    }
-    crc = crc ^ 0xffffffff;
-
-#ifdef UNROLL_LESS
-    while (len >= 4) {
-        DO4;
-        len -= 4;
-    }
-#else
-    while (len >= 8) {
-        DO8;
-        len -= 8;
-    }
-#endif
-
-    if (len) do {
-        DO1;
-    } while (--len);
-    return crc ^ 0xffffffff;
-}
-
-
-/* ========================================================================= */
-#if BYTE_ORDER == LITTLE_ENDIAN
-#define DOLIT4 c ^= *buf4++; \
-        c = crc_table[3][c & 0xff] ^ crc_table[2][(c >> 8) & 0xff] ^ \
-            crc_table[1][(c >> 16) & 0xff] ^ crc_table[0][c >> 24]
-#define DOLIT32 DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4
-
-/* ========================================================================= */
-static uint32_t crc32_little(uint32_t crc, const unsigned char *buf, z_off64_t len) {
-    register uint32_t c;
-    register const uint32_t *buf4;
-
-    c = crc;
-    c = ~c;
-    while (len && ((ptrdiff_t)buf & 3)) {
-        c = crc_table[0][(c ^ *buf++) & 0xff] ^ (c >> 8);
-        len--;
-    }
-
-    buf4 = (const uint32_t *)(const void *)buf;
-
-#ifndef UNROLL_LESS
-    while (len >= 32) {
-        DOLIT32;
-        len -= 32;
-    }
-#endif
-
-    while (len >= 4) {
-        DOLIT4;
-        len -= 4;
-    }
-    buf = (const unsigned char *)buf4;
-
-    if (len) do {
-        c = crc_table[0][(c ^ *buf++) & 0xff] ^ (c >> 8);
-    } while (--len);
-    c = ~c;
-    return c;
-}
-#endif /* BYTE_ORDER == LITTLE_ENDIAN */
-
-/* ========================================================================= */
-#if BYTE_ORDER == BIG_ENDIAN
-#define DOBIG4 c ^= *++buf4; \
-        c = crc_table[4][c & 0xff] ^ crc_table[5][(c >> 8) & 0xff] ^ \
-            crc_table[6][(c >> 16) & 0xff] ^ crc_table[7][c >> 24]
-#define DOBIG32 DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4
-
-/* ========================================================================= */
-static uint32_t crc32_big(uint32_t crc, const unsigned char *buf, z_off64_t len) {
-    register uint32_t c;
-    register const uint32_t *buf4;
-
-    c = ZSWAP32(crc);
-    c = ~c;
-    while (len && ((ptrdiff_t)buf & 3)) {
-        c = crc_table[4][(c >> 24) ^ *buf++] ^ (c << 8);
-        len--;
-    }
-
-    buf4 = (const uint32_t *)(const void *)buf;
-    buf4--;
-
-#ifndef UNROLL_LESS
-    while (len >= 32) {
-        DOBIG32;
-        len -= 32;
-    }
-#endif
-
-    while (len >= 4) {
-        DOBIG4;
-        len -= 4;
-    }
-    buf4++;
-    buf = (const unsigned char *)buf4;
-
-    if (len) do {
-        c = crc_table[4][(c >> 24) ^ *buf++] ^ (c << 8);
-    } while (--len);
-    c = ~c;
-    return ZSWAP32(c);
-}
-#endif /* BYTE_ORDER == BIG_ENDIAN */
-
-
-#define GF2_DIM 32      /* dimension of GF(2) vectors (length of CRC) */
-
-/* ========================================================================= */
-static uint32_t gf2_matrix_times(uint32_t *mat, uint32_t vec) {
-    uint32_t sum;
-
-    sum = 0;
-    while (vec) {
-        if (vec & 1)
-            sum ^= *mat;
-        vec >>= 1;
-        mat++;
-    }
-    return sum;
-}
-
-/* ========================================================================= */
-static void gf2_matrix_square(uint32_t *square, uint32_t *mat) {
-    int n;
-
-    for (n = 0; n < GF2_DIM; n++)
-        square[n] = gf2_matrix_times(mat, mat[n]);
-}
-
-/* ========================================================================= */
-static uint32_t crc32_combine_(uint32_t crc1, uint32_t crc2, z_off64_t len2) {
-    int n;
-    uint32_t row;
-    uint32_t even[GF2_DIM];    /* even-power-of-two zeros operator */
-    uint32_t odd[GF2_DIM];     /* odd-power-of-two zeros operator */
-
-    /* degenerate case (also disallow negative lengths) */
-    if (len2 <= 0)
-        return crc1;
-
-    /* put operator for one zero bit in odd */
-    odd[0] = 0xedb88320;          /* CRC-32 polynomial */
-    row = 1;
-    for (n = 1; n < GF2_DIM; n++) {
-        odd[n] = row;
-        row <<= 1;
-    }
-
-    /* put operator for two zero bits in even */
-    gf2_matrix_square(even, odd);
-
-    /* put operator for four zero bits in odd */
-    gf2_matrix_square(odd, even);
-
-    /* apply len2 zeros to crc1 (first square will put the operator for one
-       zero byte, eight zero bits, in even) */
-    do {
-        /* apply zeros operator for this bit of len2 */
-        gf2_matrix_square(even, odd);
-        if (len2 & 1)
-            crc1 = gf2_matrix_times(even, crc1);
-        len2 >>= 1;
-
-        /* if no more bits set, then done */
-        if (len2 == 0)
-            break;
-
-        /* another iteration of the loop with odd and even swapped */
-        gf2_matrix_square(odd, even);
-        if (len2 & 1)
-            crc1 = gf2_matrix_times(odd, crc1);
-        len2 >>= 1;
-
-        /* if no more bits set, then done */
-    } while (len2 != 0);
-
-    /* return combined crc */
-    crc1 ^= crc2;
-    return crc1;
-}
-
-/* ========================================================================= */
-uint32_t ZEXPORT crc32_combine(uint32_t crc1, uint32_t crc2, z_off_t len2) {
-    return crc32_combine_(crc1, crc2, len2);
-}
-
-uint32_t ZEXPORT crc32_combine64(uint32_t crc1, uint32_t crc2, z_off64_t len2) {
-    return crc32_combine_(crc1, crc2, len2);
-}
-
-
-#ifdef X86_PCLMULQDQ_CRC
-#include "arch/x86/x86.h"
-extern void ZLIB_INTERNAL crc_fold_init(deflate_state *const s);
-extern void ZLIB_INTERNAL crc_fold_copy(deflate_state *const s,
-    unsigned char *dst, const unsigned char *src, long len);
-extern uint32_t ZLIB_INTERNAL crc_fold_512to32(deflate_state *const s);
-#endif
-
-ZLIB_INTERNAL void crc_reset(deflate_state *const s) {
-#ifdef X86_PCLMULQDQ_CRC
-    if (x86_cpu_has_pclmulqdq) {
-        crc_fold_init(s);
-        return;
-    }
-#endif
-    s->strm->adler = crc32(0L, Z_NULL, 0);
-}
-
-ZLIB_INTERNAL void crc_finalize(deflate_state *const s) {
-#ifdef X86_PCLMULQDQ_CRC
-    if (x86_cpu_has_pclmulqdq)
-        s->strm->adler = crc_fold_512to32(s);
-#endif
-}
-
-ZLIB_INTERNAL void copy_with_crc(z_stream *strm, unsigned char *dst, long size) {
-#ifdef X86_PCLMULQDQ_CRC
-    if (x86_cpu_has_pclmulqdq) {
-        crc_fold_copy(strm->state, dst, strm->next_in, size);
-        return;
-    }
-#endif
-    memcpy(dst, strm->next_in, size);
-    strm->adler = crc32(strm->adler, dst, size);
-}
-
diff --git a/contrib/libzlib-ng/crc32.h b/contrib/libzlib-ng/crc32.h
deleted file mode 100644
index d194d10b5ea..00000000000
--- a/contrib/libzlib-ng/crc32.h
+++ /dev/null
@@ -1,444 +0,0 @@
-#ifndef CRC32_H_
-#define CRC32_H_
-
-/* crc32.h -- tables for rapid CRC calculation
- * Generated automatically by crc32.c
- */
-
-static const uint32_t crc_table[8][256] =
-{
-  {
-    0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419,
-    0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4,
-    0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07,
-    0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
-    0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856,
-    0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
-    0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4,
-    0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
-    0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3,
-    0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a,
-    0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599,
-    0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
-    0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190,
-    0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f,
-    0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e,
-    0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
-    0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed,
-    0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
-    0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3,
-    0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
-    0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a,
-    0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5,
-    0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010,
-    0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
-    0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17,
-    0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6,
-    0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615,
-    0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
-    0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344,
-    0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
-    0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a,
-    0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
-    0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1,
-    0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c,
-    0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef,
-    0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
-    0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe,
-    0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31,
-    0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c,
-    0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
-    0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b,
-    0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
-    0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1,
-    0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
-    0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278,
-    0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7,
-    0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66,
-    0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
-    0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605,
-    0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8,
-    0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b,
-    0x2d02ef8d
-  },
-  {
-    0x00000000, 0x191b3141, 0x32366282, 0x2b2d53c3, 0x646cc504,
-    0x7d77f445, 0x565aa786, 0x4f4196c7, 0xc8d98a08, 0xd1c2bb49,
-    0xfaefe88a, 0xe3f4d9cb, 0xacb54f0c, 0xb5ae7e4d, 0x9e832d8e,
-    0x87981ccf, 0x4ac21251, 0x53d92310, 0x78f470d3, 0x61ef4192,
-    0x2eaed755, 0x37b5e614, 0x1c98b5d7, 0x05838496, 0x821b9859,
-    0x9b00a918, 0xb02dfadb, 0xa936cb9a, 0xe6775d5d, 0xff6c6c1c,
-    0xd4413fdf, 0xcd5a0e9e, 0x958424a2, 0x8c9f15e3, 0xa7b24620,
-    0xbea97761, 0xf1e8e1a6, 0xe8f3d0e7, 0xc3de8324, 0xdac5b265,
-    0x5d5daeaa, 0x44469feb, 0x6f6bcc28, 0x7670fd69, 0x39316bae,
-    0x202a5aef, 0x0b07092c, 0x121c386d, 0xdf4636f3, 0xc65d07b2,
-    0xed705471, 0xf46b6530, 0xbb2af3f7, 0xa231c2b6, 0x891c9175,
-    0x9007a034, 0x179fbcfb, 0x0e848dba, 0x25a9de79, 0x3cb2ef38,
-    0x73f379ff, 0x6ae848be, 0x41c51b7d, 0x58de2a3c, 0xf0794f05,
-    0xe9627e44, 0xc24f2d87, 0xdb541cc6, 0x94158a01, 0x8d0ebb40,
-    0xa623e883, 0xbf38d9c2, 0x38a0c50d, 0x21bbf44c, 0x0a96a78f,
-    0x138d96ce, 0x5ccc0009, 0x45d73148, 0x6efa628b, 0x77e153ca,
-    0xbabb5d54, 0xa3a06c15, 0x888d3fd6, 0x91960e97, 0xded79850,
-    0xc7cca911, 0xece1fad2, 0xf5facb93, 0x7262d75c, 0x6b79e61d,
-    0x4054b5de, 0x594f849f, 0x160e1258, 0x0f152319, 0x243870da,
-    0x3d23419b, 0x65fd6ba7, 0x7ce65ae6, 0x57cb0925, 0x4ed03864,
-    0x0191aea3, 0x188a9fe2, 0x33a7cc21, 0x2abcfd60, 0xad24e1af,
-    0xb43fd0ee, 0x9f12832d, 0x8609b26c, 0xc94824ab, 0xd05315ea,
-    0xfb7e4629, 0xe2657768, 0x2f3f79f6, 0x362448b7, 0x1d091b74,
-    0x04122a35, 0x4b53bcf2, 0x52488db3, 0x7965de70, 0x607eef31,
-    0xe7e6f3fe, 0xfefdc2bf, 0xd5d0917c, 0xcccba03d, 0x838a36fa,
-    0x9a9107bb, 0xb1bc5478, 0xa8a76539, 0x3b83984b, 0x2298a90a,
-    0x09b5fac9, 0x10aecb88, 0x5fef5d4f, 0x46f46c0e, 0x6dd93fcd,
-    0x74c20e8c, 0xf35a1243, 0xea412302, 0xc16c70c1, 0xd8774180,
-    0x9736d747, 0x8e2de606, 0xa500b5c5, 0xbc1b8484, 0x71418a1a,
-    0x685abb5b, 0x4377e898, 0x5a6cd9d9, 0x152d4f1e, 0x0c367e5f,
-    0x271b2d9c, 0x3e001cdd, 0xb9980012, 0xa0833153, 0x8bae6290,
-    0x92b553d1, 0xddf4c516, 0xc4eff457, 0xefc2a794, 0xf6d996d5,
-    0xae07bce9, 0xb71c8da8, 0x9c31de6b, 0x852aef2a, 0xca6b79ed,
-    0xd37048ac, 0xf85d1b6f, 0xe1462a2e, 0x66de36e1, 0x7fc507a0,
-    0x54e85463, 0x4df36522, 0x02b2f3e5, 0x1ba9c2a4, 0x30849167,
-    0x299fa026, 0xe4c5aeb8, 0xfdde9ff9, 0xd6f3cc3a, 0xcfe8fd7b,
-    0x80a96bbc, 0x99b25afd, 0xb29f093e, 0xab84387f, 0x2c1c24b0,
-    0x350715f1, 0x1e2a4632, 0x07317773, 0x4870e1b4, 0x516bd0f5,
-    0x7a468336, 0x635db277, 0xcbfad74e, 0xd2e1e60f, 0xf9ccb5cc,
-    0xe0d7848d, 0xaf96124a, 0xb68d230b, 0x9da070c8, 0x84bb4189,
-    0x03235d46, 0x1a386c07, 0x31153fc4, 0x280e0e85, 0x674f9842,
-    0x7e54a903, 0x5579fac0, 0x4c62cb81, 0x8138c51f, 0x9823f45e,
-    0xb30ea79d, 0xaa1596dc, 0xe554001b, 0xfc4f315a, 0xd7626299,
-    0xce7953d8, 0x49e14f17, 0x50fa7e56, 0x7bd72d95, 0x62cc1cd4,
-    0x2d8d8a13, 0x3496bb52, 0x1fbbe891, 0x06a0d9d0, 0x5e7ef3ec,
-    0x4765c2ad, 0x6c48916e, 0x7553a02f, 0x3a1236e8, 0x230907a9,
-    0x0824546a, 0x113f652b, 0x96a779e4, 0x8fbc48a5, 0xa4911b66,
-    0xbd8a2a27, 0xf2cbbce0, 0xebd08da1, 0xc0fdde62, 0xd9e6ef23,
-    0x14bce1bd, 0x0da7d0fc, 0x268a833f, 0x3f91b27e, 0x70d024b9,
-    0x69cb15f8, 0x42e6463b, 0x5bfd777a, 0xdc656bb5, 0xc57e5af4,
-    0xee530937, 0xf7483876, 0xb809aeb1, 0xa1129ff0, 0x8a3fcc33,
-    0x9324fd72
-  },
-  {
-    0x00000000, 0x01c26a37, 0x0384d46e, 0x0246be59, 0x0709a8dc,
-    0x06cbc2eb, 0x048d7cb2, 0x054f1685, 0x0e1351b8, 0x0fd13b8f,
-    0x0d9785d6, 0x0c55efe1, 0x091af964, 0x08d89353, 0x0a9e2d0a,
-    0x0b5c473d, 0x1c26a370, 0x1de4c947, 0x1fa2771e, 0x1e601d29,
-    0x1b2f0bac, 0x1aed619b, 0x18abdfc2, 0x1969b5f5, 0x1235f2c8,
-    0x13f798ff, 0x11b126a6, 0x10734c91, 0x153c5a14, 0x14fe3023,
-    0x16b88e7a, 0x177ae44d, 0x384d46e0, 0x398f2cd7, 0x3bc9928e,
-    0x3a0bf8b9, 0x3f44ee3c, 0x3e86840b, 0x3cc03a52, 0x3d025065,
-    0x365e1758, 0x379c7d6f, 0x35dac336, 0x3418a901, 0x3157bf84,
-    0x3095d5b3, 0x32d36bea, 0x331101dd, 0x246be590, 0x25a98fa7,
-    0x27ef31fe, 0x262d5bc9, 0x23624d4c, 0x22a0277b, 0x20e69922,
-    0x2124f315, 0x2a78b428, 0x2bbade1f, 0x29fc6046, 0x283e0a71,
-    0x2d711cf4, 0x2cb376c3, 0x2ef5c89a, 0x2f37a2ad, 0x709a8dc0,
-    0x7158e7f7, 0x731e59ae, 0x72dc3399, 0x7793251c, 0x76514f2b,
-    0x7417f172, 0x75d59b45, 0x7e89dc78, 0x7f4bb64f, 0x7d0d0816,
-    0x7ccf6221, 0x798074a4, 0x78421e93, 0x7a04a0ca, 0x7bc6cafd,
-    0x6cbc2eb0, 0x6d7e4487, 0x6f38fade, 0x6efa90e9, 0x6bb5866c,
-    0x6a77ec5b, 0x68315202, 0x69f33835, 0x62af7f08, 0x636d153f,
-    0x612bab66, 0x60e9c151, 0x65a6d7d4, 0x6464bde3, 0x662203ba,
-    0x67e0698d, 0x48d7cb20, 0x4915a117, 0x4b531f4e, 0x4a917579,
-    0x4fde63fc, 0x4e1c09cb, 0x4c5ab792, 0x4d98dda5, 0x46c49a98,
-    0x4706f0af, 0x45404ef6, 0x448224c1, 0x41cd3244, 0x400f5873,
-    0x4249e62a, 0x438b8c1d, 0x54f16850, 0x55330267, 0x5775bc3e,
-    0x56b7d609, 0x53f8c08c, 0x523aaabb, 0x507c14e2, 0x51be7ed5,
-    0x5ae239e8, 0x5b2053df, 0x5966ed86, 0x58a487b1, 0x5deb9134,
-    0x5c29fb03, 0x5e6f455a, 0x5fad2f6d, 0xe1351b80, 0xe0f771b7,
-    0xe2b1cfee, 0xe373a5d9, 0xe63cb35c, 0xe7fed96b, 0xe5b86732,
-    0xe47a0d05, 0xef264a38, 0xeee4200f, 0xeca29e56, 0xed60f461,
-    0xe82fe2e4, 0xe9ed88d3, 0xebab368a, 0xea695cbd, 0xfd13b8f0,
-    0xfcd1d2c7, 0xfe976c9e, 0xff5506a9, 0xfa1a102c, 0xfbd87a1b,
-    0xf99ec442, 0xf85cae75, 0xf300e948, 0xf2c2837f, 0xf0843d26,
-    0xf1465711, 0xf4094194, 0xf5cb2ba3, 0xf78d95fa, 0xf64fffcd,
-    0xd9785d60, 0xd8ba3757, 0xdafc890e, 0xdb3ee339, 0xde71f5bc,
-    0xdfb39f8b, 0xddf521d2, 0xdc374be5, 0xd76b0cd8, 0xd6a966ef,
-    0xd4efd8b6, 0xd52db281, 0xd062a404, 0xd1a0ce33, 0xd3e6706a,
-    0xd2241a5d, 0xc55efe10, 0xc49c9427, 0xc6da2a7e, 0xc7184049,
-    0xc25756cc, 0xc3953cfb, 0xc1d382a2, 0xc011e895, 0xcb4dafa8,
-    0xca8fc59f, 0xc8c97bc6, 0xc90b11f1, 0xcc440774, 0xcd866d43,
-    0xcfc0d31a, 0xce02b92d, 0x91af9640, 0x906dfc77, 0x922b422e,
-    0x93e92819, 0x96a63e9c, 0x976454ab, 0x9522eaf2, 0x94e080c5,
-    0x9fbcc7f8, 0x9e7eadcf, 0x9c381396, 0x9dfa79a1, 0x98b56f24,
-    0x99770513, 0x9b31bb4a, 0x9af3d17d, 0x8d893530, 0x8c4b5f07,
-    0x8e0de15e, 0x8fcf8b69, 0x8a809dec, 0x8b42f7db, 0x89044982,
-    0x88c623b5, 0x839a6488, 0x82580ebf, 0x801eb0e6, 0x81dcdad1,
-    0x8493cc54, 0x8551a663, 0x8717183a, 0x86d5720d, 0xa9e2d0a0,
-    0xa820ba97, 0xaa6604ce, 0xaba46ef9, 0xaeeb787c, 0xaf29124b,
-    0xad6fac12, 0xacadc625, 0xa7f18118, 0xa633eb2f, 0xa4755576,
-    0xa5b73f41, 0xa0f829c4, 0xa13a43f3, 0xa37cfdaa, 0xa2be979d,
-    0xb5c473d0, 0xb40619e7, 0xb640a7be, 0xb782cd89, 0xb2cddb0c,
-    0xb30fb13b, 0xb1490f62, 0xb08b6555, 0xbbd72268, 0xba15485f,
-    0xb853f606, 0xb9919c31, 0xbcde8ab4, 0xbd1ce083, 0xbf5a5eda,
-    0xbe9834ed
-  },
-  {
-    0x00000000, 0xb8bc6765, 0xaa09c88b, 0x12b5afee, 0x8f629757,
-    0x37def032, 0x256b5fdc, 0x9dd738b9, 0xc5b428ef, 0x7d084f8a,
-    0x6fbde064, 0xd7018701, 0x4ad6bfb8, 0xf26ad8dd, 0xe0df7733,
-    0x58631056, 0x5019579f, 0xe8a530fa, 0xfa109f14, 0x42acf871,
-    0xdf7bc0c8, 0x67c7a7ad, 0x75720843, 0xcdce6f26, 0x95ad7f70,
-    0x2d111815, 0x3fa4b7fb, 0x8718d09e, 0x1acfe827, 0xa2738f42,
-    0xb0c620ac, 0x087a47c9, 0xa032af3e, 0x188ec85b, 0x0a3b67b5,
-    0xb28700d0, 0x2f503869, 0x97ec5f0c, 0x8559f0e2, 0x3de59787,
-    0x658687d1, 0xdd3ae0b4, 0xcf8f4f5a, 0x7733283f, 0xeae41086,
-    0x525877e3, 0x40edd80d, 0xf851bf68, 0xf02bf8a1, 0x48979fc4,
-    0x5a22302a, 0xe29e574f, 0x7f496ff6, 0xc7f50893, 0xd540a77d,
-    0x6dfcc018, 0x359fd04e, 0x8d23b72b, 0x9f9618c5, 0x272a7fa0,
-    0xbafd4719, 0x0241207c, 0x10f48f92, 0xa848e8f7, 0x9b14583d,
-    0x23a83f58, 0x311d90b6, 0x89a1f7d3, 0x1476cf6a, 0xaccaa80f,
-    0xbe7f07e1, 0x06c36084, 0x5ea070d2, 0xe61c17b7, 0xf4a9b859,
-    0x4c15df3c, 0xd1c2e785, 0x697e80e0, 0x7bcb2f0e, 0xc377486b,
-    0xcb0d0fa2, 0x73b168c7, 0x6104c729, 0xd9b8a04c, 0x446f98f5,
-    0xfcd3ff90, 0xee66507e, 0x56da371b, 0x0eb9274d, 0xb6054028,
-    0xa4b0efc6, 0x1c0c88a3, 0x81dbb01a, 0x3967d77f, 0x2bd27891,
-    0x936e1ff4, 0x3b26f703, 0x839a9066, 0x912f3f88, 0x299358ed,
-    0xb4446054, 0x0cf80731, 0x1e4da8df, 0xa6f1cfba, 0xfe92dfec,
-    0x462eb889, 0x549b1767, 0xec277002, 0x71f048bb, 0xc94c2fde,
-    0xdbf98030, 0x6345e755, 0x6b3fa09c, 0xd383c7f9, 0xc1366817,
-    0x798a0f72, 0xe45d37cb, 0x5ce150ae, 0x4e54ff40, 0xf6e89825,
-    0xae8b8873, 0x1637ef16, 0x048240f8, 0xbc3e279d, 0x21e91f24,
-    0x99557841, 0x8be0d7af, 0x335cb0ca, 0xed59b63b, 0x55e5d15e,
-    0x47507eb0, 0xffec19d5, 0x623b216c, 0xda874609, 0xc832e9e7,
-    0x708e8e82, 0x28ed9ed4, 0x9051f9b1, 0x82e4565f, 0x3a58313a,
-    0xa78f0983, 0x1f336ee6, 0x0d86c108, 0xb53aa66d, 0xbd40e1a4,
-    0x05fc86c1, 0x1749292f, 0xaff54e4a, 0x322276f3, 0x8a9e1196,
-    0x982bbe78, 0x2097d91d, 0x78f4c94b, 0xc048ae2e, 0xd2fd01c0,
-    0x6a4166a5, 0xf7965e1c, 0x4f2a3979, 0x5d9f9697, 0xe523f1f2,
-    0x4d6b1905, 0xf5d77e60, 0xe762d18e, 0x5fdeb6eb, 0xc2098e52,
-    0x7ab5e937, 0x680046d9, 0xd0bc21bc, 0x88df31ea, 0x3063568f,
-    0x22d6f961, 0x9a6a9e04, 0x07bda6bd, 0xbf01c1d8, 0xadb46e36,
-    0x15080953, 0x1d724e9a, 0xa5ce29ff, 0xb77b8611, 0x0fc7e174,
-    0x9210d9cd, 0x2aacbea8, 0x38191146, 0x80a57623, 0xd8c66675,
-    0x607a0110, 0x72cfaefe, 0xca73c99b, 0x57a4f122, 0xef189647,
-    0xfdad39a9, 0x45115ecc, 0x764dee06, 0xcef18963, 0xdc44268d,
-    0x64f841e8, 0xf92f7951, 0x41931e34, 0x5326b1da, 0xeb9ad6bf,
-    0xb3f9c6e9, 0x0b45a18c, 0x19f00e62, 0xa14c6907, 0x3c9b51be,
-    0x842736db, 0x96929935, 0x2e2efe50, 0x2654b999, 0x9ee8defc,
-    0x8c5d7112, 0x34e11677, 0xa9362ece, 0x118a49ab, 0x033fe645,
-    0xbb838120, 0xe3e09176, 0x5b5cf613, 0x49e959fd, 0xf1553e98,
-    0x6c820621, 0xd43e6144, 0xc68bceaa, 0x7e37a9cf, 0xd67f4138,
-    0x6ec3265d, 0x7c7689b3, 0xc4caeed6, 0x591dd66f, 0xe1a1b10a,
-    0xf3141ee4, 0x4ba87981, 0x13cb69d7, 0xab770eb2, 0xb9c2a15c,
-    0x017ec639, 0x9ca9fe80, 0x241599e5, 0x36a0360b, 0x8e1c516e,
-    0x866616a7, 0x3eda71c2, 0x2c6fde2c, 0x94d3b949, 0x090481f0,
-    0xb1b8e695, 0xa30d497b, 0x1bb12e1e, 0x43d23e48, 0xfb6e592d,
-    0xe9dbf6c3, 0x516791a6, 0xccb0a91f, 0x740cce7a, 0x66b96194,
-    0xde0506f1
-  },
-  {
-    0x00000000, 0x96300777, 0x2c610eee, 0xba510999, 0x19c46d07,
-    0x8ff46a70, 0x35a563e9, 0xa395649e, 0x3288db0e, 0xa4b8dc79,
-    0x1ee9d5e0, 0x88d9d297, 0x2b4cb609, 0xbd7cb17e, 0x072db8e7,
-    0x911dbf90, 0x6410b71d, 0xf220b06a, 0x4871b9f3, 0xde41be84,
-    0x7dd4da1a, 0xebe4dd6d, 0x51b5d4f4, 0xc785d383, 0x56986c13,
-    0xc0a86b64, 0x7af962fd, 0xecc9658a, 0x4f5c0114, 0xd96c0663,
-    0x633d0ffa, 0xf50d088d, 0xc8206e3b, 0x5e10694c, 0xe44160d5,
-    0x727167a2, 0xd1e4033c, 0x47d4044b, 0xfd850dd2, 0x6bb50aa5,
-    0xfaa8b535, 0x6c98b242, 0xd6c9bbdb, 0x40f9bcac, 0xe36cd832,
-    0x755cdf45, 0xcf0dd6dc, 0x593dd1ab, 0xac30d926, 0x3a00de51,
-    0x8051d7c8, 0x1661d0bf, 0xb5f4b421, 0x23c4b356, 0x9995bacf,
-    0x0fa5bdb8, 0x9eb80228, 0x0888055f, 0xb2d90cc6, 0x24e90bb1,
-    0x877c6f2f, 0x114c6858, 0xab1d61c1, 0x3d2d66b6, 0x9041dc76,
-    0x0671db01, 0xbc20d298, 0x2a10d5ef, 0x8985b171, 0x1fb5b606,
-    0xa5e4bf9f, 0x33d4b8e8, 0xa2c90778, 0x34f9000f, 0x8ea80996,
-    0x18980ee1, 0xbb0d6a7f, 0x2d3d6d08, 0x976c6491, 0x015c63e6,
-    0xf4516b6b, 0x62616c1c, 0xd8306585, 0x4e0062f2, 0xed95066c,
-    0x7ba5011b, 0xc1f40882, 0x57c40ff5, 0xc6d9b065, 0x50e9b712,
-    0xeab8be8b, 0x7c88b9fc, 0xdf1ddd62, 0x492dda15, 0xf37cd38c,
-    0x654cd4fb, 0x5861b24d, 0xce51b53a, 0x7400bca3, 0xe230bbd4,
-    0x41a5df4a, 0xd795d83d, 0x6dc4d1a4, 0xfbf4d6d3, 0x6ae96943,
-    0xfcd96e34, 0x468867ad, 0xd0b860da, 0x732d0444, 0xe51d0333,
-    0x5f4c0aaa, 0xc97c0ddd, 0x3c710550, 0xaa410227, 0x10100bbe,
-    0x86200cc9, 0x25b56857, 0xb3856f20, 0x09d466b9, 0x9fe461ce,
-    0x0ef9de5e, 0x98c9d929, 0x2298d0b0, 0xb4a8d7c7, 0x173db359,
-    0x810db42e, 0x3b5cbdb7, 0xad6cbac0, 0x2083b8ed, 0xb6b3bf9a,
-    0x0ce2b603, 0x9ad2b174, 0x3947d5ea, 0xaf77d29d, 0x1526db04,
-    0x8316dc73, 0x120b63e3, 0x843b6494, 0x3e6a6d0d, 0xa85a6a7a,
-    0x0bcf0ee4, 0x9dff0993, 0x27ae000a, 0xb19e077d, 0x44930ff0,
-    0xd2a30887, 0x68f2011e, 0xfec20669, 0x5d5762f7, 0xcb676580,
-    0x71366c19, 0xe7066b6e, 0x761bd4fe, 0xe02bd389, 0x5a7ada10,
-    0xcc4add67, 0x6fdfb9f9, 0xf9efbe8e, 0x43beb717, 0xd58eb060,
-    0xe8a3d6d6, 0x7e93d1a1, 0xc4c2d838, 0x52f2df4f, 0xf167bbd1,
-    0x6757bca6, 0xdd06b53f, 0x4b36b248, 0xda2b0dd8, 0x4c1b0aaf,
-    0xf64a0336, 0x607a0441, 0xc3ef60df, 0x55df67a8, 0xef8e6e31,
-    0x79be6946, 0x8cb361cb, 0x1a8366bc, 0xa0d26f25, 0x36e26852,
-    0x95770ccc, 0x03470bbb, 0xb9160222, 0x2f260555, 0xbe3bbac5,
-    0x280bbdb2, 0x925ab42b, 0x046ab35c, 0xa7ffd7c2, 0x31cfd0b5,
-    0x8b9ed92c, 0x1daede5b, 0xb0c2649b, 0x26f263ec, 0x9ca36a75,
-    0x0a936d02, 0xa906099c, 0x3f360eeb, 0x85670772, 0x13570005,
-    0x824abf95, 0x147ab8e2, 0xae2bb17b, 0x381bb60c, 0x9b8ed292,
-    0x0dbed5e5, 0xb7efdc7c, 0x21dfdb0b, 0xd4d2d386, 0x42e2d4f1,
-    0xf8b3dd68, 0x6e83da1f, 0xcd16be81, 0x5b26b9f6, 0xe177b06f,
-    0x7747b718, 0xe65a0888, 0x706a0fff, 0xca3b0666, 0x5c0b0111,
-    0xff9e658f, 0x69ae62f8, 0xd3ff6b61, 0x45cf6c16, 0x78e20aa0,
-    0xeed20dd7, 0x5483044e, 0xc2b30339, 0x612667a7, 0xf71660d0,
-    0x4d476949, 0xdb776e3e, 0x4a6ad1ae, 0xdc5ad6d9, 0x660bdf40,
-    0xf03bd837, 0x53aebca9, 0xc59ebbde, 0x7fcfb247, 0xe9ffb530,
-    0x1cf2bdbd, 0x8ac2baca, 0x3093b353, 0xa6a3b424, 0x0536d0ba,
-    0x9306d7cd, 0x2957de54, 0xbf67d923, 0x2e7a66b3, 0xb84a61c4,
-    0x021b685d, 0x942b6f2a, 0x37be0bb4, 0xa18e0cc3, 0x1bdf055a,
-    0x8def022d
-  },
-  {
-    0x00000000, 0x41311b19, 0x82623632, 0xc3532d2b, 0x04c56c64,
-    0x45f4777d, 0x86a75a56, 0xc796414f, 0x088ad9c8, 0x49bbc2d1,
-    0x8ae8effa, 0xcbd9f4e3, 0x0c4fb5ac, 0x4d7eaeb5, 0x8e2d839e,
-    0xcf1c9887, 0x5112c24a, 0x1023d953, 0xd370f478, 0x9241ef61,
-    0x55d7ae2e, 0x14e6b537, 0xd7b5981c, 0x96848305, 0x59981b82,
-    0x18a9009b, 0xdbfa2db0, 0x9acb36a9, 0x5d5d77e6, 0x1c6c6cff,
-    0xdf3f41d4, 0x9e0e5acd, 0xa2248495, 0xe3159f8c, 0x2046b2a7,
-    0x6177a9be, 0xa6e1e8f1, 0xe7d0f3e8, 0x2483dec3, 0x65b2c5da,
-    0xaaae5d5d, 0xeb9f4644, 0x28cc6b6f, 0x69fd7076, 0xae6b3139,
-    0xef5a2a20, 0x2c09070b, 0x6d381c12, 0xf33646df, 0xb2075dc6,
-    0x715470ed, 0x30656bf4, 0xf7f32abb, 0xb6c231a2, 0x75911c89,
-    0x34a00790, 0xfbbc9f17, 0xba8d840e, 0x79dea925, 0x38efb23c,
-    0xff79f373, 0xbe48e86a, 0x7d1bc541, 0x3c2ade58, 0x054f79f0,
-    0x447e62e9, 0x872d4fc2, 0xc61c54db, 0x018a1594, 0x40bb0e8d,
-    0x83e823a6, 0xc2d938bf, 0x0dc5a038, 0x4cf4bb21, 0x8fa7960a,
-    0xce968d13, 0x0900cc5c, 0x4831d745, 0x8b62fa6e, 0xca53e177,
-    0x545dbbba, 0x156ca0a3, 0xd63f8d88, 0x970e9691, 0x5098d7de,
-    0x11a9ccc7, 0xd2fae1ec, 0x93cbfaf5, 0x5cd76272, 0x1de6796b,
-    0xdeb55440, 0x9f844f59, 0x58120e16, 0x1923150f, 0xda703824,
-    0x9b41233d, 0xa76bfd65, 0xe65ae67c, 0x2509cb57, 0x6438d04e,
-    0xa3ae9101, 0xe29f8a18, 0x21cca733, 0x60fdbc2a, 0xafe124ad,
-    0xeed03fb4, 0x2d83129f, 0x6cb20986, 0xab2448c9, 0xea1553d0,
-    0x29467efb, 0x687765e2, 0xf6793f2f, 0xb7482436, 0x741b091d,
-    0x352a1204, 0xf2bc534b, 0xb38d4852, 0x70de6579, 0x31ef7e60,
-    0xfef3e6e7, 0xbfc2fdfe, 0x7c91d0d5, 0x3da0cbcc, 0xfa368a83,
-    0xbb07919a, 0x7854bcb1, 0x3965a7a8, 0x4b98833b, 0x0aa99822,
-    0xc9fab509, 0x88cbae10, 0x4f5def5f, 0x0e6cf446, 0xcd3fd96d,
-    0x8c0ec274, 0x43125af3, 0x022341ea, 0xc1706cc1, 0x804177d8,
-    0x47d73697, 0x06e62d8e, 0xc5b500a5, 0x84841bbc, 0x1a8a4171,
-    0x5bbb5a68, 0x98e87743, 0xd9d96c5a, 0x1e4f2d15, 0x5f7e360c,
-    0x9c2d1b27, 0xdd1c003e, 0x120098b9, 0x533183a0, 0x9062ae8b,
-    0xd153b592, 0x16c5f4dd, 0x57f4efc4, 0x94a7c2ef, 0xd596d9f6,
-    0xe9bc07ae, 0xa88d1cb7, 0x6bde319c, 0x2aef2a85, 0xed796bca,
-    0xac4870d3, 0x6f1b5df8, 0x2e2a46e1, 0xe136de66, 0xa007c57f,
-    0x6354e854, 0x2265f34d, 0xe5f3b202, 0xa4c2a91b, 0x67918430,
-    0x26a09f29, 0xb8aec5e4, 0xf99fdefd, 0x3accf3d6, 0x7bfde8cf,
-    0xbc6ba980, 0xfd5ab299, 0x3e099fb2, 0x7f3884ab, 0xb0241c2c,
-    0xf1150735, 0x32462a1e, 0x73773107, 0xb4e17048, 0xf5d06b51,
-    0x3683467a, 0x77b25d63, 0x4ed7facb, 0x0fe6e1d2, 0xccb5ccf9,
-    0x8d84d7e0, 0x4a1296af, 0x0b238db6, 0xc870a09d, 0x8941bb84,
-    0x465d2303, 0x076c381a, 0xc43f1531, 0x850e0e28, 0x42984f67,
-    0x03a9547e, 0xc0fa7955, 0x81cb624c, 0x1fc53881, 0x5ef42398,
-    0x9da70eb3, 0xdc9615aa, 0x1b0054e5, 0x5a314ffc, 0x996262d7,
-    0xd85379ce, 0x174fe149, 0x567efa50, 0x952dd77b, 0xd41ccc62,
-    0x138a8d2d, 0x52bb9634, 0x91e8bb1f, 0xd0d9a006, 0xecf37e5e,
-    0xadc26547, 0x6e91486c, 0x2fa05375, 0xe836123a, 0xa9070923,
-    0x6a542408, 0x2b653f11, 0xe479a796, 0xa548bc8f, 0x661b91a4,
-    0x272a8abd, 0xe0bccbf2, 0xa18dd0eb, 0x62defdc0, 0x23efe6d9,
-    0xbde1bc14, 0xfcd0a70d, 0x3f838a26, 0x7eb2913f, 0xb924d070,
-    0xf815cb69, 0x3b46e642, 0x7a77fd5b, 0xb56b65dc, 0xf45a7ec5,
-    0x370953ee, 0x763848f7, 0xb1ae09b8, 0xf09f12a1, 0x33cc3f8a,
-    0x72fd2493
-  },
-  {
-    0x00000000, 0x376ac201, 0x6ed48403, 0x59be4602, 0xdca80907,
-    0xebc2cb06, 0xb27c8d04, 0x85164f05, 0xb851130e, 0x8f3bd10f,
-    0xd685970d, 0xe1ef550c, 0x64f91a09, 0x5393d808, 0x0a2d9e0a,
-    0x3d475c0b, 0x70a3261c, 0x47c9e41d, 0x1e77a21f, 0x291d601e,
-    0xac0b2f1b, 0x9b61ed1a, 0xc2dfab18, 0xf5b56919, 0xc8f23512,
-    0xff98f713, 0xa626b111, 0x914c7310, 0x145a3c15, 0x2330fe14,
-    0x7a8eb816, 0x4de47a17, 0xe0464d38, 0xd72c8f39, 0x8e92c93b,
-    0xb9f80b3a, 0x3cee443f, 0x0b84863e, 0x523ac03c, 0x6550023d,
-    0x58175e36, 0x6f7d9c37, 0x36c3da35, 0x01a91834, 0x84bf5731,
-    0xb3d59530, 0xea6bd332, 0xdd011133, 0x90e56b24, 0xa78fa925,
-    0xfe31ef27, 0xc95b2d26, 0x4c4d6223, 0x7b27a022, 0x2299e620,
-    0x15f32421, 0x28b4782a, 0x1fdeba2b, 0x4660fc29, 0x710a3e28,
-    0xf41c712d, 0xc376b32c, 0x9ac8f52e, 0xada2372f, 0xc08d9a70,
-    0xf7e75871, 0xae591e73, 0x9933dc72, 0x1c259377, 0x2b4f5176,
-    0x72f11774, 0x459bd575, 0x78dc897e, 0x4fb64b7f, 0x16080d7d,
-    0x2162cf7c, 0xa4748079, 0x931e4278, 0xcaa0047a, 0xfdcac67b,
-    0xb02ebc6c, 0x87447e6d, 0xdefa386f, 0xe990fa6e, 0x6c86b56b,
-    0x5bec776a, 0x02523168, 0x3538f369, 0x087faf62, 0x3f156d63,
-    0x66ab2b61, 0x51c1e960, 0xd4d7a665, 0xe3bd6464, 0xba032266,
-    0x8d69e067, 0x20cbd748, 0x17a11549, 0x4e1f534b, 0x7975914a,
-    0xfc63de4f, 0xcb091c4e, 0x92b75a4c, 0xa5dd984d, 0x989ac446,
-    0xaff00647, 0xf64e4045, 0xc1248244, 0x4432cd41, 0x73580f40,
-    0x2ae64942, 0x1d8c8b43, 0x5068f154, 0x67023355, 0x3ebc7557,
-    0x09d6b756, 0x8cc0f853, 0xbbaa3a52, 0xe2147c50, 0xd57ebe51,
-    0xe839e25a, 0xdf53205b, 0x86ed6659, 0xb187a458, 0x3491eb5d,
-    0x03fb295c, 0x5a456f5e, 0x6d2fad5f, 0x801b35e1, 0xb771f7e0,
-    0xeecfb1e2, 0xd9a573e3, 0x5cb33ce6, 0x6bd9fee7, 0x3267b8e5,
-    0x050d7ae4, 0x384a26ef, 0x0f20e4ee, 0x569ea2ec, 0x61f460ed,
-    0xe4e22fe8, 0xd388ede9, 0x8a36abeb, 0xbd5c69ea, 0xf0b813fd,
-    0xc7d2d1fc, 0x9e6c97fe, 0xa90655ff, 0x2c101afa, 0x1b7ad8fb,
-    0x42c49ef9, 0x75ae5cf8, 0x48e900f3, 0x7f83c2f2, 0x263d84f0,
-    0x115746f1, 0x944109f4, 0xa32bcbf5, 0xfa958df7, 0xcdff4ff6,
-    0x605d78d9, 0x5737bad8, 0x0e89fcda, 0x39e33edb, 0xbcf571de,
-    0x8b9fb3df, 0xd221f5dd, 0xe54b37dc, 0xd80c6bd7, 0xef66a9d6,
-    0xb6d8efd4, 0x81b22dd5, 0x04a462d0, 0x33cea0d1, 0x6a70e6d3,
-    0x5d1a24d2, 0x10fe5ec5, 0x27949cc4, 0x7e2adac6, 0x494018c7,
-    0xcc5657c2, 0xfb3c95c3, 0xa282d3c1, 0x95e811c0, 0xa8af4dcb,
-    0x9fc58fca, 0xc67bc9c8, 0xf1110bc9, 0x740744cc, 0x436d86cd,
-    0x1ad3c0cf, 0x2db902ce, 0x4096af91, 0x77fc6d90, 0x2e422b92,
-    0x1928e993, 0x9c3ea696, 0xab546497, 0xf2ea2295, 0xc580e094,
-    0xf8c7bc9f, 0xcfad7e9e, 0x9613389c, 0xa179fa9d, 0x246fb598,
-    0x13057799, 0x4abb319b, 0x7dd1f39a, 0x3035898d, 0x075f4b8c,
-    0x5ee10d8e, 0x698bcf8f, 0xec9d808a, 0xdbf7428b, 0x82490489,
-    0xb523c688, 0x88649a83, 0xbf0e5882, 0xe6b01e80, 0xd1dadc81,
-    0x54cc9384, 0x63a65185, 0x3a181787, 0x0d72d586, 0xa0d0e2a9,
-    0x97ba20a8, 0xce0466aa, 0xf96ea4ab, 0x7c78ebae, 0x4b1229af,
-    0x12ac6fad, 0x25c6adac, 0x1881f1a7, 0x2feb33a6, 0x765575a4,
-    0x413fb7a5, 0xc429f8a0, 0xf3433aa1, 0xaafd7ca3, 0x9d97bea2,
-    0xd073c4b5, 0xe71906b4, 0xbea740b6, 0x89cd82b7, 0x0cdbcdb2,
-    0x3bb10fb3, 0x620f49b1, 0x55658bb0, 0x6822d7bb, 0x5f4815ba,
-    0x06f653b8, 0x319c91b9, 0xb48adebc, 0x83e01cbd, 0xda5e5abf,
-    0xed3498be
-  },
-  {
-    0x00000000, 0x6567bcb8, 0x8bc809aa, 0xeeafb512, 0x5797628f,
-    0x32f0de37, 0xdc5f6b25, 0xb938d79d, 0xef28b4c5, 0x8a4f087d,
-    0x64e0bd6f, 0x018701d7, 0xb8bfd64a, 0xddd86af2, 0x3377dfe0,
-    0x56106358, 0x9f571950, 0xfa30a5e8, 0x149f10fa, 0x71f8ac42,
-    0xc8c07bdf, 0xada7c767, 0x43087275, 0x266fcecd, 0x707fad95,
-    0x1518112d, 0xfbb7a43f, 0x9ed01887, 0x27e8cf1a, 0x428f73a2,
-    0xac20c6b0, 0xc9477a08, 0x3eaf32a0, 0x5bc88e18, 0xb5673b0a,
-    0xd00087b2, 0x6938502f, 0x0c5fec97, 0xe2f05985, 0x8797e53d,
-    0xd1878665, 0xb4e03add, 0x5a4f8fcf, 0x3f283377, 0x8610e4ea,
-    0xe3775852, 0x0dd8ed40, 0x68bf51f8, 0xa1f82bf0, 0xc49f9748,
-    0x2a30225a, 0x4f579ee2, 0xf66f497f, 0x9308f5c7, 0x7da740d5,
-    0x18c0fc6d, 0x4ed09f35, 0x2bb7238d, 0xc518969f, 0xa07f2a27,
-    0x1947fdba, 0x7c204102, 0x928ff410, 0xf7e848a8, 0x3d58149b,
-    0x583fa823, 0xb6901d31, 0xd3f7a189, 0x6acf7614, 0x0fa8caac,
-    0xe1077fbe, 0x8460c306, 0xd270a05e, 0xb7171ce6, 0x59b8a9f4,
-    0x3cdf154c, 0x85e7c2d1, 0xe0807e69, 0x0e2fcb7b, 0x6b4877c3,
-    0xa20f0dcb, 0xc768b173, 0x29c70461, 0x4ca0b8d9, 0xf5986f44,
-    0x90ffd3fc, 0x7e5066ee, 0x1b37da56, 0x4d27b90e, 0x284005b6,
-    0xc6efb0a4, 0xa3880c1c, 0x1ab0db81, 0x7fd76739, 0x9178d22b,
-    0xf41f6e93, 0x03f7263b, 0x66909a83, 0x883f2f91, 0xed589329,
-    0x546044b4, 0x3107f80c, 0xdfa84d1e, 0xbacff1a6, 0xecdf92fe,
-    0x89b82e46, 0x67179b54, 0x027027ec, 0xbb48f071, 0xde2f4cc9,
-    0x3080f9db, 0x55e74563, 0x9ca03f6b, 0xf9c783d3, 0x176836c1,
-    0x720f8a79, 0xcb375de4, 0xae50e15c, 0x40ff544e, 0x2598e8f6,
-    0x73888bae, 0x16ef3716, 0xf8408204, 0x9d273ebc, 0x241fe921,
-    0x41785599, 0xafd7e08b, 0xcab05c33, 0x3bb659ed, 0x5ed1e555,
-    0xb07e5047, 0xd519ecff, 0x6c213b62, 0x094687da, 0xe7e932c8,
-    0x828e8e70, 0xd49eed28, 0xb1f95190, 0x5f56e482, 0x3a31583a,
-    0x83098fa7, 0xe66e331f, 0x08c1860d, 0x6da63ab5, 0xa4e140bd,
-    0xc186fc05, 0x2f294917, 0x4a4ef5af, 0xf3762232, 0x96119e8a,
-    0x78be2b98, 0x1dd99720, 0x4bc9f478, 0x2eae48c0, 0xc001fdd2,
-    0xa566416a, 0x1c5e96f7, 0x79392a4f, 0x97969f5d, 0xf2f123e5,
-    0x05196b4d, 0x607ed7f5, 0x8ed162e7, 0xebb6de5f, 0x528e09c2,
-    0x37e9b57a, 0xd9460068, 0xbc21bcd0, 0xea31df88, 0x8f566330,
-    0x61f9d622, 0x049e6a9a, 0xbda6bd07, 0xd8c101bf, 0x366eb4ad,
-    0x53090815, 0x9a4e721d, 0xff29cea5, 0x11867bb7, 0x74e1c70f,
-    0xcdd91092, 0xa8beac2a, 0x46111938, 0x2376a580, 0x7566c6d8,
-    0x10017a60, 0xfeaecf72, 0x9bc973ca, 0x22f1a457, 0x479618ef,
-    0xa939adfd, 0xcc5e1145, 0x06ee4d76, 0x6389f1ce, 0x8d2644dc,
-    0xe841f864, 0x51792ff9, 0x341e9341, 0xdab12653, 0xbfd69aeb,
-    0xe9c6f9b3, 0x8ca1450b, 0x620ef019, 0x07694ca1, 0xbe519b3c,
-    0xdb362784, 0x35999296, 0x50fe2e2e, 0x99b95426, 0xfcdee89e,
-    0x12715d8c, 0x7716e134, 0xce2e36a9, 0xab498a11, 0x45e63f03,
-    0x208183bb, 0x7691e0e3, 0x13f65c5b, 0xfd59e949, 0x983e55f1,
-    0x2106826c, 0x44613ed4, 0xaace8bc6, 0xcfa9377e, 0x38417fd6,
-    0x5d26c36e, 0xb389767c, 0xd6eecac4, 0x6fd61d59, 0x0ab1a1e1,
-    0xe41e14f3, 0x8179a84b, 0xd769cb13, 0xb20e77ab, 0x5ca1c2b9,
-    0x39c67e01, 0x80fea99c, 0xe5991524, 0x0b36a036, 0x6e511c8e,
-    0xa7166686, 0xc271da3e, 0x2cde6f2c, 0x49b9d394, 0xf0810409,
-    0x95e6b8b1, 0x7b490da3, 0x1e2eb11b, 0x483ed243, 0x2d596efb,
-    0xc3f6dbe9, 0xa6916751, 0x1fa9b0cc, 0x7ace0c74, 0x9461b966,
-    0xf10605de
-  }
-};
-
-#endif /* CRC32_H_ */
diff --git a/contrib/libzlib-ng/deflate.c b/contrib/libzlib-ng/deflate.c
deleted file mode 100644
index fb275671777..00000000000
--- a/contrib/libzlib-ng/deflate.c
+++ /dev/null
@@ -1,1407 +0,0 @@
-/* deflate.c -- compress data using the deflation algorithm
- * Copyright (C) 1995-2013 Jean-loup Gailly and Mark Adler
- * For conditions of distribution and use, see copyright notice in zlib.h
- */
-
-/*
- *  ALGORITHM
- *
- *      The "deflation" process depends on being able to identify portions
- *      of the input text which are identical to earlier input (within a
- *      sliding window trailing behind the input currently being processed).
- *
- *      The most straightforward technique turns out to be the fastest for
- *      most input files: try all possible matches and select the longest.
- *      The key feature of this algorithm is that insertions into the string
- *      dictionary are very simple and thus fast, and deletions are avoided
- *      completely. Insertions are performed at each input character, whereas
- *      string matches are performed only when the previous match ends. So it
- *      is preferable to spend more time in matches to allow very fast string
- *      insertions and avoid deletions. The matching algorithm for small
- *      strings is inspired from that of Rabin & Karp. A brute force approach
- *      is used to find longer strings when a small match has been found.
- *      A similar algorithm is used in comic (by Jan-Mark Wams) and freeze
- *      (by Leonid Broukhis).
- *         A previous version of this file used a more sophisticated algorithm
- *      (by Fiala and Greene) which is guaranteed to run in linear amortized
- *      time, but has a larger average cost, uses more memory and is patented.
- *      However the F&G algorithm may be faster for some highly redundant
- *      files if the parameter max_chain_length (described below) is too large.
- *
- *  ACKNOWLEDGEMENTS
- *
- *      The idea of lazy evaluation of matches is due to Jan-Mark Wams, and
- *      I found it in 'freeze' written by Leonid Broukhis.
- *      Thanks to many people for bug reports and testing.
- *
- *  REFERENCES
- *
- *      Deutsch, L.P.,"DEFLATE Compressed Data Format Specification".
- *      Available in http://tools.ietf.org/html/rfc1951
- *
- *      A description of the Rabin and Karp algorithm is given in the book
- *         "Algorithms" by R. Sedgewick, Addison-Wesley, p252.
- *
- *      Fiala,E.R., and Greene,D.H.
- *         Data Compression with Finite Windows, Comm.ACM, 32,4 (1989) 490-595
- *
- */
-
-/* @(#) $Id$ */
-
-#include "deflate.h"
-#include "deflate_p.h"
-#include "match.h"
-
-const char deflate_copyright[] = " deflate 1.2.8.f Copyright 1995-2013 Jean-loup Gailly and Mark Adler ";
-/*
-  If you use the zlib library in a product, an acknowledgment is welcome
-  in the documentation of your product. If for some reason you cannot
-  include such an acknowledgment, I would appreciate that you keep this
-  copyright string in the executable of your product.
- */
-
-/* ===========================================================================
- *  Function prototypes.
- */
-
-typedef block_state (*compress_func) (deflate_state *s, int flush);
-/* Compression function. Returns the block state after the call. */
-
-void fill_window                 (deflate_state *s);
-local block_state deflate_stored (deflate_state *s, int flush);
-block_state deflate_fast         (deflate_state *s, int flush);
-block_state deflate_quick        (deflate_state *s, int flush);
-#ifdef MEDIUM_STRATEGY
-block_state deflate_medium       (deflate_state *s, int flush);
-#endif
-block_state deflate_slow         (deflate_state *s, int flush);
-local block_state deflate_rle    (deflate_state *s, int flush);
-local block_state deflate_huff   (deflate_state *s, int flush);
-local void lm_init               (deflate_state *s);
-local void putShortMSB           (deflate_state *s, uint16_t b);
-ZLIB_INTERNAL void flush_pending (z_stream *strm);
-ZLIB_INTERNAL int read_buf       (z_stream *strm, unsigned char *buf, unsigned size);
-
-extern void crc_reset(deflate_state *const s);
-extern void crc_finalize(deflate_state *const s);
-extern void copy_with_crc(z_stream *strm, unsigned char *dst, long size);
-
-/* ===========================================================================
- * Local data
- */
-
-#define NIL 0
-/* Tail of hash chains */
-
-/* Values for max_lazy_match, good_match and max_chain_length, depending on
- * the desired pack level (0..9). The values given below have been tuned to
- * exclude worst case performance for pathological files. Better values may be
- * found for specific files.
- */
-typedef struct config_s {
-    uint16_t good_length; /* reduce lazy search above this match length */
-    uint16_t max_lazy;    /* do not perform lazy search above this match length */
-    uint16_t nice_length; /* quit search above this match length */
-    uint16_t max_chain;
-    compress_func func;
-} config;
-
-local const config configuration_table[10] = {
-/*      good lazy nice chain */
-/* 0 */ {0,    0,  0,    0, deflate_stored},  /* store only */
-
-#ifdef X86_QUICK_STRATEGY
-/* 1 */ {4,    4,  8,    4, deflate_quick},
-/* 2 */ {4,    4,  8,    4, deflate_fast}, /* max speed, no lazy matches */
-#else
-/* 1 */ {4,    4,  8,    4, deflate_fast}, /* max speed, no lazy matches */
-/* 2 */ {4,    5, 16,    8, deflate_fast},
-#endif
-
-/* 3 */ {4,    6, 32,   32, deflate_fast},
-
-#ifdef MEDIUM_STRATEGY
-/* 4 */ {4,    4, 16,   16, deflate_medium},  /* lazy matches */
-/* 5 */ {8,   16, 32,   32, deflate_medium},
-/* 6 */ {8,   16, 128, 128, deflate_medium},
-#else
-/* 4 */ {4,    4, 16,   16, deflate_slow},  /* lazy matches */
-/* 5 */ {8,   16, 32,   32, deflate_slow},
-/* 6 */ {8,   16, 128, 128, deflate_slow},
-#endif
-
-/* 7 */ {8,   32, 128, 256, deflate_slow},
-/* 8 */ {32, 128, 258, 1024, deflate_slow},
-/* 9 */ {32, 258, 258, 4096, deflate_slow}}; /* max compression */
-
-/* Note: the deflate() code requires max_lazy >= MIN_MATCH and max_chain >= 4
- * For deflate_fast() (levels <= 3) good is ignored and lazy has a different
- * meaning.
- */
-
-#define EQUAL 0
-/* result of memcmp for equal strings */
-
-/* rank Z_BLOCK between Z_NO_FLUSH and Z_PARTIAL_FLUSH */
-#define RANK(f) (((f) * 2) - ((f) > 4 ? 9 : 0))
-
-
-/* ===========================================================================
- * Initialize the hash table (avoiding 64K overflow for 16 bit systems).
- * prev[] will be initialized on the fly.
- */
-#define CLEAR_HASH(s) \
-    s->head[s->hash_size-1] = NIL; \
-    memset((unsigned char *)s->head, 0, (unsigned)(s->hash_size-1)*sizeof(*s->head));
-
-/* ========================================================================= */
-int ZEXPORT deflateInit_(z_stream *strm, int level, const char *version, int stream_size) {
-    return deflateInit2_(strm, level, Z_DEFLATED, MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY, version, stream_size);
-    /* Todo: ignore strm->next_in if we use it as window */
-}
-
-/* ========================================================================= */
-int ZEXPORT deflateInit2_(z_stream *strm, int level, int method, int windowBits,
-                           int memLevel, int strategy, const char *version, int stream_size) {
-    unsigned window_padding = 0;
-    deflate_state *s;
-    int wrap = 1;
-    static const char my_version[] = ZLIB_VERSION;
-
-    uint16_t *overlay;
-    /* We overlay pending_buf and d_buf+l_buf. This works since the average
-     * output size for (length,distance) codes is <= 24 bits.
-     */
-
-#if defined(X86_SSE2_FILL_WINDOW) || defined(X86_SSE4_2_CRC_HASH)
-    x86_check_features();
-#endif
-
-    if (version == Z_NULL || version[0] != my_version[0] || stream_size != sizeof(z_stream)) {
-        return Z_VERSION_ERROR;
-    }
-    if (strm == Z_NULL)
-        return Z_STREAM_ERROR;
-
-    strm->msg = Z_NULL;
-    if (strm->zalloc == (alloc_func)0) {
-        strm->zalloc = zcalloc;
-        strm->opaque = NULL;
-    }
-    if (strm->zfree == (free_func)0)
-        strm->zfree = zcfree;
-
-    if (level == Z_DEFAULT_COMPRESSION)
-        level = 6;
-
-    if (windowBits < 0) { /* suppress zlib wrapper */
-        wrap = 0;
-        windowBits = -windowBits;
-#ifdef GZIP
-    } else if (windowBits > 15) {
-        wrap = 2;       /* write gzip wrapper instead */
-        windowBits -= 16;
-#endif
-    }
-    if (memLevel < 1 || memLevel > MAX_MEM_LEVEL || method != Z_DEFLATED || windowBits < 8 ||
-        windowBits > 15 || level < 0 || level > 9 || strategy < 0 || strategy > Z_FIXED) {
-        return Z_STREAM_ERROR;
-    }
-    if (windowBits == 8)
-        windowBits = 9;  /* until 256-byte window bug fixed */
-
-#ifdef X86_QUICK_STRATEGY
-    if (level == 1)
-        windowBits = 13;
-#endif
-
-    s = (deflate_state *) ZALLOC(strm, 1, sizeof(deflate_state));
-    if (s == Z_NULL)
-        return Z_MEM_ERROR;
-    strm->state = (struct internal_state *)s;
-    s->strm = strm;
-
-    s->wrap = wrap;
-    s->gzhead = Z_NULL;
-    s->w_bits = windowBits;
-    s->w_size = 1 << s->w_bits;
-    s->w_mask = s->w_size - 1;
-
-#ifdef X86_SSE4_2_CRC_HASH
-    if (x86_cpu_has_sse42)
-        s->hash_bits = 15;
-    else
-#endif
-        s->hash_bits = memLevel + 7;
-
-    s->hash_size = 1 << s->hash_bits;
-    s->hash_mask = s->hash_size - 1;
-    s->hash_shift =  ((s->hash_bits+MIN_MATCH-1)/MIN_MATCH);
-
-#ifdef X86_PCLMULQDQ_CRC
-    window_padding = 8;
-#endif
-
-    s->window = (unsigned char *) ZALLOC(strm, s->w_size + window_padding, 2*sizeof(unsigned char));
-    s->prev   = (Pos *)  ZALLOC(strm, s->w_size, sizeof(Pos));
-    s->head   = (Pos *)  ZALLOC(strm, s->hash_size, sizeof(Pos));
-
-    s->high_water = 0;      /* nothing written to s->window yet */
-
-    s->lit_bufsize = 1 << (memLevel + 6); /* 16K elements by default */
-
-    overlay = (uint16_t *) ZALLOC(strm, s->lit_bufsize, sizeof(uint16_t)+2);
-    s->pending_buf = (unsigned char *) overlay;
-    s->pending_buf_size = (unsigned long)s->lit_bufsize * (sizeof(uint16_t)+2L);
-
-    if (s->window == Z_NULL || s->prev == Z_NULL || s->head == Z_NULL ||
-        s->pending_buf == Z_NULL) {
-        s->status = FINISH_STATE;
-        strm->msg = ERR_MSG(Z_MEM_ERROR);
-        deflateEnd(strm);
-        return Z_MEM_ERROR;
-    }
-    s->d_buf = overlay + s->lit_bufsize/sizeof(uint16_t);
-    s->l_buf = s->pending_buf + (1+sizeof(uint16_t))*s->lit_bufsize;
-
-    s->level = level;
-    s->strategy = strategy;
-    s->method = (unsigned char)method;
-
-    return deflateReset(strm);
-}
-
-/* ========================================================================= */
-int ZEXPORT deflateSetDictionary(z_stream *strm, const unsigned char *dictionary, unsigned int dictLength) {
-    deflate_state *s;
-    unsigned int str, n;
-    int wrap;
-    uint32_t avail;
-    const unsigned char *next;
-
-    if (strm == Z_NULL || strm->state == Z_NULL || dictionary == Z_NULL)
-        return Z_STREAM_ERROR;
-    s = strm->state;
-    wrap = s->wrap;
-    if (wrap == 2 || (wrap == 1 && s->status != INIT_STATE) || s->lookahead)
-        return Z_STREAM_ERROR;
-
-    /* when using zlib wrappers, compute Adler-32 for provided dictionary */
-    if (wrap == 1)
-        strm->adler = adler32(strm->adler, dictionary, dictLength);
-    s->wrap = 0;                    /* avoid computing Adler-32 in read_buf */
-
-    /* if dictionary would fill window, just replace the history */
-    if (dictLength >= s->w_size) {
-        if (wrap == 0) {            /* already empty otherwise */
-            CLEAR_HASH(s);
-            s->strstart = 0;
-            s->block_start = 0L;
-            s->insert = 0;
-        }
-        dictionary += dictLength - s->w_size;  /* use the tail */
-        dictLength = s->w_size;
-    }
-
-    /* insert dictionary into window and hash */
-    avail = strm->avail_in;
-    next = strm->next_in;
-    strm->avail_in = dictLength;
-    strm->next_in = (const unsigned char *)dictionary;
-    fill_window(s);
-    while (s->lookahead >= MIN_MATCH) {
-        str = s->strstart;
-        n = s->lookahead - (MIN_MATCH-1);
-        bulk_insert_str(s, str, n);
-        s->strstart = str + n;
-        s->lookahead = MIN_MATCH-1;
-        fill_window(s);
-    }
-    s->strstart += s->lookahead;
-    s->block_start = (long)s->strstart;
-    s->insert = s->lookahead;
-    s->lookahead = 0;
-    s->match_length = s->prev_length = MIN_MATCH-1;
-    s->match_available = 0;
-    strm->next_in = next;
-    strm->avail_in = avail;
-    s->wrap = wrap;
-    return Z_OK;
-}
-
-/* ========================================================================= */
-int ZEXPORT deflateResetKeep(z_stream *strm) {
-    deflate_state *s;
-
-    if (strm == Z_NULL || strm->state == Z_NULL || strm->zalloc == (alloc_func)0 || strm->zfree == (free_func)0) {
-        return Z_STREAM_ERROR;
-    }
-
-    strm->total_in = strm->total_out = 0;
-    strm->msg = Z_NULL; /* use zfree if we ever allocate msg dynamically */
-    strm->data_type = Z_UNKNOWN;
-
-    s = (deflate_state *)strm->state;
-    s->pending = 0;
-    s->pending_out = s->pending_buf;
-
-    if (s->wrap < 0) {
-        s->wrap = -s->wrap; /* was made negative by deflate(..., Z_FINISH); */
-    }
-    s->status = s->wrap ? INIT_STATE : BUSY_STATE;
-#ifdef GZIP
-    strm->adler = s->wrap == 2 ? crc32(0L, Z_NULL, 0) : adler32(0L, Z_NULL, 0);
-#else
-    strm->adler = adler32(0L, Z_NULL, 0);
-#endif
-    s->last_flush = Z_NO_FLUSH;
-
-    _tr_init(s);
-
-    return Z_OK;
-}
-
-/* ========================================================================= */
-int ZEXPORT deflateReset(z_stream *strm) {
-    int ret;
-
-    ret = deflateResetKeep(strm);
-    if (ret == Z_OK)
-        lm_init(strm->state);
-    return ret;
-}
-
-/* ========================================================================= */
-int ZEXPORT deflateSetHeader(z_stream *strm, gz_headerp head) {
-    if (strm == Z_NULL || strm->state == Z_NULL)
-        return Z_STREAM_ERROR;
-    if (strm->state->wrap != 2)
-        return Z_STREAM_ERROR;
-    strm->state->gzhead = head;
-    return Z_OK;
-}
-
-/* ========================================================================= */
-int ZEXPORT deflatePending(z_stream *strm, uint32_t *pending, int *bits) {
-    if (strm == Z_NULL || strm->state == Z_NULL)
-        return Z_STREAM_ERROR;
-    if (pending != Z_NULL)
-        *pending = strm->state->pending;
-    if (bits != Z_NULL)
-        *bits = strm->state->bi_valid;
-    return Z_OK;
-}
-
-/* ========================================================================= */
-int ZEXPORT deflatePrime(z_stream *strm, int bits, int value) {
-    deflate_state *s;
-    int put;
-
-    if (strm == Z_NULL || strm->state == Z_NULL)
-        return Z_STREAM_ERROR;
-    s = strm->state;
-    if ((unsigned char *)(s->d_buf) < s->pending_out + ((Buf_size + 7) >> 3))
-        return Z_BUF_ERROR;
-    do {
-        put = Buf_size - s->bi_valid;
-        if (put > bits)
-            put = bits;
-        s->bi_buf |= (uint16_t)((value & ((1 << put) - 1)) << s->bi_valid);
-        s->bi_valid += put;
-        _tr_flush_bits(s);
-        value >>= put;
-        bits -= put;
-    } while (bits);
-    return Z_OK;
-}
-
-/* ========================================================================= */
-int ZEXPORT deflateParams(z_stream *strm, int level, int strategy) {
-    deflate_state *s;
-    compress_func func;
-    int err = Z_OK;
-
-    if (strm == Z_NULL || strm->state == Z_NULL)
-        return Z_STREAM_ERROR;
-    s = strm->state;
-
-    if (level == Z_DEFAULT_COMPRESSION)
-        level = 6;
-    if (level < 0 || level > 9 || strategy < 0 || strategy > Z_FIXED) {
-        return Z_STREAM_ERROR;
-    }
-    func = configuration_table[s->level].func;
-
-    if ((strategy != s->strategy || func != configuration_table[level].func)) {
-        /* Flush the last buffer: */
-        err = deflate(strm, Z_BLOCK);
-        if (err == Z_BUF_ERROR && s->pending == 0)
-            err = Z_OK;
-    }
-    if (s->level != level) {
-        s->level = level;
-        s->max_lazy_match   = configuration_table[level].max_lazy;
-        s->good_match       = configuration_table[level].good_length;
-        s->nice_match       = configuration_table[level].nice_length;
-        s->max_chain_length = configuration_table[level].max_chain;
-    }
-    s->strategy = strategy;
-    return err;
-}
-
-/* ========================================================================= */
-int ZEXPORT deflateTune(z_stream *strm, int good_length, int max_lazy, int nice_length, int max_chain) {
-    deflate_state *s;
-
-    if (strm == Z_NULL || strm->state == Z_NULL)
-        return Z_STREAM_ERROR;
-    s = strm->state;
-    s->good_match = good_length;
-    s->max_lazy_match = max_lazy;
-    s->nice_match = nice_length;
-    s->max_chain_length = max_chain;
-    return Z_OK;
-}
-
-/* =========================================================================
- * For the default windowBits of 15 and memLevel of 8, this function returns
- * a close to exact, as well as small, upper bound on the compressed size.
- * They are coded as constants here for a reason--if the #define's are
- * changed, then this function needs to be changed as well.  The return
- * value for 15 and 8 only works for those exact settings.
- *
- * For any setting other than those defaults for windowBits and memLevel,
- * the value returned is a conservative worst case for the maximum expansion
- * resulting from using fixed blocks instead of stored blocks, which deflate
- * can emit on compressed data for some combinations of the parameters.
- *
- * This function could be more sophisticated to provide closer upper bounds for
- * every combination of windowBits and memLevel.  But even the conservative
- * upper bound of about 14% expansion does not seem onerous for output buffer
- * allocation.
- */
-unsigned long ZEXPORT deflateBound(z_stream *strm, unsigned long sourceLen) {
-    deflate_state *s;
-    unsigned long complen, wraplen;
-    unsigned char *str;
-
-    /* conservative upper bound for compressed data */
-    complen = sourceLen + ((sourceLen + 7) >> 3) + ((sourceLen + 63) >> 6) + 5;
-
-    /* if can't get parameters, return conservative bound plus zlib wrapper */
-    if (strm == Z_NULL || strm->state == Z_NULL)
-        return complen + 6;
-
-    /* compute wrapper length */
-    s = strm->state;
-    switch (s->wrap) {
-    case 0:                                 /* raw deflate */
-        wraplen = 0;
-        break;
-    case 1:                                 /* zlib wrapper */
-        wraplen = 6 + (s->strstart ? 4 : 0);
-        break;
-    case 2:                                 /* gzip wrapper */
-        wraplen = 18;
-        if (s->gzhead != Z_NULL) {          /* user-supplied gzip header */
-            if (s->gzhead->extra != Z_NULL) {
-                wraplen += 2 + s->gzhead->extra_len;
-            }
-            str = s->gzhead->name;
-            if (str != Z_NULL) {
-                do {
-                    wraplen++;
-                } while (*str++);
-            }
-            str = s->gzhead->comment;
-            if (str != Z_NULL) {
-                do {
-                    wraplen++;
-                } while (*str++);
-            }
-            if (s->gzhead->hcrc)
-                wraplen += 2;
-        }
-        break;
-    default:                                /* for compiler happiness */
-        wraplen = 6;
-    }
-
-    /* if not default parameters, return conservative bound */
-    if (s->w_bits != 15 || s->hash_bits != 8 + 7)
-        return complen + wraplen;
-
-    /* default settings: return tight bound for that case */
-    return sourceLen + (sourceLen >> 12) + (sourceLen >> 14) + (sourceLen >> 25) + 13 - 6 + wraplen;
-}
-
-/* =========================================================================
- * Put a short in the pending buffer. The 16-bit value is put in MSB order.
- * IN assertion: the stream state is correct and there is enough room in
- * pending_buf.
- */
-local void putShortMSB(deflate_state *s, uint16_t b) {
-    put_byte(s, (unsigned char)(b >> 8));
-    put_byte(s, (unsigned char)(b & 0xff));
-}
-
-/* =========================================================================
- * Flush as much pending output as possible. All deflate() output goes
- * through this function so some applications may wish to modify it
- * to avoid allocating a large strm->next_out buffer and copying into it.
- * (See also read_buf()).
- */
-ZLIB_INTERNAL void flush_pending(z_stream *strm) {
-    uint32_t len;
-    deflate_state *s = strm->state;
-
-    _tr_flush_bits(s);
-    len = s->pending;
-    if (len > strm->avail_out)
-        len = strm->avail_out;
-    if (len == 0)
-        return;
-
-    memcpy(strm->next_out, s->pending_out, len);
-    strm->next_out  += len;
-    s->pending_out  += len;
-    strm->total_out += len;
-    strm->avail_out  -= len;
-    s->pending -= len;
-    if (s->pending == 0) {
-        s->pending_out = s->pending_buf;
-    }
-}
-
-/* ========================================================================= */
-int ZEXPORT deflate(z_stream *strm, int flush) {
-    int old_flush; /* value of flush param for previous deflate call */
-    deflate_state *s;
-
-    if (strm == Z_NULL || strm->state == Z_NULL || flush > Z_BLOCK || flush < 0) {
-        return Z_STREAM_ERROR;
-    }
-    s = strm->state;
-
-    if (strm->next_out == Z_NULL || (strm->avail_in != 0 && strm->next_in == Z_NULL) ||
-        (s->status == FINISH_STATE && flush != Z_FINISH)) {
-        ERR_RETURN(strm, Z_STREAM_ERROR);
-    }
-    if (strm->avail_out == 0)
-        ERR_RETURN(strm, Z_BUF_ERROR);
-
-    s->strm = strm; /* just in case */
-    old_flush = s->last_flush;
-    s->last_flush = flush;
-
-    /* Write the header */
-    if (s->status == INIT_STATE) {
-#ifdef GZIP
-        if (s->wrap == 2) {
-            crc_reset(s);
-            put_byte(s, 31);
-            put_byte(s, 139);
-            put_byte(s, 8);
-            if (s->gzhead == Z_NULL) {
-                put_byte(s, 0);
-                put_byte(s, 0);
-                put_byte(s, 0);
-                put_byte(s, 0);
-                put_byte(s, 0);
-                put_byte(s, s->level == 9 ? 2 :
-                            (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2 ?
-                            4 : 0));
-                put_byte(s, OS_CODE);
-                s->status = BUSY_STATE;
-            } else {
-                put_byte(s, (s->gzhead->text ? 1 : 0) +
-                            (s->gzhead->hcrc ? 2 : 0) +
-                            (s->gzhead->extra == Z_NULL ? 0 : 4) +
-                            (s->gzhead->name == Z_NULL ? 0 : 8) +
-                            (s->gzhead->comment == Z_NULL ? 0 : 16) );
-                put_byte(s, (unsigned char)(s->gzhead->time & 0xff));
-                put_byte(s, (unsigned char)((s->gzhead->time >> 8) & 0xff));
-                put_byte(s, (unsigned char)((s->gzhead->time >> 16) & 0xff));
-                put_byte(s, (unsigned char)((s->gzhead->time >> 24) & 0xff));
-                put_byte(s, s->level == 9 ? 2 :
-                            (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2 ?
-                             4 : 0));
-                put_byte(s, s->gzhead->os & 0xff);
-                if (s->gzhead->extra != Z_NULL) {
-                    put_byte(s, s->gzhead->extra_len & 0xff);
-                    put_byte(s, (s->gzhead->extra_len >> 8) & 0xff);
-                }
-                if (s->gzhead->hcrc)
-                    strm->adler = crc32(strm->adler, s->pending_buf, s->pending);
-                s->gzindex = 0;
-                s->status = EXTRA_STATE;
-            }
-        } else
-#endif
-        {
-            unsigned int header = (Z_DEFLATED + ((s->w_bits-8) << 4)) << 8;
-            unsigned int level_flags;
-
-            if (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2)
-                level_flags = 0;
-            else if (s->level < 6)
-                level_flags = 1;
-            else if (s->level == 6)
-                level_flags = 2;
-            else
-                level_flags = 3;
-            header |= (level_flags << 6);
-            if (s->strstart != 0)
-                header |= PRESET_DICT;
-            header += 31 - (header % 31);
-
-            s->status = BUSY_STATE;
-            putShortMSB(s, header);
-
-            /* Save the adler32 of the preset dictionary: */
-            if (s->strstart != 0) {
-                putShortMSB(s, (uint16_t)(strm->adler >> 16));
-                putShortMSB(s, (uint16_t)strm->adler);
-            }
-            strm->adler = adler32(0L, Z_NULL, 0);
-        }
-    }
-#ifdef GZIP
-    if (s->status == EXTRA_STATE) {
-        if (s->gzhead->extra != Z_NULL) {
-            uint32_t beg = s->pending;  /* start of bytes to update crc */
-
-            while (s->gzindex < (s->gzhead->extra_len & 0xffff)) {
-                if (s->pending == s->pending_buf_size) {
-                    if (s->gzhead->hcrc && s->pending > beg)
-                        strm->adler = crc32(strm->adler, s->pending_buf + beg, s->pending - beg);
-                    flush_pending(strm);
-                    beg = s->pending;
-                    if (s->pending == s->pending_buf_size)
-                        break;
-                }
-                put_byte(s, s->gzhead->extra[s->gzindex]);
-                s->gzindex++;
-            }
-            if (s->gzhead->hcrc && s->pending > beg)
-                strm->adler = crc32(strm->adler, s->pending_buf + beg, s->pending - beg);
-            if (s->gzindex == s->gzhead->extra_len) {
-                s->gzindex = 0;
-                s->status = NAME_STATE;
-            }
-        } else {
-            s->status = NAME_STATE;
-        }
-    }
-    if (s->status == NAME_STATE) {
-        if (s->gzhead->name != Z_NULL) {
-            uint32_t beg = s->pending;  /* start of bytes to update crc */
-            int val;
-
-            do {
-                if (s->pending == s->pending_buf_size) {
-                    if (s->gzhead->hcrc && s->pending > beg)
-                        strm->adler = crc32(strm->adler, s->pending_buf + beg, s->pending - beg);
-                    flush_pending(strm);
-                    beg = s->pending;
-                    if (s->pending == s->pending_buf_size) {
-                        val = 1;
-                        break;
-                    }
-                }
-                val = s->gzhead->name[s->gzindex++];
-                put_byte(s, val);
-            } while (val != 0);
-            if (s->gzhead->hcrc && s->pending > beg)
-                strm->adler = crc32(strm->adler, s->pending_buf + beg, s->pending - beg);
-            if (val == 0) {
-                s->gzindex = 0;
-                s->status = COMMENT_STATE;
-            }
-        } else {
-            s->status = COMMENT_STATE;
-        }
-    }
-    if (s->status == COMMENT_STATE) {
-        if (s->gzhead->comment != Z_NULL) {
-            uint32_t beg = s->pending;  /* start of bytes to update crc */
-            int val;
-
-            do {
-                if (s->pending == s->pending_buf_size) {
-                    if (s->gzhead->hcrc && s->pending > beg)
-                        strm->adler = crc32(strm->adler, s->pending_buf + beg, s->pending - beg);
-                    flush_pending(strm);
-                    beg = s->pending;
-                    if (s->pending == s->pending_buf_size) {
-                        val = 1;
-                        break;
-                    }
-                }
-                val = s->gzhead->comment[s->gzindex++];
-                put_byte(s, val);
-            } while (val != 0);
-            if (s->gzhead->hcrc && s->pending > beg)
-                strm->adler = crc32(strm->adler, s->pending_buf + beg, s->pending - beg);
-            if (val == 0)
-                s->status = HCRC_STATE;
-        } else {
-            s->status = HCRC_STATE;
-        }
-    }
-    if (s->status == HCRC_STATE) {
-        if (s->gzhead->hcrc) {
-            if (s->pending + 2 > s->pending_buf_size)
-                flush_pending(strm);
-            if (s->pending + 2 <= s->pending_buf_size) {
-                put_byte(s, (unsigned char)(strm->adler & 0xff));
-                put_byte(s, (unsigned char)((strm->adler >> 8) & 0xff));
-                strm->adler = crc32(0L, Z_NULL, 0);
-                s->status = BUSY_STATE;
-            }
-        } else {
-            s->status = BUSY_STATE;
-        }
-    }
-#endif
-
-    /* Flush as much pending output as possible */
-    if (s->pending != 0) {
-        flush_pending(strm);
-        if (strm->avail_out == 0) {
-            /* Since avail_out is 0, deflate will be called again with
-             * more output space, but possibly with both pending and
-             * avail_in equal to zero. There won't be anything to do,
-             * but this is not an error situation so make sure we
-             * return OK instead of BUF_ERROR at next call of deflate:
-             */
-            s->last_flush = -1;
-            return Z_OK;
-        }
-
-    /* Make sure there is something to do and avoid duplicate consecutive
-     * flushes. For repeated and useless calls with Z_FINISH, we keep
-     * returning Z_STREAM_END instead of Z_BUF_ERROR.
-     */
-    } else if (strm->avail_in == 0 && RANK(flush) <= RANK(old_flush) && flush != Z_FINISH) {
-        ERR_RETURN(strm, Z_BUF_ERROR);
-    }
-
-    /* User must not provide more input after the first FINISH: */
-    if (s->status == FINISH_STATE && strm->avail_in != 0) {
-        ERR_RETURN(strm, Z_BUF_ERROR);
-    }
-
-    /* Start a new block or continue the current one.
-     */
-    if (strm->avail_in != 0 || s->lookahead != 0 || (flush != Z_NO_FLUSH && s->status != FINISH_STATE)) {
-        block_state bstate;
-
-#ifdef X86_QUICK_STRATEGY
-        if (s->level == 1 && !x86_cpu_has_sse42)
-            bstate = s->strategy == Z_HUFFMAN_ONLY ? deflate_huff(s, flush) :
-                    (s->strategy == Z_RLE ? deflate_rle(s, flush) : deflate_fast(s, flush));
-        else
-#endif
-            bstate = s->strategy == Z_HUFFMAN_ONLY ? deflate_huff(s, flush) :
-                    (s->strategy == Z_RLE ? deflate_rle(s, flush) : (*(configuration_table[s->level].func))(s, flush));
-
-        if (bstate == finish_started || bstate == finish_done) {
-            s->status = FINISH_STATE;
-        }
-        if (bstate == need_more || bstate == finish_started) {
-            if (strm->avail_out == 0) {
-                s->last_flush = -1; /* avoid BUF_ERROR next call, see above */
-            }
-            return Z_OK;
-            /* If flush != Z_NO_FLUSH && avail_out == 0, the next call
-             * of deflate should use the same flush parameter to make sure
-             * that the flush is complete. So we don't have to output an
-             * empty block here, this will be done at next call. This also
-             * ensures that for a very small output buffer, we emit at most
-             * one empty block.
-             */
-        }
-        if (bstate == block_done) {
-            if (flush == Z_PARTIAL_FLUSH) {
-                _tr_align(s);
-            } else if (flush != Z_BLOCK) { /* FULL_FLUSH or SYNC_FLUSH */
-                _tr_stored_block(s, (char*)0, 0L, 0);
-                /* For a full flush, this empty block will be recognized
-                 * as a special marker by inflate_sync().
-                 */
-                if (flush == Z_FULL_FLUSH) {
-                    CLEAR_HASH(s);             /* forget history */
-                    if (s->lookahead == 0) {
-                        s->strstart = 0;
-                        s->block_start = 0L;
-                        s->insert = 0;
-                    }
-                }
-            }
-            flush_pending(strm);
-            if (strm->avail_out == 0) {
-              s->last_flush = -1; /* avoid BUF_ERROR at next call, see above */
-              return Z_OK;
-            }
-        }
-    }
-    Assert(strm->avail_out > 0, "bug2");
-
-    if (flush != Z_FINISH)
-        return Z_OK;
-    if (s->wrap <= 0)
-        return Z_STREAM_END;
-
-    /* Write the trailer */
-#ifdef GZIP
-    if (s->wrap == 2) {
-        crc_finalize(s);
-        put_byte(s, (unsigned char)(strm->adler & 0xff));
-        put_byte(s, (unsigned char)((strm->adler >> 8) & 0xff));
-        put_byte(s, (unsigned char)((strm->adler >> 16) & 0xff));
-        put_byte(s, (unsigned char)((strm->adler >> 24) & 0xff));
-        put_byte(s, (unsigned char)(strm->total_in & 0xff));
-        put_byte(s, (unsigned char)((strm->total_in >> 8) & 0xff));
-        put_byte(s, (unsigned char)((strm->total_in >> 16) & 0xff));
-        put_byte(s, (unsigned char)((strm->total_in >> 24) & 0xff));
-    } else
-#endif
-    {
-        putShortMSB(s, (uint16_t)(strm->adler >> 16));
-        putShortMSB(s, (uint16_t)strm->adler);
-    }
-    flush_pending(strm);
-    /* If avail_out is zero, the application will call deflate again
-     * to flush the rest.
-     */
-    if (s->wrap > 0)
-        s->wrap = -s->wrap; /* write the trailer only once! */
-    return s->pending != 0 ? Z_OK : Z_STREAM_END;
-}
-
-/* ========================================================================= */
-int ZEXPORT deflateEnd(z_stream *strm) {
-    int status;
-
-    if (strm == Z_NULL || strm->state == Z_NULL)
-        return Z_STREAM_ERROR;
-
-    status = strm->state->status;
-    if (status != INIT_STATE &&
-        status != EXTRA_STATE &&
-        status != NAME_STATE &&
-        status != COMMENT_STATE &&
-        status != HCRC_STATE &&
-        status != BUSY_STATE &&
-        status != FINISH_STATE) {
-      return Z_STREAM_ERROR;
-    }
-
-    /* Deallocate in reverse order of allocations: */
-    TRY_FREE(strm, strm->state->pending_buf);
-    TRY_FREE(strm, strm->state->head);
-    TRY_FREE(strm, strm->state->prev);
-    TRY_FREE(strm, strm->state->window);
-
-    ZFREE(strm, strm->state);
-    strm->state = Z_NULL;
-
-    return status == BUSY_STATE ? Z_DATA_ERROR : Z_OK;
-}
-
-/* =========================================================================
- * Copy the source state to the destination state.
- */
-int ZEXPORT deflateCopy(z_stream *dest, z_stream *source) {
-    deflate_state *ds;
-    deflate_state *ss;
-    uint16_t *overlay;
-
-    if (source == Z_NULL || dest == Z_NULL || source->state == Z_NULL) {
-        return Z_STREAM_ERROR;
-    }
-
-    ss = source->state;
-
-    memcpy((void *)dest, (void *)source, sizeof(z_stream));
-
-    ds = (deflate_state *) ZALLOC(dest, 1, sizeof(deflate_state));
-    if (ds == Z_NULL)
-        return Z_MEM_ERROR;
-    dest->state = (struct internal_state *) ds;
-    memcpy((void *)ds, (void *)ss, sizeof(deflate_state));
-    ds->strm = dest;
-
-    ds->window = (unsigned char *) ZALLOC(dest, ds->w_size, 2*sizeof(unsigned char));
-    ds->prev   = (Pos *)  ZALLOC(dest, ds->w_size, sizeof(Pos));
-    ds->head   = (Pos *)  ZALLOC(dest, ds->hash_size, sizeof(Pos));
-    overlay = (uint16_t *) ZALLOC(dest, ds->lit_bufsize, sizeof(uint16_t)+2);
-    ds->pending_buf = (unsigned char *) overlay;
-
-    if (ds->window == Z_NULL || ds->prev == Z_NULL || ds->head == Z_NULL || ds->pending_buf == Z_NULL) {
-        deflateEnd(dest);
-        return Z_MEM_ERROR;
-    }
-
-    memcpy(ds->window, ss->window, ds->w_size * 2 * sizeof(unsigned char));
-    memcpy((void *)ds->prev, (void *)ss->prev, ds->w_size * sizeof(Pos));
-    memcpy((void *)ds->head, (void *)ss->head, ds->hash_size * sizeof(Pos));
-    memcpy(ds->pending_buf, ss->pending_buf, (unsigned int)ds->pending_buf_size);
-
-    ds->pending_out = ds->pending_buf + (ss->pending_out - ss->pending_buf);
-    ds->d_buf = overlay + ds->lit_bufsize/sizeof(uint16_t);
-    ds->l_buf = ds->pending_buf + (1+sizeof(uint16_t))*ds->lit_bufsize;
-
-    ds->l_desc.dyn_tree = ds->dyn_ltree;
-    ds->d_desc.dyn_tree = ds->dyn_dtree;
-    ds->bl_desc.dyn_tree = ds->bl_tree;
-
-    return Z_OK;
-}
-
-/* ===========================================================================
- * Read a new buffer from the current input stream, update the adler32
- * and total number of bytes read.  All deflate() input goes through
- * this function so some applications may wish to modify it to avoid
- * allocating a large strm->next_in buffer and copying from it.
- * (See also flush_pending()).
- */
-ZLIB_INTERNAL int read_buf(z_stream *strm, unsigned char *buf, unsigned size) {
-    uint32_t len = strm->avail_in;
-
-    if (len > size)
-        len = size;
-    if (len == 0)
-        return 0;
-
-    strm->avail_in  -= len;
-
-#ifdef GZIP
-    if (strm->state->wrap == 2)
-        copy_with_crc(strm, buf, len);
-    else
-#endif
-    {
-        memcpy(buf, strm->next_in, len);
-        if (strm->state->wrap == 1)
-            strm->adler = adler32(strm->adler, buf, len);
-    }
-    strm->next_in  += len;
-    strm->total_in += len;
-
-    return (int)len;
-}
-
-/* ===========================================================================
- * Initialize the "longest match" routines for a new zlib stream
- */
-local void lm_init(deflate_state *s) {
-    s->window_size = (unsigned long)2L*s->w_size;
-
-    CLEAR_HASH(s);
-
-    /* Set the default configuration parameters:
-     */
-    s->max_lazy_match   = configuration_table[s->level].max_lazy;
-    s->good_match       = configuration_table[s->level].good_length;
-    s->nice_match       = configuration_table[s->level].nice_length;
-    s->max_chain_length = configuration_table[s->level].max_chain;
-
-    s->strstart = 0;
-    s->block_start = 0L;
-    s->lookahead = 0;
-    s->insert = 0;
-    s->match_length = s->prev_length = MIN_MATCH-1;
-    s->match_available = 0;
-    s->ins_h = 0;
-}
-
-#ifdef DEBUG
-/* ===========================================================================
- * Check that the match at match_start is indeed a match.
- */
-void check_match(deflate_state *s, IPos start, IPos match, int length) {
-    /* check that the match is indeed a match */
-    if (memcmp(s->window + match, s->window + start, length) != EQUAL) {
-        fprintf(stderr, " start %u, match %u, length %d\n", start, match, length);
-        do {
-            fprintf(stderr, "%c%c", s->window[match++], s->window[start++]);
-        } while (--length != 0);
-        z_error("invalid match");
-    }
-    if (z_verbose > 1) {
-        fprintf(stderr, "\\[%u,%d]", start-match, length);
-        do {
-            putc(s->window[start++], stderr);
-        } while (--length != 0);
-    }
-}
-#else
-#  define check_match(s, start, match, length)
-#endif /* DEBUG */
-
-/* ===========================================================================
- * Fill the window when the lookahead becomes insufficient.
- * Updates strstart and lookahead.
- *
- * IN assertion: lookahead < MIN_LOOKAHEAD
- * OUT assertions: strstart <= window_size-MIN_LOOKAHEAD
- *    At least one byte has been read, or avail_in == 0; reads are
- *    performed for at least two bytes (required for the zip translate_eol
- *    option -- not supported here).
- */
-#ifdef X86_SSE2_FILL_WINDOW
-extern void fill_window_sse(deflate_state *s);
-#endif
-void fill_window_c(deflate_state *s);
-
-void fill_window(deflate_state *s) {
-#ifdef X86_SSE2_FILL_WINDOW
-# ifndef X86_NOCHECK_SSE2
-    if (x86_cpu_has_sse2) {
-# endif
-        fill_window_sse(s);
-# ifndef X86_NOCHECK_SSE2
-    } else {
-        fill_window_c(s);
-    }
-# endif
-
-#else
-    fill_window_c(s);
-#endif
-}
-
-void fill_window_c(deflate_state *s) {
-    register unsigned n;
-    register Pos *p;
-    unsigned more;    /* Amount of free space at the end of the window. */
-    unsigned int wsize = s->w_size;
-
-    Assert(s->lookahead < MIN_LOOKAHEAD, "already enough lookahead");
-
-    do {
-        more = (unsigned)(s->window_size -(unsigned long)s->lookahead -(unsigned long)s->strstart);
-
-        /* If the window is almost full and there is insufficient lookahead,
-         * move the upper half to the lower one to make room in the upper half.
-         */
-        if (s->strstart >= wsize+MAX_DIST(s)) {
-            memcpy(s->window, s->window+wsize, (unsigned)wsize);
-            s->match_start -= wsize;
-            s->strstart    -= wsize; /* we now have strstart >= MAX_DIST */
-            s->block_start -= (long) wsize;
-
-            /* Slide the hash table (could be avoided with 32 bit values
-               at the expense of memory usage). We slide even when level == 0
-               to keep the hash table consistent if we switch back to level > 0
-               later. (Using level 0 permanently is not an optimal usage of
-               zlib, so we don't care about this pathological case.)
-             */
-            n = s->hash_size;
-            p = &s->head[n];
-#ifdef NOT_TWEAK_COMPILER
-            do {
-                unsigned m;
-                m = *--p;
-                *p = (Pos)(m >= wsize ? m-wsize : NIL);
-            } while (--n);
-#else
-            /* As of I make this change, gcc (4.8.*) isn't able to vectorize
-             * this hot loop using saturated-subtraction on x86-64 architecture.
-             * To avoid this defect, we can change the loop such that
-             *    o. the pointer advance forward, and
-             *    o. demote the variable 'm' to be local to the loop, and
-             *       choose type "Pos" (instead of 'unsigned int') for the
-             *       variable to avoid unncessary zero-extension.
-             */
-            {
-                unsigned int i;
-                Pos *q = p - n;
-                for (i = 0; i < n; i++) {
-                    Pos m = *q;
-                    Pos t = wsize;
-                    *q++ = (Pos)(m >= t ? m-t: NIL);
-                }
-            }
-
-#endif /* NOT_TWEAK_COMPILER */
-            n = wsize;
-            p = &s->prev[n];
-#ifdef NOT_TWEAK_COMPILER
-            do {
-                unsigned m;
-                m = *--p;
-                *p = (Pos)(m >= wsize ? m-wsize : NIL);
-                /* If n is not on any hash chain, prev[n] is garbage but
-                 * its value will never be used.
-                 */
-            } while (--n);
-#else
-            {
-                unsigned int i;
-                Pos *q = p - n;
-                for (i = 0; i < n; i++) {
-                    Pos m = *q;
-                    Pos t = wsize;
-                    *q++ = (Pos)(m >= t ? m-t: NIL);
-                }
-            }
-#endif /* NOT_TWEAK_COMPILER */
-            more += wsize;
-        }
-        if (s->strm->avail_in == 0)
-            break;
-
-        /* If there was no sliding:
-         *    strstart <= WSIZE+MAX_DIST-1 && lookahead <= MIN_LOOKAHEAD - 1 &&
-         *    more == window_size - lookahead - strstart
-         * => more >= window_size - (MIN_LOOKAHEAD-1 + WSIZE + MAX_DIST-1)
-         * => more >= window_size - 2*WSIZE + 2
-         * In the BIG_MEM or MMAP case (not yet supported),
-         *   window_size == input_size + MIN_LOOKAHEAD  &&
-         *   strstart + s->lookahead <= input_size => more >= MIN_LOOKAHEAD.
-         * Otherwise, window_size == 2*WSIZE so more >= 2.
-         * If there was sliding, more >= WSIZE. So in all cases, more >= 2.
-         */
-        Assert(more >= 2, "more < 2");
-
-        n = read_buf(s->strm, s->window + s->strstart + s->lookahead, more);
-        s->lookahead += n;
-
-        /* Initialize the hash value now that we have some input: */
-        if (s->lookahead + s->insert >= MIN_MATCH) {
-            unsigned int str = s->strstart - s->insert;
-            s->ins_h = s->window[str];
-            if (str >= 1)
-                UPDATE_HASH(s, s->ins_h, str + 1 - (MIN_MATCH-1));
-#if MIN_MATCH != 3
-            Call UPDATE_HASH() MIN_MATCH-3 more times
-#endif
-            while (s->insert) {
-                UPDATE_HASH(s, s->ins_h, str);
-                s->prev[str & s->w_mask] = s->head[s->ins_h];
-                s->head[s->ins_h] = (Pos)str;
-                str++;
-                s->insert--;
-                if (s->lookahead + s->insert < MIN_MATCH)
-                    break;
-            }
-        }
-        /* If the whole input has less than MIN_MATCH bytes, ins_h is garbage,
-         * but this is not important since only literal bytes will be emitted.
-         */
-    } while (s->lookahead < MIN_LOOKAHEAD && s->strm->avail_in != 0);
-
-    /* If the WIN_INIT bytes after the end of the current data have never been
-     * written, then zero those bytes in order to avoid memory check reports of
-     * the use of uninitialized (or uninitialised as Julian writes) bytes by
-     * the longest match routines.  Update the high water mark for the next
-     * time through here.  WIN_INIT is set to MAX_MATCH since the longest match
-     * routines allow scanning to strstart + MAX_MATCH, ignoring lookahead.
-     */
-    if (s->high_water < s->window_size) {
-        unsigned long curr = s->strstart + (unsigned long)(s->lookahead);
-        unsigned long init;
-
-        if (s->high_water < curr) {
-            /* Previous high water mark below current data -- zero WIN_INIT
-             * bytes or up to end of window, whichever is less.
-             */
-            init = s->window_size - curr;
-            if (init > WIN_INIT)
-                init = WIN_INIT;
-            memset(s->window + curr, 0, (unsigned)init);
-            s->high_water = curr + init;
-        } else if (s->high_water < (unsigned long)curr + WIN_INIT) {
-            /* High water mark at or above current data, but below current data
-             * plus WIN_INIT -- zero out to current data plus WIN_INIT, or up
-             * to end of window, whichever is less.
-             */
-            init = (unsigned long)curr + WIN_INIT - s->high_water;
-            if (init > s->window_size - s->high_water)
-                init = s->window_size - s->high_water;
-            memset(s->window + s->high_water, 0, (unsigned)init);
-            s->high_water += init;
-        }
-    }
-
-    Assert((unsigned long)s->strstart <= s->window_size - MIN_LOOKAHEAD,
-           "not enough room for search");
-}
-
-/* ===========================================================================
- * Copy without compression as much as possible from the input stream, return
- * the current block state.
- * This function does not insert new strings in the dictionary since
- * uncompressible data is probably not useful. This function is used
- * only for the level=0 compression option.
- * NOTE: this function should be optimized to avoid extra copying from
- * window to pending_buf.
- */
-local block_state deflate_stored(deflate_state *s, int flush) {
-    /* Stored blocks are limited to 0xffff bytes, pending_buf is limited
-     * to pending_buf_size, and each stored block has a 5 byte header:
-     */
-    unsigned long max_block_size = 0xffff;
-    unsigned long max_start;
-
-    if (max_block_size > s->pending_buf_size - 5) {
-        max_block_size = (uint32_t)(s->pending_buf_size - 5);
-    }
-
-    /* Copy as much as possible from input to output: */
-    for (;;) {
-        /* Fill the window as much as possible: */
-        if (s->lookahead <= 1) {
-            Assert(s->strstart < s->w_size+MAX_DIST(s) || s->block_start >= (long)s->w_size, "slide too late");
-
-            fill_window(s);
-            if (s->lookahead == 0 && flush == Z_NO_FLUSH)
-                return need_more;
-
-            if (s->lookahead == 0)
-                break; /* flush the current block */
-        }
-        Assert(s->block_start >= 0L, "block gone");
-
-        s->strstart += s->lookahead;
-        s->lookahead = 0;
-
-        /* Emit a stored block if pending_buf will be full: */
-        max_start = s->block_start + max_block_size;
-        if (s->strstart == 0 || (unsigned long)s->strstart >= max_start) {
-            /* strstart == 0 is possible when wraparound on 16-bit machine */
-            s->lookahead = (unsigned int)(s->strstart - max_start);
-            s->strstart = (unsigned int)max_start;
-            FLUSH_BLOCK(s, 0);
-        }
-        /* Flush if we may have to slide, otherwise block_start may become
-         * negative and the data will be gone:
-         */
-        if (s->strstart - (unsigned int)s->block_start >= MAX_DIST(s)) {
-            FLUSH_BLOCK(s, 0);
-        }
-    }
-    s->insert = 0;
-    if (flush == Z_FINISH) {
-        FLUSH_BLOCK(s, 1);
-        return finish_done;
-    }
-    if ((long)s->strstart > s->block_start)
-        FLUSH_BLOCK(s, 0);
-    return block_done;
-}
-
-
-/* ===========================================================================
- * For Z_RLE, simply look for runs of bytes, generate matches only of distance
- * one.  Do not maintain a hash table.  (It will be regenerated if this run of
- * deflate switches away from Z_RLE.)
- */
-local block_state deflate_rle(deflate_state *s, int flush) {
-    int bflush;                     /* set if current block must be flushed */
-    unsigned int prev;              /* byte at distance one to match */
-    unsigned char *scan, *strend;   /* scan goes up to strend for length of run */
-
-    for (;;) {
-        /* Make sure that we always have enough lookahead, except
-         * at the end of the input file. We need MAX_MATCH bytes
-         * for the longest run, plus one for the unrolled loop.
-         */
-        if (s->lookahead <= MAX_MATCH) {
-            fill_window(s);
-            if (s->lookahead <= MAX_MATCH && flush == Z_NO_FLUSH) {
-                return need_more;
-            }
-            if (s->lookahead == 0)
-                break; /* flush the current block */
-        }
-
-        /* See how many times the previous byte repeats */
-        s->match_length = 0;
-        if (s->lookahead >= MIN_MATCH && s->strstart > 0) {
-            scan = s->window + s->strstart - 1;
-            prev = *scan;
-            if (prev == *++scan && prev == *++scan && prev == *++scan) {
-                strend = s->window + s->strstart + MAX_MATCH;
-                do {
-                } while (prev == *++scan && prev == *++scan &&
-                         prev == *++scan && prev == *++scan &&
-                         prev == *++scan && prev == *++scan &&
-                         prev == *++scan && prev == *++scan &&
-                         scan < strend);
-                s->match_length = MAX_MATCH - (int)(strend - scan);
-                if (s->match_length > s->lookahead)
-                    s->match_length = s->lookahead;
-            }
-            Assert(scan <= s->window+(unsigned int)(s->window_size-1), "wild scan");
-        }
-
-        /* Emit match if have run of MIN_MATCH or longer, else emit literal */
-        if (s->match_length >= MIN_MATCH) {
-            check_match(s, s->strstart, s->strstart - 1, s->match_length);
-
-            _tr_tally_dist(s, 1, s->match_length - MIN_MATCH, bflush);
-
-            s->lookahead -= s->match_length;
-            s->strstart += s->match_length;
-            s->match_length = 0;
-        } else {
-            /* No match, output a literal byte */
-            Tracevv((stderr, "%c", s->window[s->strstart]));
-            _tr_tally_lit(s, s->window[s->strstart], bflush);
-            s->lookahead--;
-            s->strstart++;
-        }
-        if (bflush)
-            FLUSH_BLOCK(s, 0);
-    }
-    s->insert = 0;
-    if (flush == Z_FINISH) {
-        FLUSH_BLOCK(s, 1);
-        return finish_done;
-    }
-    if (s->last_lit)
-        FLUSH_BLOCK(s, 0);
-    return block_done;
-}
-
-/* ===========================================================================
- * For Z_HUFFMAN_ONLY, do not look for matches.  Do not maintain a hash table.
- * (It will be regenerated if this run of deflate switches away from Huffman.)
- */
-local block_state deflate_huff(deflate_state *s, int flush) {
-    int bflush;             /* set if current block must be flushed */
-
-    for (;;) {
-        /* Make sure that we have a literal to write. */
-        if (s->lookahead == 0) {
-            fill_window(s);
-            if (s->lookahead == 0) {
-                if (flush == Z_NO_FLUSH)
-                    return need_more;
-                break;      /* flush the current block */
-            }
-        }
-
-        /* Output a literal byte */
-        s->match_length = 0;
-        Tracevv((stderr, "%c", s->window[s->strstart]));
-        _tr_tally_lit(s, s->window[s->strstart], bflush);
-        s->lookahead--;
-        s->strstart++;
-        if (bflush)
-            FLUSH_BLOCK(s, 0);
-    }
-    s->insert = 0;
-    if (flush == Z_FINISH) {
-        FLUSH_BLOCK(s, 1);
-        return finish_done;
-    }
-    if (s->last_lit)
-        FLUSH_BLOCK(s, 0);
-    return block_done;
-}
diff --git a/contrib/libzlib-ng/deflate.h b/contrib/libzlib-ng/deflate.h
deleted file mode 100644
index 2d3202641d8..00000000000
--- a/contrib/libzlib-ng/deflate.h
+++ /dev/null
@@ -1,459 +0,0 @@
-#ifndef DEFLATE_H_
-#define DEFLATE_H_
-/* deflate.h -- internal compression state
- * Copyright (C) 1995-2012 Jean-loup Gailly
- * For conditions of distribution and use, see copyright notice in zlib.h
- */
-
-/* WARNING: this file should *not* be used by applications. It is
-   part of the implementation of the compression library and is
-   subject to change. Applications should only use zlib.h.
- */
-
-/* @(#) $Id$ */
-
-#include "zutil.h"
-
-/* define NO_GZIP when compiling if you want to disable gzip header and
-   trailer creation by deflate().  NO_GZIP would be used to avoid linking in
-   the crc code when it is not needed.  For shared libraries, gzip encoding
-   should be left enabled. */
-#ifndef NO_GZIP
-#  define GZIP
-#endif
-
-#define NIL 0
-/* Tail of hash chains */
-
-
-/* ===========================================================================
- * Internal compression state.
- */
-
-#define LENGTH_CODES 29
-/* number of length codes, not counting the special END_BLOCK code */
-
-#define LITERALS  256
-/* number of literal bytes 0..255 */
-
-#define L_CODES (LITERALS+1+LENGTH_CODES)
-/* number of Literal or Length codes, including the END_BLOCK code */
-
-#define D_CODES   30
-/* number of distance codes */
-
-#define BL_CODES  19
-/* number of codes used to transfer the bit lengths */
-
-#define HEAP_SIZE (2*L_CODES+1)
-/* maximum heap size */
-
-#define MAX_BITS 15
-/* All codes must not exceed MAX_BITS bits */
-
-#define Buf_size 16
-/* size of bit buffer in bi_buf */
-
-#define END_BLOCK 256
-/* end of block literal code */
-
-#define INIT_STATE    42
-#define EXTRA_STATE   69
-#define NAME_STATE    73
-#define COMMENT_STATE 91
-#define HCRC_STATE   103
-#define BUSY_STATE   113
-#define FINISH_STATE 666
-/* Stream status */
-
-
-/* Data structure describing a single value and its code string. */
-typedef struct ct_data_s {
-    union {
-        uint16_t  freq;       /* frequency count */
-        uint16_t  code;       /* bit string */
-    } fc;
-    union {
-        uint16_t  dad;        /* father node in Huffman tree */
-        uint16_t  len;        /* length of bit string */
-    } dl;
-} ct_data;
-
-#define Freq fc.freq
-#define Code fc.code
-#define Dad  dl.dad
-#define Len  dl.len
-
-typedef struct static_tree_desc_s  static_tree_desc;
-
-typedef struct tree_desc_s {
-    ct_data *dyn_tree;           /* the dynamic tree */
-    int     max_code;            /* largest code with non zero frequency */
-    const static_tree_desc *stat_desc; /* the corresponding static tree */
-} tree_desc;
-
-typedef uint16_t Pos;
-typedef unsigned IPos;
-
-/* A Pos is an index in the character window. We use short instead of int to
- * save space in the various tables. IPos is used only for parameter passing.
- */
-
-typedef struct internal_state {
-    z_stream      *strm;             /* pointer back to this zlib stream */
-    int           status;            /* as the name implies */
-    unsigned char *pending_buf;      /* output still pending */
-    unsigned long pending_buf_size;  /* size of pending_buf */
-    unsigned char *pending_out;      /* next pending byte to output to the stream */
-    unsigned int  pending;           /* nb of bytes in the pending buffer */
-    int           wrap;              /* bit 0 true for zlib, bit 1 true for gzip */
-    gz_headerp    gzhead;            /* gzip header information to write */
-    unsigned int  gzindex;           /* where in extra, name, or comment */
-    unsigned char method;            /* can only be DEFLATED */
-    int           last_flush;        /* value of flush param for previous deflate call */
-
-#ifdef X86_PCLMULQDQ_CRC
-    unsigned ALIGNED_(16) crc0[4 * 5];
-#endif
-
-                /* used by deflate.c: */
-
-    unsigned int  w_size;            /* LZ77 window size (32K by default) */
-    unsigned int  w_bits;            /* log2(w_size)  (8..16) */
-    unsigned int  w_mask;            /* w_size - 1 */
-
-    unsigned char *window;
-    /* Sliding window. Input bytes are read into the second half of the window,
-     * and move to the first half later to keep a dictionary of at least wSize
-     * bytes. With this organization, matches are limited to a distance of
-     * wSize-MAX_MATCH bytes, but this ensures that IO is always
-     * performed with a length multiple of the block size. Also, it limits
-     * the window size to 64K, which is quite useful on MSDOS.
-     * To do: use the user input buffer as sliding window.
-     */
-
-    unsigned long window_size;
-    /* Actual size of window: 2*wSize, except when the user input buffer
-     * is directly used as sliding window.
-     */
-
-    Pos *prev;
-    /* Link to older string with same hash index. To limit the size of this
-     * array to 64K, this link is maintained only for the last 32K strings.
-     * An index in this array is thus a window index modulo 32K.
-     */
-
-    Pos *head; /* Heads of the hash chains or NIL. */
-
-    unsigned int  ins_h;             /* hash index of string to be inserted */
-    unsigned int  hash_size;         /* number of elements in hash table */
-    unsigned int  hash_bits;         /* log2(hash_size) */
-    unsigned int  hash_mask;         /* hash_size-1 */
-
-    unsigned int  hash_shift;
-    /* Number of bits by which ins_h must be shifted at each input
-     * step. It must be such that after MIN_MATCH steps, the oldest
-     * byte no longer takes part in the hash key, that is:
-     *   hash_shift * MIN_MATCH >= hash_bits
-     */
-
-    long block_start;
-    /* Window position at the beginning of the current output block. Gets
-     * negative when the window is moved backwards.
-     */
-
-    unsigned int match_length;       /* length of best match */
-    IPos         prev_match;         /* previous match */
-    int          match_available;    /* set if previous match exists */
-    unsigned int strstart;           /* start of string to insert */
-    unsigned int match_start;        /* start of matching string */
-    unsigned int lookahead;          /* number of valid bytes ahead in window */
-
-    unsigned int prev_length;
-    /* Length of the best match at previous step. Matches not greater than this
-     * are discarded. This is used in the lazy match evaluation.
-     */
-
-    unsigned int max_chain_length;
-    /* To speed up deflation, hash chains are never searched beyond this
-     * length.  A higher limit improves compression ratio but degrades the
-     * speed.
-     */
-
-    unsigned int max_lazy_match;
-    /* Attempt to find a better match only when the current match is strictly
-     * smaller than this value. This mechanism is used only for compression
-     * levels >= 4.
-     */
-#   define max_insert_length  max_lazy_match
-    /* Insert new strings in the hash table only if the match length is not
-     * greater than this length. This saves time but degrades compression.
-     * max_insert_length is used only for compression levels <= 3.
-     */
-
-    int level;    /* compression level (1..9) */
-    int strategy; /* favor or force Huffman coding*/
-
-    unsigned int good_match;
-    /* Use a faster search when the previous match is longer than this */
-
-    int nice_match; /* Stop searching when current match exceeds this */
-
-                /* used by trees.c: */
-    /* Didn't use ct_data typedef below to suppress compiler warning */
-    struct ct_data_s dyn_ltree[HEAP_SIZE];   /* literal and length tree */
-    struct ct_data_s dyn_dtree[2*D_CODES+1]; /* distance tree */
-    struct ct_data_s bl_tree[2*BL_CODES+1];  /* Huffman tree for bit lengths */
-
-    struct tree_desc_s l_desc;               /* desc. for literal tree */
-    struct tree_desc_s d_desc;               /* desc. for distance tree */
-    struct tree_desc_s bl_desc;              /* desc. for bit length tree */
-
-    uint16_t bl_count[MAX_BITS+1];
-    /* number of codes at each bit length for an optimal tree */
-
-    int heap[2*L_CODES+1];      /* heap used to build the Huffman trees */
-    int heap_len;               /* number of elements in the heap */
-    int heap_max;               /* element of largest frequency */
-    /* The sons of heap[n] are heap[2*n] and heap[2*n+1]. heap[0] is not used.
-     * The same heap array is used to build all trees.
-     */
-
-    unsigned char depth[2*L_CODES+1];
-    /* Depth of each subtree used as tie breaker for trees of equal frequency
-     */
-
-    unsigned char *l_buf;       /* buffer for literals or lengths */
-
-    unsigned int  lit_bufsize;
-    /* Size of match buffer for literals/lengths.  There are 4 reasons for
-     * limiting lit_bufsize to 64K:
-     *   - frequencies can be kept in 16 bit counters
-     *   - if compression is not successful for the first block, all input
-     *     data is still in the window so we can still emit a stored block even
-     *     when input comes from standard input.  (This can also be done for
-     *     all blocks if lit_bufsize is not greater than 32K.)
-     *   - if compression is not successful for a file smaller than 64K, we can
-     *     even emit a stored file instead of a stored block (saving 5 bytes).
-     *     This is applicable only for zip (not gzip or zlib).
-     *   - creating new Huffman trees less frequently may not provide fast
-     *     adaptation to changes in the input data statistics. (Take for
-     *     example a binary file with poorly compressible code followed by
-     *     a highly compressible string table.) Smaller buffer sizes give
-     *     fast adaptation but have of course the overhead of transmitting
-     *     trees more frequently.
-     *   - I can't count above 4
-     */
-
-    unsigned int last_lit;        /* running index in l_buf */
-
-    uint16_t *d_buf;
-    /* Buffer for distances. To simplify the code, d_buf and l_buf have
-     * the same number of elements. To use different lengths, an extra flag
-     * array would be necessary.
-     */
-
-    unsigned long opt_len;        /* bit length of current block with optimal trees */
-    unsigned long static_len;     /* bit length of current block with static trees */
-    unsigned int matches;         /* number of string matches in current block */
-    unsigned int insert;          /* bytes at end of window left to insert */
-
-#ifdef DEBUG
-    unsigned long compressed_len; /* total bit length of compressed file mod 2^32 */
-    unsigned long bits_sent;      /* bit length of compressed data sent mod 2^32 */
-#endif
-
-    uint16_t bi_buf;
-    /* Output buffer. bits are inserted starting at the bottom (least
-     * significant bits).
-     */
-    int bi_valid;
-    /* Number of valid bits in bi_buf.  All bits above the last valid bit
-     * are always zero.
-     */
-
-    unsigned long high_water;
-    /* High water mark offset in window for initialized bytes -- bytes above
-     * this are set to zero in order to avoid memory check warnings when
-     * longest match routines access bytes past the input.  This is then
-     * updated to the new high water mark.
-     */
-} deflate_state;
-
-typedef enum {
-    need_more,      /* block not completed, need more input or more output */
-    block_done,     /* block flush performed */
-    finish_started, /* finish started, need only more output at next deflate */
-    finish_done     /* finish done, accept no more input or output */
-} block_state;
-
-/* Output a byte on the stream.
- * IN assertion: there is enough room in pending_buf.
- */
-#define put_byte(s, c) {s->pending_buf[s->pending++] = (c);}
-
-/* ===========================================================================
- * Output a short LSB first on the stream.
- * IN assertion: there is enough room in pendingBuf.
- */
-#if defined(__x86_64) || defined(__i386_)
-/* Compared to the else-clause's implementation, there are few advantages:
- *  - s->pending is loaded only once (else-clause's implementation needs to
- *    load s->pending twice due to the alias between s->pending and
- *    s->pending_buf[].
- *  - no instructions for extracting bytes from short.
- *  - needs less registers
- *  - stores to adjacent bytes are merged into a single store, albeit at the
- *    cost of penalty of potentially unaligned access. 
- */
-#define put_short(s, w) { \
-    s->pending += 2; \
-    *(uint16_t*)(&s->pending_buf[s->pending - 2]) = (w) ; \
-}
-#else
-#define put_short(s, w) { \
-    put_byte(s, (unsigned char)((w) & 0xff)); \
-    put_byte(s, (unsigned char)((uint16_t)(w) >> 8)); \
-}
-#endif
-
-#define MIN_LOOKAHEAD (MAX_MATCH+MIN_MATCH+1)
-/* Minimum amount of lookahead, except at the end of the input file.
- * See deflate.c for comments about the MIN_MATCH+1.
- */
-
-#define MAX_DIST(s)  ((s)->w_size-MIN_LOOKAHEAD)
-/* In order to simplify the code, particularly on 16 bit machines, match
- * distances are limited to MAX_DIST instead of WSIZE.
- */
-
-#define WIN_INIT MAX_MATCH
-/* Number of bytes after end of data in window to initialize in order to avoid
-   memory checker errors from longest match routines */
-
-        /* in trees.c */
-void ZLIB_INTERNAL _tr_init(deflate_state *s);
-int ZLIB_INTERNAL _tr_tally(deflate_state *s, unsigned dist, unsigned lc);
-void ZLIB_INTERNAL _tr_flush_block(deflate_state *s, char *buf, unsigned long stored_len, int last);
-void ZLIB_INTERNAL _tr_flush_bits(deflate_state *s);
-void ZLIB_INTERNAL _tr_align(deflate_state *s);
-void ZLIB_INTERNAL _tr_stored_block(deflate_state *s, char *buf, unsigned long stored_len, int last);
-void ZLIB_INTERNAL bi_windup(deflate_state *s);
-
-#define d_code(dist) ((dist) < 256 ? _dist_code[dist] : _dist_code[256+((dist)>>7)])
-/* Mapping from a distance to a distance code. dist is the distance - 1 and
- * must not have side effects. _dist_code[256] and _dist_code[257] are never
- * used.
- */
-
-#ifndef DEBUG
-/* Inline versions of _tr_tally for speed: */
-
-# if defined(GEN_TREES_H)
-    extern unsigned char ZLIB_INTERNAL _length_code[];
-    extern unsigned char ZLIB_INTERNAL _dist_code[];
-# else
-    extern const unsigned char ZLIB_INTERNAL _length_code[];
-    extern const unsigned char ZLIB_INTERNAL _dist_code[];
-# endif
-
-# define _tr_tally_lit(s, c, flush) \
-  { unsigned char cc = (c); \
-    s->d_buf[s->last_lit] = 0; \
-    s->l_buf[s->last_lit++] = cc; \
-    s->dyn_ltree[cc].Freq++; \
-    flush = (s->last_lit == s->lit_bufsize-1); \
-  }
-# define _tr_tally_dist(s, distance, length, flush) \
-  { unsigned char len = (length); \
-    uint16_t dist = (distance); \
-    s->d_buf[s->last_lit] = dist; \
-    s->l_buf[s->last_lit++] = len; \
-    dist--; \
-    s->dyn_ltree[_length_code[len]+LITERALS+1].Freq++; \
-    s->dyn_dtree[d_code(dist)].Freq++; \
-    flush = (s->last_lit == s->lit_bufsize-1); \
-  }
-#else
-#   define _tr_tally_lit(s, c, flush) flush = _tr_tally(s, 0, c)
-#   define _tr_tally_dist(s, distance, length, flush) \
-              flush = _tr_tally(s, distance, length)
-#endif
-
-/* ===========================================================================
- * Update a hash value with the given input byte
- * IN  assertion: all calls to to UPDATE_HASH are made with consecutive
- *    input characters, so that a running hash key can be computed from the
- *    previous key instead of complete recalculation each time.
- */
-#ifdef X86_SSE4_2_CRC_HASH
-#define UPDATE_HASH(s, h, i) \
-    do {\
-        if (s->level < 6) \
-            h = (3483 * (s->window[i]) +\
-                 23081* (s->window[i+1]) +\
-                 6954 * (s->window[i+2]) +\
-                 20947* (s->window[i+3])) & s->hash_mask;\
-        else\
-            h = (25881* (s->window[i]) +\
-                 24674* (s->window[i+1]) +\
-                 25811* (s->window[i+2])) & s->hash_mask;\
-    } while (0)
-#else
-#   define UPDATE_HASH(s, h, i) (h = (((h) << s->hash_shift) ^ (s->window[i + (MIN_MATCH-1)])) & s->hash_mask)
-#endif
-
-#ifndef DEBUG
-#  define send_code(s, c, tree) send_bits(s, tree[c].Code, tree[c].Len)
-/* Send a code of the given tree. c and tree must not have side effects */
-
-#else /* DEBUG */
-#  define send_code(s, c, tree) \
-    {  if (z_verbose > 2) { \
-           fprintf(stderr, "\ncd %3d ", (c)); \
-       } \
-       send_bits(s, tree[c].Code, tree[c].Len); \
-     }
-#endif
-
-#ifdef DEBUG
-/* ===========================================================================
- * Send a value on a given number of bits.
- * IN assertion: length <= 16 and value fits in length bits.
- */
-local void send_bits(deflate_state *s, int value, int length) {
-    Tracevv((stderr, " l %2d v %4x ", length, value));
-    Assert(length > 0 && length <= 15, "invalid length");
-    s->bits_sent += (unsigned long)length;
-
-    /* If not enough room in bi_buf, use (valid) bits from bi_buf and
-     * (16 - bi_valid) bits from value, leaving (width - (16-bi_valid))
-     * unused bits in value.
-     */
-    if (s->bi_valid > (int)Buf_size - length) {
-        s->bi_buf |= (uint16_t)value << s->bi_valid;
-        put_short(s, s->bi_buf);
-        s->bi_buf = (uint16_t)value >> (Buf_size - s->bi_valid);
-        s->bi_valid += length - Buf_size;
-    } else {
-        s->bi_buf |= (uint16_t)value << s->bi_valid;
-        s->bi_valid += length;
-    }
-}
-#else
-#define send_bits(s, value, length) \
-{ int len = length;\
-  if (s->bi_valid > (int)Buf_size - len) {\
-    int val = value;\
-    s->bi_buf |= (uint16_t)val << s->bi_valid;\
-    put_short(s, s->bi_buf);\
-    s->bi_buf = (uint16_t)val >> (Buf_size - s->bi_valid);\
-    s->bi_valid += len - Buf_size;\
-  } else {\
-    s->bi_buf |= (uint16_t)(value) << s->bi_valid;\
-    s->bi_valid += len;\
-  }\
-}
-#endif
-
-#endif /* DEFLATE_H_ */
diff --git a/contrib/libzlib-ng/deflate_fast.c b/contrib/libzlib-ng/deflate_fast.c
deleted file mode 100644
index edfe53d7f7d..00000000000
--- a/contrib/libzlib-ng/deflate_fast.c
+++ /dev/null
@@ -1,114 +0,0 @@
-/* deflate_fast.c -- compress data using the fast strategy of deflation algorithm
- *
- * Copyright (C) 1995-2013 Jean-loup Gailly and Mark Adler
- * For conditions of distribution and use, see copyright notice in zlib.h
- */
-
-#include "deflate.h"
-#include "deflate_p.h"
-#include "match.h"
-
-/* ===========================================================================
- * Compress as much as possible from the input stream, return the current
- * block state.
- * This function does not perform lazy evaluation of matches and inserts
- * new strings in the dictionary only for unmatched strings or for short
- * matches. It is used only for the fast compression options.
- */
-block_state deflate_fast(deflate_state *s, int flush) {
-    IPos hash_head;       /* head of the hash chain */
-    int bflush;           /* set if current block must be flushed */
-
-    for (;;) {
-        /* Make sure that we always have enough lookahead, except
-         * at the end of the input file. We need MAX_MATCH bytes
-         * for the next match, plus MIN_MATCH bytes to insert the
-         * string following the next match.
-         */
-        if (s->lookahead < MIN_LOOKAHEAD) {
-            fill_window(s);
-            if (s->lookahead < MIN_LOOKAHEAD && flush == Z_NO_FLUSH) {
-                return need_more;
-            }
-            if (s->lookahead == 0)
-                break; /* flush the current block */
-        }
-
-        /* Insert the string window[strstart .. strstart+2] in the
-         * dictionary, and set hash_head to the head of the hash chain:
-         */
-        hash_head = NIL;
-        if (s->lookahead >= MIN_MATCH) {
-            hash_head = insert_string(s, s->strstart);
-        }
-
-        /* Find the longest match, discarding those <= prev_length.
-         * At this point we have always match_length < MIN_MATCH
-         */
-        if (hash_head != NIL && s->strstart - hash_head <= MAX_DIST(s)) {
-            /* To simplify the code, we prevent matches with the string
-             * of window index 0 (in particular we have to avoid a match
-             * of the string with itself at the start of the input file).
-             */
-            s->match_length = longest_match(s, hash_head);
-            /* longest_match() sets match_start */
-        }
-        if (s->match_length >= MIN_MATCH) {
-            check_match(s, s->strstart, s->match_start, s->match_length);
-
-            _tr_tally_dist(s, s->strstart - s->match_start, s->match_length - MIN_MATCH, bflush);
-
-            s->lookahead -= s->match_length;
-
-            /* Insert new strings in the hash table only if the match length
-             * is not too large. This saves time but degrades compression.
-             */
-            if (s->match_length <= s->max_insert_length && s->lookahead >= MIN_MATCH) {
-                s->match_length--; /* string at strstart already in table */
-                s->strstart++;
-#ifdef NOT_TWEAK_COMPILER
-                do {
-                    insert_string(s, s->strstart);
-                    s->strstart++;
-                    /* strstart never exceeds WSIZE-MAX_MATCH, so there are
-                     * always MIN_MATCH bytes ahead.
-                     */
-                } while (--s->match_length != 0);
-#else
-                {
-                    bulk_insert_str(s, s->strstart, s->match_length);
-                    s->strstart += s->match_length;
-                    s->match_length = 0;
-                }
-#endif
-            } else {
-                s->strstart += s->match_length;
-                s->match_length = 0;
-                s->ins_h = s->window[s->strstart];
-                UPDATE_HASH(s, s->ins_h, s->strstart+2 - (MIN_MATCH));
-#if MIN_MATCH != 3
-                Call UPDATE_HASH() MIN_MATCH-3 more times
-#endif
-                /* If lookahead < MIN_MATCH, ins_h is garbage, but it does not
-                 * matter since it will be recomputed at next deflate call.
-                 */
-            }
-        } else {
-            /* No match, output a literal byte */
-            Tracevv((stderr, "%c", s->window[s->strstart]));
-            _tr_tally_lit(s, s->window[s->strstart], bflush);
-            s->lookahead--;
-            s->strstart++;
-        }
-        if (bflush)
-            FLUSH_BLOCK(s, 0);
-    }
-    s->insert = s->strstart < MIN_MATCH-1 ? s->strstart : MIN_MATCH-1;
-    if (flush == Z_FINISH) {
-        FLUSH_BLOCK(s, 1);
-        return finish_done;
-    }
-    if (s->last_lit)
-        FLUSH_BLOCK(s, 0);
-    return block_done;
-}
diff --git a/contrib/libzlib-ng/deflate_medium.c b/contrib/libzlib-ng/deflate_medium.c
deleted file mode 100644
index 731b8a26850..00000000000
--- a/contrib/libzlib-ng/deflate_medium.c
+++ /dev/null
@@ -1,322 +0,0 @@
-/* deflate_medium.c -- The deflate_medium deflate strategy
- *
- * Copyright (C) 2013 Intel Corporation. All rights reserved.
- * Authors:
- *  Arjan van de Ven    <arjan@linux.intel.com>
- *
- * For conditions of distribution and use, see copyright notice in zlib.h
- */
-#ifdef MEDIUM_STRATEGY
-#include "deflate.h"
-#include "deflate_p.h"
-#include "match.h"
-
-struct match {
-    unsigned int match_start;
-    unsigned int match_length;
-    unsigned int strstart;
-    unsigned int orgstart;
-};
-
-#define MAX_DIST2  ((1 << MAX_WBITS) - MIN_LOOKAHEAD)
-
-static int tr_tally_dist(deflate_state *s, int distance, int length) {
-    return _tr_tally(s, distance, length);
-}
-
-static int tr_tally_lit(deflate_state *s, int c) {
-    return  _tr_tally(s, 0, c);
-}
-
-static int emit_match(deflate_state *s, struct match match) {
-    int flush = 0;
-
-    /* matches that are not long enough we need to emit as litterals */
-    if (match.match_length < MIN_MATCH) {
-        while (match.match_length) {
-            flush += tr_tally_lit(s, s->window[match.strstart]);
-            s->lookahead--;
-            match.strstart++;
-            match.match_length--;
-        }
-        return flush;
-    }
-
-    check_match(s, match.strstart, match.match_start, match.match_length);
-
-    flush += tr_tally_dist(s, match.strstart - match.match_start, match.match_length - MIN_MATCH);
-
-    s->lookahead -= match.match_length;
-    return flush;
-}
-
-static void insert_match(deflate_state *s, struct match match) {
-    if (unlikely(s->lookahead <= match.match_length + MIN_MATCH))
-        return;
-
-    /* matches that are not long enough we need to emit as litterals */
-    if (match.match_length < MIN_MATCH) {
-#ifdef NOT_TWEAK_COMPILER
-        while (match.match_length) {
-            match.strstart++;
-            match.match_length--;
-
-            if (match.match_length) {
-                if (match.strstart >= match.orgstart) {
-                    insert_string(s, match.strstart);
-                }
-            }
-        }
-#else
-        if (likely(match.match_length == 1)) {
-            match.strstart++;
-            match.match_length = 0;
-        }else{
-            match.strstart++;
-            match.match_length--;
-            if (match.strstart >= match.orgstart) {
-                bulk_insert_str(s, match.strstart, match.match_length);
-            }
-            match.strstart += match.match_length;
-            match.match_length = 0;
-        }
-#endif
-        return;
-    }
-
-    /* Insert new strings in the hash table only if the match length
-     * is not too large. This saves time but degrades compression.
-     */
-    if (match.match_length <= 16* s->max_insert_length && s->lookahead >= MIN_MATCH) {
-        match.match_length--; /* string at strstart already in table */
-        match.strstart++;
-#ifdef NOT_TWEAK_COMPILER
-        do {
-            if (likely(match.strstart >= match.orgstart)) {
-                insert_string(s, match.strstart);
-            }
-            match.strstart++;
-            /* strstart never exceeds WSIZE-MAX_MATCH, so there are
-             * always MIN_MATCH bytes ahead.
-             */
-        } while (--match.match_length != 0);
-#else
-        if (likely(match.strstart >= match.orgstart)) {
-            bulk_insert_str(s, match.strstart, match.match_length);
-        }
-        match.strstart += match.match_length;
-        match.match_length = 0;
-#endif
-    } else {
-        match.strstart += match.match_length;
-        match.match_length = 0;
-        s->ins_h = s->window[match.strstart];
-        if (match.strstart >= 1)
-            UPDATE_HASH(s, s->ins_h, match.strstart+2-MIN_MATCH);
-#if MIN_MATCH != 3
-#warning Call UPDATE_HASH() MIN_MATCH-3 more times
-#endif
-    /* If lookahead < MIN_MATCH, ins_h is garbage, but it does not
-     * matter since it will be recomputed at next deflate call.
-     */
-    }
-}
-
-static void fizzle_matches(deflate_state *s, struct match *current, struct match *next) {
-    IPos limit;
-    unsigned char *match, *orig;
-    int changed = 0;
-    struct match c, n;
-    /* step zero: sanity checks */
-
-    if (current->match_length <= 1)
-        return;
-
-    if (unlikely(current->match_length > 1 + next->match_start))
-        return;
-
-    if (unlikely(current->match_length > 1 + next->strstart))
-        return;
-
-    match = s->window - current->match_length + 1 + next->match_start;
-    orig  = s->window - current->match_length + 1 + next->strstart;
-
-    /* quick exit check.. if this fails then don't bother with anything else */
-    if (likely(*match != *orig))
-        return;
-
-    /* check the overlap case and just give up. We can do better in theory,
-     * but unlikely to be worth it
-     */
-    if (next->match_start + next->match_length >= current->strstart)
-        return;
-
-    c = *current;
-    n = *next;
-
-    /* step one: try to move the "next" match to the left as much as possible */
-    limit = next->strstart > MAX_DIST2 ? next->strstart - MAX_DIST2 : 0;
-
-    match = s->window + n.match_start - 1;
-    orig = s->window + n.strstart - 1;
-
-    while (*match == *orig) {
-        if (c.match_length < 1)
-            break;
-        if (n.strstart <= limit)
-            break;
-        if (n.match_length >= 256)
-            break;
-        if (n.match_start <= 0)
-            break;
-
-        n.strstart--;
-        n.match_start--;
-        n.match_length++;
-        c.match_length--;
-        match--;
-        orig--;
-        changed++;
-    }
-
-    if (!changed)
-        return;
-
-    if (c.match_length <= 1 && n.match_length != 2) {
-        n.orgstart++;
-        *current = c;
-        *next = n;
-    } else {
-        return;
-    }
-}
-
-block_state deflate_medium(deflate_state *s, int flush) {
-    struct match current_match, next_match;
-
-    memset(&current_match, 0, sizeof(struct match));
-    memset(&next_match, 0, sizeof(struct match));
-
-    for (;;) {
-        IPos hash_head = 0;   /* head of the hash chain */
-        int bflush;           /* set if current block must be flushed */
-
-        /* Make sure that we always have enough lookahead, except
-         * at the end of the input file. We need MAX_MATCH bytes
-         * for the next match, plus MIN_MATCH bytes to insert the
-         * string following the next current_match.
-         */
-        if (s->lookahead < MIN_LOOKAHEAD) {
-            fill_window(s);
-            if (s->lookahead < MIN_LOOKAHEAD && flush == Z_NO_FLUSH) {
-                return need_more;
-            }
-            if (s->lookahead == 0)
-                break; /* flush the current block */
-            next_match.match_length = 0;
-        }
-        s->prev_length = 2;
-
-        /* Insert the string window[strstart .. strstart+2] in the
-         * dictionary, and set hash_head to the head of the hash chain:
-         */
-
-        /* If we already have a future match from a previous round, just use that */
-        if (next_match.match_length > 0) {
-            current_match = next_match;
-            next_match.match_length = 0;
-
-        } else {
-            hash_head = 0;
-            if (s->lookahead >= MIN_MATCH) {
-                hash_head = insert_string(s, s->strstart);
-            }
-
-            /* set up the initial match to be a 1 byte literal */
-            current_match.match_start = 0;
-            current_match.match_length = 1;
-            current_match.strstart = s->strstart;
-            current_match.orgstart = current_match.strstart;
-
-            /* Find the longest match, discarding those <= prev_length.
-             * At this point we have always match_length < MIN_MATCH
-             */
-
-            if (hash_head != 0 && s->strstart - hash_head <= MAX_DIST2) {
-                /* To simplify the code, we prevent matches with the string
-                 * of window index 0 (in particular we have to avoid a match
-                 * of the string with itself at the start of the input file).
-                 */
-                current_match.match_length = longest_match(s, hash_head);
-                current_match.match_start = s->match_start;
-                if (current_match.match_length < MIN_MATCH)
-                    current_match.match_length = 1;
-                if (current_match.match_start >= current_match.strstart) {
-                    /* this can happen due to some restarts */
-                    current_match.match_length = 1;
-                }
-            }
-        }
-
-        insert_match(s, current_match);
-
-        /* now, look ahead one */
-        if (s->lookahead > MIN_LOOKAHEAD) {
-            s->strstart = current_match.strstart + current_match.match_length;
-            hash_head = insert_string(s, s->strstart);
-
-            /* set up the initial match to be a 1 byte literal */
-            next_match.match_start = 0;
-            next_match.match_length = 1;
-            next_match.strstart = s->strstart;
-            next_match.orgstart = next_match.strstart;
-
-            /* Find the longest match, discarding those <= prev_length.
-             * At this point we have always match_length < MIN_MATCH
-             */
-            if (hash_head != 0 && s->strstart - hash_head <= MAX_DIST2) {
-                /* To simplify the code, we prevent matches with the string
-                 * of window index 0 (in particular we have to avoid a match
-                 * of the string with itself at the start of the input file).
-                 */
-                next_match.match_length = longest_match(s, hash_head);
-                next_match.match_start = s->match_start;
-                if (next_match.match_start >= next_match.strstart) {
-                    /* this can happen due to some restarts */
-                    next_match.match_length = 1;
-                }
-                if (next_match.match_length < MIN_MATCH)
-                    next_match.match_length = 1;
-                else
-                    fizzle_matches(s, &current_match, &next_match);
-            }
-
-            /* short matches with a very long distance are rarely a good idea encoding wise */
-            if (next_match.match_length == 3 && (next_match.strstart - next_match.match_start) > 12000)
-                    next_match.match_length = 1;
-            s->strstart = current_match.strstart;
-
-        } else {
-            next_match.match_length = 0;
-        }
-
-        /* now emit the current match */
-        bflush = emit_match(s, current_match);
-
-        /* move the "cursor" forward */
-        s->strstart += current_match.match_length;
-
-        if (bflush)
-            FLUSH_BLOCK(s, 0);
-    }
-    s->insert = s->strstart < MIN_MATCH-1 ? s->strstart : MIN_MATCH-1;
-    if (flush == Z_FINISH) {
-        FLUSH_BLOCK(s, 1);
-        return finish_done;
-    }
-    if (s->last_lit)
-        FLUSH_BLOCK(s, 0);
-
-    return block_done;
-}
-#endif
diff --git a/contrib/libzlib-ng/deflate_p.h b/contrib/libzlib-ng/deflate_p.h
deleted file mode 100644
index 4b8282d46bc..00000000000
--- a/contrib/libzlib-ng/deflate_p.h
+++ /dev/null
@@ -1,96 +0,0 @@
-/* deflate_p.h -- Private inline functions and macros shared with more than
- *                one deflate method
- *
- * Copyright (C) 1995-2013 Jean-loup Gailly and Mark Adler
- * For conditions of distribution and use, see copyright notice in zlib.h
- *
- */
-
-#ifndef DEFLATE_P_H
-#define DEFLATE_P_H
-
-#if defined(X86_CPUID)
-# include "arch/x86/x86.h"
-#endif
-
-/* Forward declare common non-inlined functions declared in deflate.c */
-
-#ifdef DEBUG
-void check_match(deflate_state *s, IPos start, IPos match, int length);
-#else
-#define check_match(s, start, match, length)
-#endif
-void fill_window(deflate_state *s);
-void flush_pending(z_stream *strm);
-
-/* ===========================================================================
- * Insert string str in the dictionary and set match_head to the previous head
- * of the hash chain (the most recent string with same hash key). Return
- * the previous length of the hash chain.
- * IN  assertion: all calls to to INSERT_STRING are made with consecutive
- *    input characters and the first MIN_MATCH bytes of str are valid
- *    (except for the last MIN_MATCH-1 bytes of the input file).
- */
-
-#ifdef X86_SSE4_2_CRC_HASH
-extern Pos insert_string_sse(deflate_state *const s, const Pos str, uInt count);
-#endif
-
-local inline Pos insert_string_c(deflate_state *const s, const Pos str, uInt count) {
-    Pos ret = 0;
-    uInt idx;
-
-    for (idx = 0; idx < count; idx++) {
-        UPDATE_HASH(s, s->ins_h, str+idx);
-        if (s->head[s->ins_h] != str+idx) {
-            s->prev[(str+idx) & s->w_mask] = s->head[s->ins_h];
-            s->head[s->ins_h] = str+idx;
-        }
-    }
-    ret = s->prev[(str+count-1) & s->w_mask];
-    return ret;
-}
-
-local inline Pos insert_string(deflate_state *const s, const Pos str) {
-#ifdef X86_SSE4_2_CRC_HASH
-    if (x86_cpu_has_sse42)
-        return insert_string_sse(s, str, 1);
-#endif
-    return insert_string_c(s, str, 1);
-}
-
-#ifndef NOT_TWEAK_COMPILER
-local inline void bulk_insert_str(deflate_state *const s, Pos startpos, uInt count) {
-# ifdef X86_SSE4_2_CRC_HASH
-    if (x86_cpu_has_sse42) {
-        insert_string_sse(s, startpos, count);
-    } else
-# endif
-    {
-        insert_string_c(s, startpos, count);
-    }
-}
-#endif /* NOT_TWEAK_COMPILER */
-
-/* ===========================================================================
- * Flush the current block, with given end-of-file flag.
- * IN assertion: strstart is set to the end of the current match.
- */
-#define FLUSH_BLOCK_ONLY(s, last) { \
-    _tr_flush_block(s, (s->block_start >= 0L ? \
-                   (char *)&s->window[(unsigned)s->block_start] : \
-                   (char *)Z_NULL), \
-                   (ulg)((long)s->strstart - s->block_start), \
-                   (last)); \
-    s->block_start = s->strstart; \
-    flush_pending(s->strm); \
-    Tracev((stderr, "[FLUSH]")); \
-}
-
-/* Same but force premature exit if necessary. */
-#define FLUSH_BLOCK(s, last) { \
-    FLUSH_BLOCK_ONLY(s, last); \
-    if (s->strm->avail_out == 0) return (last) ? finish_started : need_more; \
-}
-
-#endif
diff --git a/contrib/libzlib-ng/deflate_slow.c b/contrib/libzlib-ng/deflate_slow.c
deleted file mode 100644
index 6a855f0c837..00000000000
--- a/contrib/libzlib-ng/deflate_slow.c
+++ /dev/null
@@ -1,160 +0,0 @@
-/* deflate_slow.c -- compress data using the slow strategy of deflation algorithm
- *
- * Copyright (C) 1995-2013 Jean-loup Gailly and Mark Adler
- * For conditions of distribution and use, see copyright notice in zlib.h
- */
-
-#include "deflate.h"
-#include "deflate_p.h"
-#include "match.h"
-
-/* ===========================================================================
- * Local data
- */
-
-#ifndef TOO_FAR
-#  define TOO_FAR 4096
-#endif
-/* Matches of length 3 are discarded if their distance exceeds TOO_FAR */
-
-/* ===========================================================================
- * Same as deflate_medium, but achieves better compression. We use a lazy
- * evaluation for matches: a match is finally adopted only if there is
- * no better match at the next window position.
- */
-block_state deflate_slow(deflate_state *s, int flush) {
-    IPos hash_head;          /* head of hash chain */
-    int bflush;              /* set if current block must be flushed */
-
-    /* Process the input block. */
-    for (;;) {
-        /* Make sure that we always have enough lookahead, except
-         * at the end of the input file. We need MAX_MATCH bytes
-         * for the next match, plus MIN_MATCH bytes to insert the
-         * string following the next match.
-         */
-        if (s->lookahead < MIN_LOOKAHEAD) {
-            fill_window(s);
-            if (s->lookahead < MIN_LOOKAHEAD && flush == Z_NO_FLUSH) {
-                return need_more;
-            }
-            if (s->lookahead == 0)
-                break; /* flush the current block */
-        }
-
-        /* Insert the string window[strstart .. strstart+2] in the
-         * dictionary, and set hash_head to the head of the hash chain:
-         */
-        hash_head = NIL;
-        if (s->lookahead >= MIN_MATCH) {
-            hash_head = insert_string(s, s->strstart);
-        }
-
-        /* Find the longest match, discarding those <= prev_length.
-         */
-        s->prev_length = s->match_length, s->prev_match = s->match_start;
-        s->match_length = MIN_MATCH-1;
-
-        if (hash_head != NIL && s->prev_length < s->max_lazy_match && s->strstart - hash_head <= MAX_DIST(s)) {
-            /* To simplify the code, we prevent matches with the string
-             * of window index 0 (in particular we have to avoid a match
-             * of the string with itself at the start of the input file).
-             */
-            s->match_length = longest_match(s, hash_head);
-            /* longest_match() sets match_start */
-
-            if (s->match_length <= 5 && (s->strategy == Z_FILTERED
-#if TOO_FAR <= 32767
-                || (s->match_length == MIN_MATCH && s->strstart - s->match_start > TOO_FAR)
-#endif
-                )) {
-
-                /* If prev_match is also MIN_MATCH, match_start is garbage
-                 * but we will ignore the current match anyway.
-                 */
-                s->match_length = MIN_MATCH-1;
-            }
-        }
-        /* If there was a match at the previous step and the current
-         * match is not better, output the previous match:
-         */
-        if (s->prev_length >= MIN_MATCH && s->match_length <= s->prev_length) {
-            uInt max_insert = s->strstart + s->lookahead - MIN_MATCH;
-            /* Do not insert strings in hash table beyond this. */
-
-            check_match(s, s->strstart-1, s->prev_match, s->prev_length);
-
-            _tr_tally_dist(s, s->strstart -1 - s->prev_match, s->prev_length - MIN_MATCH, bflush);
-
-            /* Insert in hash table all strings up to the end of the match.
-             * strstart-1 and strstart are already inserted. If there is not
-             * enough lookahead, the last two strings are not inserted in
-             * the hash table.
-             */
-            s->lookahead -= s->prev_length-1;
-
-#ifdef NOT_TWEAK_COMPILER
-            s->prev_length -= 2;
-            do {
-                if (++s->strstart <= max_insert) {
-                    insert_string(s, s->strstart);
-                }
-            } while (--s->prev_length != 0);
-            s->match_available = 0;
-            s->match_length = MIN_MATCH-1;
-            s->strstart++;
-#else
-            {
-                uInt mov_fwd = s->prev_length - 2;
-                uInt insert_cnt = mov_fwd;
-                if (unlikely(insert_cnt > max_insert - s->strstart))
-                    insert_cnt = max_insert - s->strstart;
-
-                bulk_insert_str(s, s->strstart + 1, insert_cnt);
-                s->prev_length = 0;
-                s->match_available = 0;
-                s->match_length = MIN_MATCH-1;
-                s->strstart += mov_fwd + 1;
-            }
-#endif /*NOT_TWEAK_COMPILER*/
-
-            if (bflush) FLUSH_BLOCK(s, 0);
-
-        } else if (s->match_available) {
-            /* If there was no match at the previous position, output a
-             * single literal. If there was a match but the current match
-             * is longer, truncate the previous match to a single literal.
-             */
-            Tracevv((stderr, "%c", s->window[s->strstart-1]));
-            _tr_tally_lit(s, s->window[s->strstart-1], bflush);
-            if (bflush) {
-                FLUSH_BLOCK_ONLY(s, 0);
-            }
-            s->strstart++;
-            s->lookahead--;
-            if (s->strm->avail_out == 0)
-                return need_more;
-        } else {
-            /* There is no previous match to compare with, wait for
-             * the next step to decide.
-             */
-            s->match_available = 1;
-            s->strstart++;
-            s->lookahead--;
-        }
-    }
-    Assert(flush != Z_NO_FLUSH, "no flush?");
-    if (s->match_available) {
-        Tracevv((stderr, "%c", s->window[s->strstart-1]));
-        _tr_tally_lit(s, s->window[s->strstart-1], bflush);
-        s->match_available = 0;
-    }
-    s->insert = s->strstart < MIN_MATCH-1 ? s->strstart : MIN_MATCH-1;
-    if (flush == Z_FINISH) {
-        FLUSH_BLOCK(s, 1);
-        return finish_done;
-    }
-    if (s->last_lit)
-        FLUSH_BLOCK(s, 0);
-    return block_done;
-}
diff --git a/contrib/libzlib-ng/doc/algorithm.txt b/contrib/libzlib-ng/doc/algorithm.txt
deleted file mode 100644
index c97f495020b..00000000000
--- a/contrib/libzlib-ng/doc/algorithm.txt
+++ /dev/null
@@ -1,209 +0,0 @@
-1. Compression algorithm (deflate)
-
-The deflation algorithm used by gzip (also zip and zlib) is a variation of
-LZ77 (Lempel-Ziv 1977, see reference below). It finds duplicated strings in
-the input data.  The second occurrence of a string is replaced by a
-pointer to the previous string, in the form of a pair (distance,
-length).  Distances are limited to 32K bytes, and lengths are limited
-to 258 bytes. When a string does not occur anywhere in the previous
-32K bytes, it is emitted as a sequence of literal bytes.  (In this
-description, `string' must be taken as an arbitrary sequence of bytes,
-and is not restricted to printable characters.)
-
-Literals or match lengths are compressed with one Huffman tree, and
-match distances are compressed with another tree. The trees are stored
-in a compact form at the start of each block. The blocks can have any
-size (except that the compressed data for one block must fit in
-available memory). A block is terminated when deflate() determines that
-it would be useful to start another block with fresh trees. (This is
-somewhat similar to the behavior of LZW-based _compress_.)
-
-Duplicated strings are found using a hash table. All input strings of
-length 3 are inserted in the hash table. A hash index is computed for
-the next 3 bytes. If the hash chain for this index is not empty, all
-strings in the chain are compared with the current input string, and
-the longest match is selected.
-
-The hash chains are searched starting with the most recent strings, to
-favor small distances and thus take advantage of the Huffman encoding.
-The hash chains are singly linked. There are no deletions from the
-hash chains, the algorithm simply discards matches that are too old.
-
-To avoid a worst-case situation, very long hash chains are arbitrarily
-truncated at a certain length, determined by a runtime option (level
-parameter of deflateInit). So deflate() does not always find the longest
-possible match but generally finds a match which is long enough.
-
-deflate() also defers the selection of matches with a lazy evaluation
-mechanism. After a match of length N has been found, deflate() searches for
-a longer match at the next input byte. If a longer match is found, the
-previous match is truncated to a length of one (thus producing a single
-literal byte) and the process of lazy evaluation begins again. Otherwise,
-the original match is kept, and the next match search is attempted only N
-steps later.
-
-The lazy match evaluation is also subject to a runtime parameter. If
-the current match is long enough, deflate() reduces the search for a longer
-match, thus speeding up the whole process. If compression ratio is more
-important than speed, deflate() attempts a complete second search even if
-the first match is already long enough.
-
-The lazy match evaluation is not performed for the fastest compression
-modes (level parameter 1 to 3). For these fast modes, new strings
-are inserted in the hash table only when no match was found, or
-when the match is not too long. This degrades the compression ratio
-but saves time since there are both fewer insertions and fewer searches.
-
-
-2. Decompression algorithm (inflate)
-
-2.1 Introduction
-
-The key question is how to represent a Huffman code (or any prefix code) so
-that you can decode fast.  The most important characteristic is that shorter
-codes are much more common than longer codes, so pay attention to decoding the
-short codes fast, and let the long codes take longer to decode.
-
-inflate() sets up a first level table that covers some number of bits of
-input less than the length of longest code.  It gets that many bits from the
-stream, and looks it up in the table.  The table will tell if the next
-code is that many bits or less and how many, and if it is, it will tell
-the value, else it will point to the next level table for which inflate()
-grabs more bits and tries to decode a longer code.
-
-How many bits to make the first lookup is a tradeoff between the time it
-takes to decode and the time it takes to build the table.  If building the
-table took no time (and if you had infinite memory), then there would only
-be a first level table to cover all the way to the longest code.  However,
-building the table ends up taking a lot longer for more bits since short
-codes are replicated many times in such a table.  What inflate() does is
-simply to make the number of bits in the first table a variable, and  then
-to set that variable for the maximum speed.
-
-For inflate, which has 286 possible codes for the literal/length tree, the size
-of the first table is nine bits.  Also the distance trees have 30 possible
-values, and the size of the first table is six bits.  Note that for each of
-those cases, the table ended up one bit longer than the ``average'' code
-length, i.e. the code length of an approximately flat code which would be a
-little more than eight bits for 286 symbols and a little less than five bits
-for 30 symbols.
-
-
-2.2 More details on the inflate table lookup
-
-Ok, you want to know what this cleverly obfuscated inflate tree actually
-looks like.  You are correct that it's not a Huffman tree.  It is simply a
-lookup table for the first, let's say, nine bits of a Huffman symbol.  The
-symbol could be as short as one bit or as long as 15 bits.  If a particular
-symbol is shorter than nine bits, then that symbol's translation is duplicated
-in all those entries that start with that symbol's bits.  For example, if the
-symbol is four bits, then it's duplicated 32 times in a nine-bit table.  If a
-symbol is nine bits long, it appears in the table once.
-
-If the symbol is longer than nine bits, then that entry in the table points
-to another similar table for the remaining bits.  Again, there are duplicated
-entries as needed.  The idea is that most of the time the symbol will be short
-and there will only be one table look up.  (That's whole idea behind data
-compression in the first place.)  For the less frequent long symbols, there
-will be two lookups.  If you had a compression method with really long
-symbols, you could have as many levels of lookups as is efficient.  For
-inflate, two is enough.
-
-So a table entry either points to another table (in which case nine bits in
-the above example are gobbled), or it contains the translation for the symbol
-and the number of bits to gobble.  Then you start again with the next
-ungobbled bit.
-
-You may wonder: why not just have one lookup table for how ever many bits the
-longest symbol is?  The reason is that if you do that, you end up spending
-more time filling in duplicate symbol entries than you do actually decoding.
-At least for deflate's output that generates new trees every several 10's of
-kbytes.  You can imagine that filling in a 2^15 entry table for a 15-bit code
-would take too long if you're only decoding several thousand symbols.  At the
-other extreme, you could make a new table for every bit in the code.  In fact,
-that's essentially a Huffman tree.  But then you spend too much time
-traversing the tree while decoding, even for short symbols.
-
-So the number of bits for the first lookup table is a trade of the time to
-fill out the table vs. the time spent looking at the second level and above of
-the table.
-
-Here is an example, scaled down:
-
-The code being decoded, with 10 symbols, from 1 to 6 bits long:
-
-A: 0
-B: 10
-C: 1100
-D: 11010
-E: 11011
-F: 11100
-G: 11101
-H: 11110
-I: 111110
-J: 111111
-
-Let's make the first table three bits long (eight entries):
-
-000: A,1
-001: A,1
-010: A,1
-011: A,1
-100: B,2
-101: B,2
-110: -> table X (gobble 3 bits)
-111: -> table Y (gobble 3 bits)
-
-Each entry is what the bits decode as and how many bits that is, i.e. how
-many bits to gobble.  Or the entry points to another table, with the number of
-bits to gobble implicit in the size of the table.
-
-Table X is two bits long since the longest code starting with 110 is five bits
-long:
-
-00: C,1
-01: C,1
-10: D,2
-11: E,2
-
-Table Y is three bits long since the longest code starting with 111 is six
-bits long:
-
-000: F,2
-001: F,2
-010: G,2
-011: G,2
-100: H,2
-101: H,2
-110: I,3
-111: J,3
-
-So what we have here are three tables with a total of 20 entries that had to
-be constructed.  That's compared to 64 entries for a single table.  Or
-compared to 16 entries for a Huffman tree (six two entry tables and one four
-entry table).  Assuming that the code ideally represents the probability of
-the symbols, it takes on the average 1.25 lookups per symbol.  That's compared
-to one lookup for the single table, or 1.66 lookups per symbol for the
-Huffman tree.
-
-There, I think that gives you a picture of what's going on.  For inflate, the
-meaning of a particular symbol is often more than just a letter.  It can be a
-byte (a "literal"), or it can be either a length or a distance which
-indicates a base value and a number of bits to fetch after the code that is
-added to the base value.  Or it might be the special end-of-block code.  The
-data structures created in inftrees.c try to encode all that information
-compactly in the tables.
-
-
-Jean-loup Gailly        Mark Adler
-jloup@gzip.org          madler@alumni.caltech.edu
-
-
-References:
-
-[LZ77] Ziv J., Lempel A., ``A Universal Algorithm for Sequential Data
-Compression,'' IEEE Transactions on Information Theory, Vol. 23, No. 3,
-pp. 337-343.
-
-``DEFLATE Compressed Data Format Specification'' available in
-http://tools.ietf.org/html/rfc1951
diff --git a/contrib/libzlib-ng/doc/rfc1950.txt b/contrib/libzlib-ng/doc/rfc1950.txt
deleted file mode 100644
index ce6428a0f2e..00000000000
--- a/contrib/libzlib-ng/doc/rfc1950.txt
+++ /dev/null
@@ -1,619 +0,0 @@
-
-
-
-
-
-
-Network Working Group                                         P. Deutsch
-Request for Comments: 1950                           Aladdin Enterprises
-Category: Informational                                      J-L. Gailly
-                                                                Info-ZIP
-                                                                May 1996
-
-
-         ZLIB Compressed Data Format Specification version 3.3
-
-Status of This Memo
-
-   This memo provides information for the Internet community.  This memo
-   does not specify an Internet standard of any kind.  Distribution of
-   this memo is unlimited.
-
-IESG Note:
-
-   The IESG takes no position on the validity of any Intellectual
-   Property Rights statements contained in this document.
-
-Notices
-
-   Copyright (c) 1996 L. Peter Deutsch and Jean-Loup Gailly
-
-   Permission is granted to copy and distribute this document for any
-   purpose and without charge, including translations into other
-   languages and incorporation into compilations, provided that the
-   copyright notice and this notice are preserved, and that any
-   substantive changes or deletions from the original are clearly
-   marked.
-
-   A pointer to the latest version of this and related documentation in
-   HTML format can be found at the URL
-   <ftp://ftp.uu.net/graphics/png/documents/zlib/zdoc-index.html>.
-
-Abstract
-
-   This specification defines a lossless compressed data format.  The
-   data can be produced or consumed, even for an arbitrarily long
-   sequentially presented input data stream, using only an a priori
-   bounded amount of intermediate storage.  The format presently uses
-   the DEFLATE compression method but can be easily extended to use
-   other compression methods.  It can be implemented readily in a manner
-   not covered by patents.  This specification also defines the ADLER-32
-   checksum (an extension and improvement of the Fletcher checksum),
-   used for detection of data corruption, and provides an algorithm for
-   computing it.
-
-
-
-
-Deutsch & Gailly             Informational                      [Page 1]
-
-RFC 1950       ZLIB Compressed Data Format Specification        May 1996
-
-
-Table of Contents
-
-   1. Introduction ................................................... 2
-      1.1. Purpose ................................................... 2
-      1.2. Intended audience ......................................... 3
-      1.3. Scope ..................................................... 3
-      1.4. Compliance ................................................ 3
-      1.5.  Definitions of terms and conventions used ................ 3
-      1.6. Changes from previous versions ............................ 3
-   2. Detailed specification ......................................... 3
-      2.1. Overall conventions ....................................... 3
-      2.2. Data format ............................................... 4
-      2.3. Compliance ................................................ 7
-   3. References ..................................................... 7
-   4. Source code .................................................... 8
-   5. Security Considerations ........................................ 8
-   6. Acknowledgements ............................................... 8
-   7. Authors' Addresses ............................................. 8
-   8. Appendix: Rationale ............................................ 9
-   9. Appendix: Sample code ..........................................10
-
-1. Introduction
-
-   1.1. Purpose
-
-      The purpose of this specification is to define a lossless
-      compressed data format that:
-
-          * Is independent of CPU type, operating system, file system,
-            and character set, and hence can be used for interchange;
-
-          * Can be produced or consumed, even for an arbitrarily long
-            sequentially presented input data stream, using only an a
-            priori bounded amount of intermediate storage, and hence can
-            be used in data communications or similar structures such as
-            Unix filters;
-
-          * Can use a number of different compression methods;
-
-          * Can be implemented readily in a manner not covered by
-            patents, and hence can be practiced freely.
-
-      The data format defined by this specification does not attempt to
-      allow random access to compressed data.
-
-
-
-
-
-
-
-Deutsch & Gailly             Informational                      [Page 2]
-
-RFC 1950       ZLIB Compressed Data Format Specification        May 1996
-
-
-   1.2. Intended audience
-
-      This specification is intended for use by implementors of software
-      to compress data into zlib format and/or decompress data from zlib
-      format.
-
-      The text of the specification assumes a basic background in
-      programming at the level of bits and other primitive data
-      representations.
-
-   1.3. Scope
-
-      The specification specifies a compressed data format that can be
-      used for in-memory compression of a sequence of arbitrary bytes.
-
-   1.4. Compliance
-
-      Unless otherwise indicated below, a compliant decompressor must be
-      able to accept and decompress any data set that conforms to all
-      the specifications presented here; a compliant compressor must
-      produce data sets that conform to all the specifications presented
-      here.
-
-   1.5.  Definitions of terms and conventions used
-
-      byte: 8 bits stored or transmitted as a unit (same as an octet).
-      (For this specification, a byte is exactly 8 bits, even on
-      machines which store a character on a number of bits different
-      from 8.) See below, for the numbering of bits within a byte.
-
-   1.6. Changes from previous versions
-
-      Version 3.1 was the first public release of this specification.
-      In version 3.2, some terminology was changed and the Adler-32
-      sample code was rewritten for clarity.  In version 3.3, the
-      support for a preset dictionary was introduced, and the
-      specification was converted to RFC style.
-
-2. Detailed specification
-
-   2.1. Overall conventions
-
-      In the diagrams below, a box like this:
-
-         +---+
-         |   | <-- the vertical bars might be missing
-         +---+
-
-
-
-
-Deutsch & Gailly             Informational                      [Page 3]
-
-RFC 1950       ZLIB Compressed Data Format Specification        May 1996
-
-
-      represents one byte; a box like this:
-
-         +==============+
-         |              |
-         +==============+
-
-      represents a variable number of bytes.
-
-      Bytes stored within a computer do not have a "bit order", since
-      they are always treated as a unit.  However, a byte considered as
-      an integer between 0 and 255 does have a most- and least-
-      significant bit, and since we write numbers with the most-
-      significant digit on the left, we also write bytes with the most-
-      significant bit on the left.  In the diagrams below, we number the
-      bits of a byte so that bit 0 is the least-significant bit, i.e.,
-      the bits are numbered:
-
-         +--------+
-         |76543210|
-         +--------+
-
-      Within a computer, a number may occupy multiple bytes.  All
-      multi-byte numbers in the format described here are stored with
-      the MOST-significant byte first (at the lower memory address).
-      For example, the decimal number 520 is stored as:
-
-             0     1
-         +--------+--------+
-         |00000010|00001000|
-         +--------+--------+
-          ^        ^
-          |        |
-          |        + less significant byte = 8
-          + more significant byte = 2 x 256
-
-   2.2. Data format
-
-      A zlib stream has the following structure:
-
-           0   1
-         +---+---+
-         |CMF|FLG|   (more-->)
-         +---+---+
-
-
-
-
-
-
-
-
-Deutsch & Gailly             Informational                      [Page 4]
-
-RFC 1950       ZLIB Compressed Data Format Specification        May 1996
-
-
-      (if FLG.FDICT set)
-
-           0   1   2   3
-         +---+---+---+---+
-         |     DICTID    |   (more-->)
-         +---+---+---+---+
-
-         +=====================+---+---+---+---+
-         |...compressed data...|    ADLER32    |
-         +=====================+---+---+---+---+
-
-      Any data which may appear after ADLER32 are not part of the zlib
-      stream.
-
-      CMF (Compression Method and flags)
-         This byte is divided into a 4-bit compression method and a 4-
-         bit information field depending on the compression method.
-
-            bits 0 to 3  CM     Compression method
-            bits 4 to 7  CINFO  Compression info
-
-      CM (Compression method)
-         This identifies the compression method used in the file. CM = 8
-         denotes the "deflate" compression method with a window size up
-         to 32K.  This is the method used by gzip and PNG (see
-         references [1] and [2] in Chapter 3, below, for the reference
-         documents).  CM = 15 is reserved.  It might be used in a future
-         version of this specification to indicate the presence of an
-         extra field before the compressed data.
-
-      CINFO (Compression info)
-         For CM = 8, CINFO is the base-2 logarithm of the LZ77 window
-         size, minus eight (CINFO=7 indicates a 32K window size). Values
-         of CINFO above 7 are not allowed in this version of the
-         specification.  CINFO is not defined in this specification for
-         CM not equal to 8.
-
-      FLG (FLaGs)
-         This flag byte is divided as follows:
-
-            bits 0 to 4  FCHECK  (check bits for CMF and FLG)
-            bit  5       FDICT   (preset dictionary)
-            bits 6 to 7  FLEVEL  (compression level)
-
-         The FCHECK value must be such that CMF and FLG, when viewed as
-         a 16-bit unsigned integer stored in MSB order (CMF*256 + FLG),
-         is a multiple of 31.
-
-
-
-
-Deutsch & Gailly             Informational                      [Page 5]
-
-RFC 1950       ZLIB Compressed Data Format Specification        May 1996
-
-
-      FDICT (Preset dictionary)
-         If FDICT is set, a DICT dictionary identifier is present
-         immediately after the FLG byte. The dictionary is a sequence of
-         bytes which are initially fed to the compressor without
-         producing any compressed output. DICT is the Adler-32 checksum
-         of this sequence of bytes (see the definition of ADLER32
-         below).  The decompressor can use this identifier to determine
-         which dictionary has been used by the compressor.
-
-      FLEVEL (Compression level)
-         These flags are available for use by specific compression
-         methods.  The "deflate" method (CM = 8) sets these flags as
-         follows:
-
-            0 - compressor used fastest algorithm
-            1 - compressor used fast algorithm
-            2 - compressor used default algorithm
-            3 - compressor used maximum compression, slowest algorithm
-
-         The information in FLEVEL is not needed for decompression; it
-         is there to indicate if recompression might be worthwhile.
-
-      compressed data
-         For compression method 8, the compressed data is stored in the
-         deflate compressed data format as described in the document
-         "DEFLATE Compressed Data Format Specification" by L. Peter
-         Deutsch. (See reference [3] in Chapter 3, below)
-
-         Other compressed data formats are not specified in this version
-         of the zlib specification.
-
-      ADLER32 (Adler-32 checksum)
-         This contains a checksum value of the uncompressed data
-         (excluding any dictionary data) computed according to Adler-32
-         algorithm. This algorithm is a 32-bit extension and improvement
-         of the Fletcher algorithm, used in the ITU-T X.224 / ISO 8073
-         standard. See references [4] and [5] in Chapter 3, below)
-
-         Adler-32 is composed of two sums accumulated per byte: s1 is
-         the sum of all bytes, s2 is the sum of all s1 values. Both sums
-         are done modulo 65521. s1 is initialized to 1, s2 to zero.  The
-         Adler-32 checksum is stored as s2*65536 + s1 in most-
-         significant-byte first (network) order.
-
-
-
-
-
-
-
-
-Deutsch & Gailly             Informational                      [Page 6]
-
-RFC 1950       ZLIB Compressed Data Format Specification        May 1996
-
-
-   2.3. Compliance
-
-      A compliant compressor must produce streams with correct CMF, FLG
-      and ADLER32, but need not support preset dictionaries.  When the
-      zlib data format is used as part of another standard data format,
-      the compressor may use only preset dictionaries that are specified
-      by this other data format.  If this other format does not use the
-      preset dictionary feature, the compressor must not set the FDICT
-      flag.
-
-      A compliant decompressor must check CMF, FLG, and ADLER32, and
-      provide an error indication if any of these have incorrect values.
-      A compliant decompressor must give an error indication if CM is
-      not one of the values defined in this specification (only the
-      value 8 is permitted in this version), since another value could
-      indicate the presence of new features that would cause subsequent
-      data to be interpreted incorrectly.  A compliant decompressor must
-      give an error indication if FDICT is set and DICTID is not the
-      identifier of a known preset dictionary.  A decompressor may
-      ignore FLEVEL and still be compliant.  When the zlib data format
-      is being used as a part of another standard format, a compliant
-      decompressor must support all the preset dictionaries specified by
-      the other format. When the other format does not use the preset
-      dictionary feature, a compliant decompressor must reject any
-      stream in which the FDICT flag is set.
-
-3. References
-
-   [1] Deutsch, L.P.,"GZIP Compressed Data Format Specification",
-       available in ftp://ftp.uu.net/pub/archiving/zip/doc/
-
-   [2] Thomas Boutell, "PNG (Portable Network Graphics) specification",
-       available in ftp://ftp.uu.net/graphics/png/documents/
-
-   [3] Deutsch, L.P.,"DEFLATE Compressed Data Format Specification",
-       available in ftp://ftp.uu.net/pub/archiving/zip/doc/
-
-   [4] Fletcher, J. G., "An Arithmetic Checksum for Serial
-       Transmissions," IEEE Transactions on Communications, Vol. COM-30,
-       No. 1, January 1982, pp. 247-252.
-
-   [5] ITU-T Recommendation X.224, Annex D, "Checksum Algorithms,"
-       November, 1993, pp. 144, 145. (Available from
-       gopher://info.itu.ch). ITU-T X.244 is also the same as ISO 8073.
-
-
-
-
-
-
-
-Deutsch & Gailly             Informational                      [Page 7]
-
-RFC 1950       ZLIB Compressed Data Format Specification        May 1996
-
-
-4. Source code
-
-   Source code for a C language implementation of a "zlib" compliant
-   library is available at ftp://ftp.uu.net/pub/archiving/zip/zlib/.
-
-5. Security Considerations
-
-   A decoder that fails to check the ADLER32 checksum value may be
-   subject to undetected data corruption.
-
-6. Acknowledgements
-
-   Trademarks cited in this document are the property of their
-   respective owners.
-
-   Jean-Loup Gailly and Mark Adler designed the zlib format and wrote
-   the related software described in this specification.  Glenn
-   Randers-Pehrson converted this document to RFC and HTML format.
-
-7. Authors' Addresses
-
-   L. Peter Deutsch
-   Aladdin Enterprises
-   203 Santa Margarita Ave.
-   Menlo Park, CA 94025
-
-   Phone: (415) 322-0103 (AM only)
-   FAX:   (415) 322-1734
-   EMail: <ghost@aladdin.com>
-
-
-   Jean-Loup Gailly
-
-   EMail: <gzip@prep.ai.mit.edu>
-
-   Questions about the technical content of this specification can be
-   sent by email to
-
-   Jean-Loup Gailly <gzip@prep.ai.mit.edu> and
-   Mark Adler <madler@alumni.caltech.edu>
-
-   Editorial comments on this specification can be sent by email to
-
-   L. Peter Deutsch <ghost@aladdin.com> and
-   Glenn Randers-Pehrson <randeg@alumni.rpi.edu>
-
-
-
-
-
-
-Deutsch & Gailly             Informational                      [Page 8]
-
-RFC 1950       ZLIB Compressed Data Format Specification        May 1996
-
-
-8. Appendix: Rationale
-
-   8.1. Preset dictionaries
-
-      A preset dictionary is specially useful to compress short input
-      sequences. The compressor can take advantage of the dictionary
-      context to encode the input in a more compact manner. The
-      decompressor can be initialized with the appropriate context by
-      virtually decompressing a compressed version of the dictionary
-      without producing any output. However for certain compression
-      algorithms such as the deflate algorithm this operation can be
-      achieved without actually performing any decompression.
-
-      The compressor and the decompressor must use exactly the same
-      dictionary. The dictionary may be fixed or may be chosen among a
-      certain number of predefined dictionaries, according to the kind
-      of input data. The decompressor can determine which dictionary has
-      been chosen by the compressor by checking the dictionary
-      identifier. This document does not specify the contents of
-      predefined dictionaries, since the optimal dictionaries are
-      application specific. Standard data formats using this feature of
-      the zlib specification must precisely define the allowed
-      dictionaries.
-
-   8.2. The Adler-32 algorithm
-
-      The Adler-32 algorithm is much faster than the CRC32 algorithm yet
-      still provides an extremely low probability of undetected errors.
-
-      The modulo on unsigned long accumulators can be delayed for 5552
-      bytes, so the modulo operation time is negligible.  If the bytes
-      are a, b, c, the second sum is 3a + 2b + c + 3, and so is position
-      and order sensitive, unlike the first sum, which is just a
-      checksum.  That 65521 is prime is important to avoid a possible
-      large class of two-byte errors that leave the check unchanged.
-      (The Fletcher checksum uses 255, which is not prime and which also
-      makes the Fletcher check insensitive to single byte changes 0 <->
-      255.)
-
-      The sum s1 is initialized to 1 instead of zero to make the length
-      of the sequence part of s2, so that the length does not have to be
-      checked separately. (Any sequence of zeroes has a Fletcher
-      checksum of zero.)
-
-
-
-
-
-
-
-
-Deutsch & Gailly             Informational                      [Page 9]
-
-RFC 1950       ZLIB Compressed Data Format Specification        May 1996
-
-
-9. Appendix: Sample code
-
-   The following C code computes the Adler-32 checksum of a data buffer.
-   It is written for clarity, not for speed.  The sample code is in the
-   ANSI C programming language. Non C users may find it easier to read
-   with these hints:
-
-      &      Bitwise AND operator.
-      >>     Bitwise right shift operator. When applied to an
-             unsigned quantity, as here, right shift inserts zero bit(s)
-             at the left.
-      <<     Bitwise left shift operator. Left shift inserts zero
-             bit(s) at the right.
-      ++     "n++" increments the variable n.
-      %      modulo operator: a % b is the remainder of a divided by b.
-
-      #define BASE 65521 /* largest prime smaller than 65536 */
-
-      /*
-         Update a running Adler-32 checksum with the bytes buf[0..len-1]
-       and return the updated checksum. The Adler-32 checksum should be
-       initialized to 1.
-
-       Usage example:
-
-         unsigned long adler = 1L;
-
-         while (read_buffer(buffer, length) != EOF) {
-           adler = update_adler32(adler, buffer, length);
-         }
-         if (adler != original_adler) error();
-      */
-      unsigned long update_adler32(unsigned long adler,
-         unsigned char *buf, int len)
-      {
-        unsigned long s1 = adler & 0xffff;
-        unsigned long s2 = (adler >> 16) & 0xffff;
-        int n;
-
-        for (n = 0; n < len; n++) {
-          s1 = (s1 + buf[n]) % BASE;
-          s2 = (s2 + s1)     % BASE;
-        }
-        return (s2 << 16) + s1;
-      }
-
-      /* Return the adler32 of the bytes buf[0..len-1] */
-
-
-
-
-Deutsch & Gailly             Informational                     [Page 10]
-
-RFC 1950       ZLIB Compressed Data Format Specification        May 1996
-
-
-      unsigned long adler32(unsigned char *buf, int len)
-      {
-        return update_adler32(1L, buf, len);
-      }
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-Deutsch & Gailly             Informational                     [Page 11]
-
diff --git a/contrib/libzlib-ng/doc/rfc1951.txt b/contrib/libzlib-ng/doc/rfc1951.txt
deleted file mode 100644
index 403c8c722ff..00000000000
--- a/contrib/libzlib-ng/doc/rfc1951.txt
+++ /dev/null
@@ -1,955 +0,0 @@
-
-
-
-
-
-
-Network Working Group                                         P. Deutsch
-Request for Comments: 1951                           Aladdin Enterprises
-Category: Informational                                         May 1996
-
-
-        DEFLATE Compressed Data Format Specification version 1.3
-
-Status of This Memo
-
-   This memo provides information for the Internet community.  This memo
-   does not specify an Internet standard of any kind.  Distribution of
-   this memo is unlimited.
-
-IESG Note:
-
-   The IESG takes no position on the validity of any Intellectual
-   Property Rights statements contained in this document.
-
-Notices
-
-   Copyright (c) 1996 L. Peter Deutsch
-
-   Permission is granted to copy and distribute this document for any
-   purpose and without charge, including translations into other
-   languages and incorporation into compilations, provided that the
-   copyright notice and this notice are preserved, and that any
-   substantive changes or deletions from the original are clearly
-   marked.
-
-   A pointer to the latest version of this and related documentation in
-   HTML format can be found at the URL
-   <ftp://ftp.uu.net/graphics/png/documents/zlib/zdoc-index.html>.
-
-Abstract
-
-   This specification defines a lossless compressed data format that
-   compresses data using a combination of the LZ77 algorithm and Huffman
-   coding, with efficiency comparable to the best currently available
-   general-purpose compression methods.  The data can be produced or
-   consumed, even for an arbitrarily long sequentially presented input
-   data stream, using only an a priori bounded amount of intermediate
-   storage.  The format can be implemented readily in a manner not
-   covered by patents.
-
-
-
-
-
-
-
-
-Deutsch                      Informational                      [Page 1]
-
-RFC 1951      DEFLATE Compressed Data Format Specification      May 1996
-
-
-Table of Contents
-
-   1. Introduction ................................................... 2
-      1.1. Purpose ................................................... 2
-      1.2. Intended audience ......................................... 3
-      1.3. Scope ..................................................... 3
-      1.4. Compliance ................................................ 3
-      1.5.  Definitions of terms and conventions used ................ 3
-      1.6. Changes from previous versions ............................ 4
-   2. Compressed representation overview ............................. 4
-   3. Detailed specification ......................................... 5
-      3.1. Overall conventions ....................................... 5
-          3.1.1. Packing into bytes .................................. 5
-      3.2. Compressed block format ................................... 6
-          3.2.1. Synopsis of prefix and Huffman coding ............... 6
-          3.2.2. Use of Huffman coding in the "deflate" format ....... 7
-          3.2.3. Details of block format ............................. 9
-          3.2.4. Non-compressed blocks (BTYPE=00) ................... 11
-          3.2.5. Compressed blocks (length and distance codes) ...... 11
-          3.2.6. Compression with fixed Huffman codes (BTYPE=01) .... 12
-          3.2.7. Compression with dynamic Huffman codes (BTYPE=10) .. 13
-      3.3. Compliance ............................................... 14
-   4. Compression algorithm details ................................. 14
-   5. References .................................................... 16
-   6. Security Considerations ....................................... 16
-   7. Source code ................................................... 16
-   8. Acknowledgements .............................................. 16
-   9. Author's Address .............................................. 17
-
-1. Introduction
-
-   1.1. Purpose
-
-      The purpose of this specification is to define a lossless
-      compressed data format that:
-          * Is independent of CPU type, operating system, file system,
-            and character set, and hence can be used for interchange;
-          * Can be produced or consumed, even for an arbitrarily long
-            sequentially presented input data stream, using only an a
-            priori bounded amount of intermediate storage, and hence
-            can be used in data communications or similar structures
-            such as Unix filters;
-          * Compresses data with efficiency comparable to the best
-            currently available general-purpose compression methods,
-            and in particular considerably better than the "compress"
-            program;
-          * Can be implemented readily in a manner not covered by
-            patents, and hence can be practiced freely;
-
-
-
-Deutsch                      Informational                      [Page 2]
-
-RFC 1951      DEFLATE Compressed Data Format Specification      May 1996
-
-
-          * Is compatible with the file format produced by the current
-            widely used gzip utility, in that conforming decompressors
-            will be able to read data produced by the existing gzip
-            compressor.
-
-      The data format defined by this specification does not attempt to:
-
-          * Allow random access to compressed data;
-          * Compress specialized data (e.g., raster graphics) as well
-            as the best currently available specialized algorithms.
-
-      A simple counting argument shows that no lossless compression
-      algorithm can compress every possible input data set.  For the
-      format defined here, the worst case expansion is 5 bytes per 32K-
-      byte block, i.e., a size increase of 0.015% for large data sets.
-      English text usually compresses by a factor of 2.5 to 3;
-      executable files usually compress somewhat less; graphical data
-      such as raster images may compress much more.
-
-   1.2. Intended audience
-
-      This specification is intended for use by implementors of software
-      to compress data into "deflate" format and/or decompress data from
-      "deflate" format.
-
-      The text of the specification assumes a basic background in
-      programming at the level of bits and other primitive data
-      representations.  Familiarity with the technique of Huffman coding
-      is helpful but not required.
-
-   1.3. Scope
-
-      The specification specifies a method for representing a sequence
-      of bytes as a (usually shorter) sequence of bits, and a method for
-      packing the latter bit sequence into bytes.
-
-   1.4. Compliance
-
-      Unless otherwise indicated below, a compliant decompressor must be
-      able to accept and decompress any data set that conforms to all
-      the specifications presented here; a compliant compressor must
-      produce data sets that conform to all the specifications presented
-      here.
-
-   1.5.  Definitions of terms and conventions used
-
-      Byte: 8 bits stored or transmitted as a unit (same as an octet).
-      For this specification, a byte is exactly 8 bits, even on machines
-
-
-
-Deutsch                      Informational                      [Page 3]
-
-RFC 1951      DEFLATE Compressed Data Format Specification      May 1996
-
-
-      which store a character on a number of bits different from eight.
-      See below, for the numbering of bits within a byte.
-
-      String: a sequence of arbitrary bytes.
-
-   1.6. Changes from previous versions
-
-      There have been no technical changes to the deflate format since
-      version 1.1 of this specification.  In version 1.2, some
-      terminology was changed.  Version 1.3 is a conversion of the
-      specification to RFC style.
-
-2. Compressed representation overview
-
-   A compressed data set consists of a series of blocks, corresponding
-   to successive blocks of input data.  The block sizes are arbitrary,
-   except that non-compressible blocks are limited to 65,535 bytes.
-
-   Each block is compressed using a combination of the LZ77 algorithm
-   and Huffman coding. The Huffman trees for each block are independent
-   of those for previous or subsequent blocks; the LZ77 algorithm may
-   use a reference to a duplicated string occurring in a previous block,
-   up to 32K input bytes before.
-
-   Each block consists of two parts: a pair of Huffman code trees that
-   describe the representation of the compressed data part, and a
-   compressed data part.  (The Huffman trees themselves are compressed
-   using Huffman encoding.)  The compressed data consists of a series of
-   elements of two types: literal bytes (of strings that have not been
-   detected as duplicated within the previous 32K input bytes), and
-   pointers to duplicated strings, where a pointer is represented as a
-   pair <length, backward distance>.  The representation used in the
-   "deflate" format limits distances to 32K bytes and lengths to 258
-   bytes, but does not limit the size of a block, except for
-   uncompressible blocks, which are limited as noted above.
-
-   Each type of value (literals, distances, and lengths) in the
-   compressed data is represented using a Huffman code, using one code
-   tree for literals and lengths and a separate code tree for distances.
-   The code trees for each block appear in a compact form just before
-   the compressed data for that block.
-
-
-
-
-
-
-
-
-
-
-Deutsch                      Informational                      [Page 4]
-
-RFC 1951      DEFLATE Compressed Data Format Specification      May 1996
-
-
-3. Detailed specification
-
-   3.1. Overall conventions In the diagrams below, a box like this:
-
-         +---+
-         |   | <-- the vertical bars might be missing
-         +---+
-
-      represents one byte; a box like this:
-
-         +==============+
-         |              |
-         +==============+
-
-      represents a variable number of bytes.
-
-      Bytes stored within a computer do not have a "bit order", since
-      they are always treated as a unit.  However, a byte considered as
-      an integer between 0 and 255 does have a most- and least-
-      significant bit, and since we write numbers with the most-
-      significant digit on the left, we also write bytes with the most-
-      significant bit on the left.  In the diagrams below, we number the
-      bits of a byte so that bit 0 is the least-significant bit, i.e.,
-      the bits are numbered:
-
-         +--------+
-         |76543210|
-         +--------+
-
-      Within a computer, a number may occupy multiple bytes.  All
-      multi-byte numbers in the format described here are stored with
-      the least-significant byte first (at the lower memory address).
-      For example, the decimal number 520 is stored as:
-
-             0        1
-         +--------+--------+
-         |00001000|00000010|
-         +--------+--------+
-          ^        ^
-          |        |
-          |        + more significant byte = 2 x 256
-          + less significant byte = 8
-
-      3.1.1. Packing into bytes
-
-         This document does not address the issue of the order in which
-         bits of a byte are transmitted on a bit-sequential medium,
-         since the final data format described here is byte- rather than
-
-
-
-Deutsch                      Informational                      [Page 5]
-
-RFC 1951      DEFLATE Compressed Data Format Specification      May 1996
-
-
-         bit-oriented.  However, we describe the compressed block format
-         in below, as a sequence of data elements of various bit
-         lengths, not a sequence of bytes.  We must therefore specify
-         how to pack these data elements into bytes to form the final
-         compressed byte sequence:
-
-             * Data elements are packed into bytes in order of
-               increasing bit number within the byte, i.e., starting
-               with the least-significant bit of the byte.
-             * Data elements other than Huffman codes are packed
-               starting with the least-significant bit of the data
-               element.
-             * Huffman codes are packed starting with the most-
-               significant bit of the code.
-
-         In other words, if one were to print out the compressed data as
-         a sequence of bytes, starting with the first byte at the
-         *right* margin and proceeding to the *left*, with the most-
-         significant bit of each byte on the left as usual, one would be
-         able to parse the result from right to left, with fixed-width
-         elements in the correct MSB-to-LSB order and Huffman codes in
-         bit-reversed order (i.e., with the first bit of the code in the
-         relative LSB position).
-
-   3.2. Compressed block format
-
-      3.2.1. Synopsis of prefix and Huffman coding
-
-         Prefix coding represents symbols from an a priori known
-         alphabet by bit sequences (codes), one code for each symbol, in
-         a manner such that different symbols may be represented by bit
-         sequences of different lengths, but a parser can always parse
-         an encoded string unambiguously symbol-by-symbol.
-
-         We define a prefix code in terms of a binary tree in which the
-         two edges descending from each non-leaf node are labeled 0 and
-         1 and in which the leaf nodes correspond one-for-one with (are
-         labeled with) the symbols of the alphabet; then the code for a
-         symbol is the sequence of 0's and 1's on the edges leading from
-         the root to the leaf labeled with that symbol.  For example:
-
-
-
-
-
-
-
-
-
-
-
-Deutsch                      Informational                      [Page 6]
-
-RFC 1951      DEFLATE Compressed Data Format Specification      May 1996
-
-
-                          /\              Symbol    Code
-                         0  1             ------    ----
-                        /    \                A      00
-                       /\     B               B       1
-                      0  1                    C     011
-                     /    \                   D     010
-                    A     /\
-                         0  1
-                        /    \
-                       D      C
-
-         A parser can decode the next symbol from an encoded input
-         stream by walking down the tree from the root, at each step
-         choosing the edge corresponding to the next input bit.
-
-         Given an alphabet with known symbol frequencies, the Huffman
-         algorithm allows the construction of an optimal prefix code
-         (one which represents strings with those symbol frequencies
-         using the fewest bits of any possible prefix codes for that
-         alphabet).  Such a code is called a Huffman code.  (See
-         reference [1] in Chapter 5, references for additional
-         information on Huffman codes.)
-
-         Note that in the "deflate" format, the Huffman codes for the
-         various alphabets must not exceed certain maximum code lengths.
-         This constraint complicates the algorithm for computing code
-         lengths from symbol frequencies.  Again, see Chapter 5,
-         references for details.
-
-      3.2.2. Use of Huffman coding in the "deflate" format
-
-         The Huffman codes used for each alphabet in the "deflate"
-         format have two additional rules:
-
-             * All codes of a given bit length have lexicographically
-               consecutive values, in the same order as the symbols
-               they represent;
-
-             * Shorter codes lexicographically precede longer codes.
-
-
-
-
-
-
-
-
-
-
-
-
-Deutsch                      Informational                      [Page 7]
-
-RFC 1951      DEFLATE Compressed Data Format Specification      May 1996
-
-
-         We could recode the example above to follow this rule as
-         follows, assuming that the order of the alphabet is ABCD:
-
-            Symbol  Code
-            ------  ----
-            A       10
-            B       0
-            C       110
-            D       111
-
-         I.e., 0 precedes 10 which precedes 11x, and 110 and 111 are
-         lexicographically consecutive.
-
-         Given this rule, we can define the Huffman code for an alphabet
-         just by giving the bit lengths of the codes for each symbol of
-         the alphabet in order; this is sufficient to determine the
-         actual codes.  In our example, the code is completely defined
-         by the sequence of bit lengths (2, 1, 3, 3).  The following
-         algorithm generates the codes as integers, intended to be read
-         from most- to least-significant bit.  The code lengths are
-         initially in tree[I].Len; the codes are produced in
-         tree[I].Code.
-
-         1)  Count the number of codes for each code length.  Let
-             bl_count[N] be the number of codes of length N, N >= 1.
-
-         2)  Find the numerical value of the smallest code for each
-             code length:
-
-                code = 0;
-                bl_count[0] = 0;
-                for (bits = 1; bits <= MAX_BITS; bits++) {
-                    code = (code + bl_count[bits-1]) << 1;
-                    next_code[bits] = code;
-                }
-
-         3)  Assign numerical values to all codes, using consecutive
-             values for all codes of the same length with the base
-             values determined at step 2. Codes that are never used
-             (which have a bit length of zero) must not be assigned a
-             value.
-
-                for (n = 0;  n <= max_code; n++) {
-                    len = tree[n].Len;
-                    if (len != 0) {
-                        tree[n].Code = next_code[len];
-                        next_code[len]++;
-                    }
-
-
-
-Deutsch                      Informational                      [Page 8]
-
-RFC 1951      DEFLATE Compressed Data Format Specification      May 1996
-
-
-                }
-
-         Example:
-
-         Consider the alphabet ABCDEFGH, with bit lengths (3, 3, 3, 3,
-         3, 2, 4, 4).  After step 1, we have:
-
-            N      bl_count[N]
-            -      -----------
-            2      1
-            3      5
-            4      2
-
-         Step 2 computes the following next_code values:
-
-            N      next_code[N]
-            -      ------------
-            1      0
-            2      0
-            3      2
-            4      14
-
-         Step 3 produces the following code values:
-
-            Symbol Length   Code
-            ------ ------   ----
-            A       3        010
-            B       3        011
-            C       3        100
-            D       3        101
-            E       3        110
-            F       2         00
-            G       4       1110
-            H       4       1111
-
-      3.2.3. Details of block format
-
-         Each block of compressed data begins with 3 header bits
-         containing the following data:
-
-            first bit       BFINAL
-            next 2 bits     BTYPE
-
-         Note that the header bits do not necessarily begin on a byte
-         boundary, since a block does not necessarily occupy an integral
-         number of bytes.
-
-
-
-
-
-Deutsch                      Informational                      [Page 9]
-
-RFC 1951      DEFLATE Compressed Data Format Specification      May 1996
-
-
-         BFINAL is set if and only if this is the last block of the data
-         set.
-
-         BTYPE specifies how the data are compressed, as follows:
-
-            00 - no compression
-            01 - compressed with fixed Huffman codes
-            10 - compressed with dynamic Huffman codes
-            11 - reserved (error)
-
-         The only difference between the two compressed cases is how the
-         Huffman codes for the literal/length and distance alphabets are
-         defined.
-
-         In all cases, the decoding algorithm for the actual data is as
-         follows:
-
-            do
-               read block header from input stream.
-               if stored with no compression
-                  skip any remaining bits in current partially
-                     processed byte
-                  read LEN and NLEN (see next section)
-                  copy LEN bytes of data to output
-               otherwise
-                  if compressed with dynamic Huffman codes
-                     read representation of code trees (see
-                        subsection below)
-                  loop (until end of block code recognized)
-                     decode literal/length value from input stream
-                     if value < 256
-                        copy value (literal byte) to output stream
-                     otherwise
-                        if value = end of block (256)
-                           break from loop
-                        otherwise (value = 257..285)
-                           decode distance from input stream
-
-                           move backwards distance bytes in the output
-                           stream, and copy length bytes from this
-                           position to the output stream.
-                  end loop
-            while not last block
-
-         Note that a duplicated string reference may refer to a string
-         in a previous block; i.e., the backward distance may cross one
-         or more block boundaries.  However a distance cannot refer past
-         the beginning of the output stream.  (An application using a
-
-
-
-Deutsch                      Informational                     [Page 10]
-
-RFC 1951      DEFLATE Compressed Data Format Specification      May 1996
-
-
-         preset dictionary might discard part of the output stream; a
-         distance can refer to that part of the output stream anyway)
-         Note also that the referenced string may overlap the current
-         position; for example, if the last 2 bytes decoded have values
-         X and Y, a string reference with <length = 5, distance = 2>
-         adds X,Y,X,Y,X to the output stream.
-
-         We now specify each compression method in turn.
-
-      3.2.4. Non-compressed blocks (BTYPE=00)
-
-         Any bits of input up to the next byte boundary are ignored.
-         The rest of the block consists of the following information:
-
-              0   1   2   3   4...
-            +---+---+---+---+================================+
-            |  LEN  | NLEN  |... LEN bytes of literal data...|
-            +---+---+---+---+================================+
-
-         LEN is the number of data bytes in the block.  NLEN is the
-         one's complement of LEN.
-
-      3.2.5. Compressed blocks (length and distance codes)
-
-         As noted above, encoded data blocks in the "deflate" format
-         consist of sequences of symbols drawn from three conceptually
-         distinct alphabets: either literal bytes, from the alphabet of
-         byte values (0..255), or <length, backward distance> pairs,
-         where the length is drawn from (3..258) and the distance is
-         drawn from (1..32,768).  In fact, the literal and length
-         alphabets are merged into a single alphabet (0..285), where
-         values 0..255 represent literal bytes, the value 256 indicates
-         end-of-block, and values 257..285 represent length codes
-         (possibly in conjunction with extra bits following the symbol
-         code) as follows:
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-Deutsch                      Informational                     [Page 11]
-
-RFC 1951      DEFLATE Compressed Data Format Specification      May 1996
-
-
-                 Extra               Extra               Extra
-            Code Bits Length(s) Code Bits Lengths   Code Bits Length(s)
-            ---- ---- ------     ---- ---- -------   ---- ---- -------
-             257   0     3       267   1   15,16     277   4   67-82
-             258   0     4       268   1   17,18     278   4   83-98
-             259   0     5       269   2   19-22     279   4   99-114
-             260   0     6       270   2   23-26     280   4  115-130
-             261   0     7       271   2   27-30     281   5  131-162
-             262   0     8       272   2   31-34     282   5  163-194
-             263   0     9       273   3   35-42     283   5  195-226
-             264   0    10       274   3   43-50     284   5  227-257
-             265   1  11,12      275   3   51-58     285   0    258
-             266   1  13,14      276   3   59-66
-
-         The extra bits should be interpreted as a machine integer
-         stored with the most-significant bit first, e.g., bits 1110
-         represent the value 14.
-
-                  Extra           Extra               Extra
-             Code Bits Dist  Code Bits   Dist     Code Bits Distance
-             ---- ---- ----  ---- ----  ------    ---- ---- --------
-               0   0    1     10   4     33-48    20    9   1025-1536
-               1   0    2     11   4     49-64    21    9   1537-2048
-               2   0    3     12   5     65-96    22   10   2049-3072
-               3   0    4     13   5     97-128   23   10   3073-4096
-               4   1   5,6    14   6    129-192   24   11   4097-6144
-               5   1   7,8    15   6    193-256   25   11   6145-8192
-               6   2   9-12   16   7    257-384   26   12  8193-12288
-               7   2  13-16   17   7    385-512   27   12 12289-16384
-               8   3  17-24   18   8    513-768   28   13 16385-24576
-               9   3  25-32   19   8   769-1024   29   13 24577-32768
-
-      3.2.6. Compression with fixed Huffman codes (BTYPE=01)
-
-         The Huffman codes for the two alphabets are fixed, and are not
-         represented explicitly in the data.  The Huffman code lengths
-         for the literal/length alphabet are:
-
-                   Lit Value    Bits        Codes
-                   ---------    ----        -----
-                     0 - 143     8          00110000 through
-                                            10111111
-                   144 - 255     9          110010000 through
-                                            111111111
-                   256 - 279     7          0000000 through
-                                            0010111
-                   280 - 287     8          11000000 through
-                                            11000111
-
-
-
-Deutsch                      Informational                     [Page 12]
-
-RFC 1951      DEFLATE Compressed Data Format Specification      May 1996
-
-
-         The code lengths are sufficient to generate the actual codes,
-         as described above; we show the codes in the table for added
-         clarity.  Literal/length values 286-287 will never actually
-         occur in the compressed data, but participate in the code
-         construction.
-
-         Distance codes 0-31 are represented by (fixed-length) 5-bit
-         codes, with possible additional bits as shown in the table
-         shown in Paragraph 3.2.5, above.  Note that distance codes 30-
-         31 will never actually occur in the compressed data.
-
-      3.2.7. Compression with dynamic Huffman codes (BTYPE=10)
-
-         The Huffman codes for the two alphabets appear in the block
-         immediately after the header bits and before the actual
-         compressed data, first the literal/length code and then the
-         distance code.  Each code is defined by a sequence of code
-         lengths, as discussed in Paragraph 3.2.2, above.  For even
-         greater compactness, the code length sequences themselves are
-         compressed using a Huffman code.  The alphabet for code lengths
-         is as follows:
-
-               0 - 15: Represent code lengths of 0 - 15
-                   16: Copy the previous code length 3 - 6 times.
-                       The next 2 bits indicate repeat length
-                             (0 = 3, ... , 3 = 6)
-                          Example:  Codes 8, 16 (+2 bits 11),
-                                    16 (+2 bits 10) will expand to
-                                    12 code lengths of 8 (1 + 6 + 5)
-                   17: Repeat a code length of 0 for 3 - 10 times.
-                       (3 bits of length)
-                   18: Repeat a code length of 0 for 11 - 138 times
-                       (7 bits of length)
-
-         A code length of 0 indicates that the corresponding symbol in
-         the literal/length or distance alphabet will not occur in the
-         block, and should not participate in the Huffman code
-         construction algorithm given earlier.  If only one distance
-         code is used, it is encoded using one bit, not zero bits; in
-         this case there is a single code length of one, with one unused
-         code.  One distance code of zero bits means that there are no
-         distance codes used at all (the data is all literals).
-
-         We can now define the format of the block:
-
-               5 Bits: HLIT, # of Literal/Length codes - 257 (257 - 286)
-               5 Bits: HDIST, # of Distance codes - 1        (1 - 32)
-               4 Bits: HCLEN, # of Code Length codes - 4     (4 - 19)
-
-
-
-Deutsch                      Informational                     [Page 13]
-
-RFC 1951      DEFLATE Compressed Data Format Specification      May 1996
-
-
-               (HCLEN + 4) x 3 bits: code lengths for the code length
-                  alphabet given just above, in the order: 16, 17, 18,
-                  0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15
-
-                  These code lengths are interpreted as 3-bit integers
-                  (0-7); as above, a code length of 0 means the
-                  corresponding symbol (literal/length or distance code
-                  length) is not used.
-
-               HLIT + 257 code lengths for the literal/length alphabet,
-                  encoded using the code length Huffman code
-
-               HDIST + 1 code lengths for the distance alphabet,
-                  encoded using the code length Huffman code
-
-               The actual compressed data of the block,
-                  encoded using the literal/length and distance Huffman
-                  codes
-
-               The literal/length symbol 256 (end of data),
-                  encoded using the literal/length Huffman code
-
-         The code length repeat codes can cross from HLIT + 257 to the
-         HDIST + 1 code lengths.  In other words, all code lengths form
-         a single sequence of HLIT + HDIST + 258 values.
-
-   3.3. Compliance
-
-      A compressor may limit further the ranges of values specified in
-      the previous section and still be compliant; for example, it may
-      limit the range of backward pointers to some value smaller than
-      32K.  Similarly, a compressor may limit the size of blocks so that
-      a compressible block fits in memory.
-
-      A compliant decompressor must accept the full range of possible
-      values defined in the previous section, and must accept blocks of
-      arbitrary size.
-
-4. Compression algorithm details
-
-   While it is the intent of this document to define the "deflate"
-   compressed data format without reference to any particular
-   compression algorithm, the format is related to the compressed
-   formats produced by LZ77 (Lempel-Ziv 1977, see reference [2] below);
-   since many variations of LZ77 are patented, it is strongly
-   recommended that the implementor of a compressor follow the general
-   algorithm presented here, which is known not to be patented per se.
-   The material in this section is not part of the definition of the
-
-
-
-Deutsch                      Informational                     [Page 14]
-
-RFC 1951      DEFLATE Compressed Data Format Specification      May 1996
-
-
-   specification per se, and a compressor need not follow it in order to
-   be compliant.
-
-   The compressor terminates a block when it determines that starting a
-   new block with fresh trees would be useful, or when the block size
-   fills up the compressor's block buffer.
-
-   The compressor uses a chained hash table to find duplicated strings,
-   using a hash function that operates on 3-byte sequences.  At any
-   given point during compression, let XYZ be the next 3 input bytes to
-   be examined (not necessarily all different, of course).  First, the
-   compressor examines the hash chain for XYZ.  If the chain is empty,
-   the compressor simply writes out X as a literal byte and advances one
-   byte in the input.  If the hash chain is not empty, indicating that
-   the sequence XYZ (or, if we are unlucky, some other 3 bytes with the
-   same hash function value) has occurred recently, the compressor
-   compares all strings on the XYZ hash chain with the actual input data
-   sequence starting at the current point, and selects the longest
-   match.
-
-   The compressor searches the hash chains starting with the most recent
-   strings, to favor small distances and thus take advantage of the
-   Huffman encoding.  The hash chains are singly linked. There are no
-   deletions from the hash chains; the algorithm simply discards matches
-   that are too old.  To avoid a worst-case situation, very long hash
-   chains are arbitrarily truncated at a certain length, determined by a
-   run-time parameter.
-
-   To improve overall compression, the compressor optionally defers the
-   selection of matches ("lazy matching"): after a match of length N has
-   been found, the compressor searches for a longer match starting at
-   the next input byte.  If it finds a longer match, it truncates the
-   previous match to a length of one (thus producing a single literal
-   byte) and then emits the longer match.  Otherwise, it emits the
-   original match, and, as described above, advances N bytes before
-   continuing.
-
-   Run-time parameters also control this "lazy match" procedure.  If
-   compression ratio is most important, the compressor attempts a
-   complete second search regardless of the length of the first match.
-   In the normal case, if the current match is "long enough", the
-   compressor reduces the search for a longer match, thus speeding up
-   the process.  If speed is most important, the compressor inserts new
-   strings in the hash table only when no match was found, or when the
-   match is not "too long".  This degrades the compression ratio but
-   saves time since there are both fewer insertions and fewer searches.
-
-
-
-
-
-Deutsch                      Informational                     [Page 15]
-
-RFC 1951      DEFLATE Compressed Data Format Specification      May 1996
-
-
-5. References
-
-   [1] Huffman, D. A., "A Method for the Construction of Minimum
-       Redundancy Codes", Proceedings of the Institute of Radio
-       Engineers, September 1952, Volume 40, Number 9, pp. 1098-1101.
-
-   [2] Ziv J., Lempel A., "A Universal Algorithm for Sequential Data
-       Compression", IEEE Transactions on Information Theory, Vol. 23,
-       No. 3, pp. 337-343.
-
-   [3] Gailly, J.-L., and Adler, M., ZLIB documentation and sources,
-       available in ftp://ftp.uu.net/pub/archiving/zip/doc/
-
-   [4] Gailly, J.-L., and Adler, M., GZIP documentation and sources,
-       available as gzip-*.tar in ftp://prep.ai.mit.edu/pub/gnu/
-
-   [5] Schwartz, E. S., and Kallick, B. "Generating a canonical prefix
-       encoding." Comm. ACM, 7,3 (Mar. 1964), pp. 166-169.
-
-   [6] Hirschberg and Lelewer, "Efficient decoding of prefix codes,"
-       Comm. ACM, 33,4, April 1990, pp. 449-459.
-
-6. Security Considerations
-
-   Any data compression method involves the reduction of redundancy in
-   the data.  Consequently, any corruption of the data is likely to have
-   severe effects and be difficult to correct.  Uncompressed text, on
-   the other hand, will probably still be readable despite the presence
-   of some corrupted bytes.
-
-   It is recommended that systems using this data format provide some
-   means of validating the integrity of the compressed data.  See
-   reference [3], for example.
-
-7. Source code
-
-   Source code for a C language implementation of a "deflate" compliant
-   compressor and decompressor is available within the zlib package at
-   ftp://ftp.uu.net/pub/archiving/zip/zlib/.
-
-8. Acknowledgements
-
-   Trademarks cited in this document are the property of their
-   respective owners.
-
-   Phil Katz designed the deflate format.  Jean-Loup Gailly and Mark
-   Adler wrote the related software described in this specification.
-   Glenn Randers-Pehrson converted this document to RFC and HTML format.
-
-
-
-Deutsch                      Informational                     [Page 16]
-
-RFC 1951      DEFLATE Compressed Data Format Specification      May 1996
-
-
-9. Author's Address
-
-   L. Peter Deutsch
-   Aladdin Enterprises
-   203 Santa Margarita Ave.
-   Menlo Park, CA 94025
-
-   Phone: (415) 322-0103 (AM only)
-   FAX:   (415) 322-1734
-   EMail: <ghost@aladdin.com>
-
-   Questions about the technical content of this specification can be
-   sent by email to:
-
-   Jean-Loup Gailly <gzip@prep.ai.mit.edu> and
-   Mark Adler <madler@alumni.caltech.edu>
-
-   Editorial comments on this specification can be sent by email to:
-
-   L. Peter Deutsch <ghost@aladdin.com> and
-   Glenn Randers-Pehrson <randeg@alumni.rpi.edu>
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-Deutsch                      Informational                     [Page 17]
-
diff --git a/contrib/libzlib-ng/doc/rfc1952.txt b/contrib/libzlib-ng/doc/rfc1952.txt
deleted file mode 100644
index a8e51b4567f..00000000000
--- a/contrib/libzlib-ng/doc/rfc1952.txt
+++ /dev/null
@@ -1,675 +0,0 @@
-
-
-
-
-
-
-Network Working Group                                         P. Deutsch
-Request for Comments: 1952                           Aladdin Enterprises
-Category: Informational                                         May 1996
-
-
-               GZIP file format specification version 4.3
-
-Status of This Memo
-
-   This memo provides information for the Internet community.  This memo
-   does not specify an Internet standard of any kind.  Distribution of
-   this memo is unlimited.
-
-IESG Note:
-
-   The IESG takes no position on the validity of any Intellectual
-   Property Rights statements contained in this document.
-
-Notices
-
-   Copyright (c) 1996 L. Peter Deutsch
-
-   Permission is granted to copy and distribute this document for any
-   purpose and without charge, including translations into other
-   languages and incorporation into compilations, provided that the
-   copyright notice and this notice are preserved, and that any
-   substantive changes or deletions from the original are clearly
-   marked.
-
-   A pointer to the latest version of this and related documentation in
-   HTML format can be found at the URL
-   <ftp://ftp.uu.net/graphics/png/documents/zlib/zdoc-index.html>.
-
-Abstract
-
-   This specification defines a lossless compressed data format that is
-   compatible with the widely used GZIP utility.  The format includes a
-   cyclic redundancy check value for detecting data corruption.  The
-   format presently uses the DEFLATE method of compression but can be
-   easily extended to use other compression methods.  The format can be
-   implemented readily in a manner not covered by patents.
-
-
-
-
-
-
-
-
-
-
-Deutsch                      Informational                      [Page 1]
-
-RFC 1952             GZIP File Format Specification             May 1996
-
-
-Table of Contents
-
-   1. Introduction ................................................... 2
-      1.1. Purpose ................................................... 2
-      1.2. Intended audience ......................................... 3
-      1.3. Scope ..................................................... 3
-      1.4. Compliance ................................................ 3
-      1.5. Definitions of terms and conventions used ................. 3
-      1.6. Changes from previous versions ............................ 3
-   2. Detailed specification ......................................... 4
-      2.1. Overall conventions ....................................... 4
-      2.2. File format ............................................... 5
-      2.3. Member format ............................................. 5
-          2.3.1. Member header and trailer ........................... 6
-              2.3.1.1. Extra field ................................... 8
-              2.3.1.2. Compliance .................................... 9
-      3. References .................................................. 9
-      4. Security Considerations .................................... 10
-      5. Acknowledgements ........................................... 10
-      6. Author's Address ........................................... 10
-      7. Appendix: Jean-Loup Gailly's gzip utility .................. 11
-      8. Appendix: Sample CRC Code .................................. 11
-
-1. Introduction
-
-   1.1. Purpose
-
-      The purpose of this specification is to define a lossless
-      compressed data format that:
-
-          * Is independent of CPU type, operating system, file system,
-            and character set, and hence can be used for interchange;
-          * Can compress or decompress a data stream (as opposed to a
-            randomly accessible file) to produce another data stream,
-            using only an a priori bounded amount of intermediate
-            storage, and hence can be used in data communications or
-            similar structures such as Unix filters;
-          * Compresses data with efficiency comparable to the best
-            currently available general-purpose compression methods,
-            and in particular considerably better than the "compress"
-            program;
-          * Can be implemented readily in a manner not covered by
-            patents, and hence can be practiced freely;
-          * Is compatible with the file format produced by the current
-            widely used gzip utility, in that conforming decompressors
-            will be able to read data produced by the existing gzip
-            compressor.
-
-
-
-
-Deutsch                      Informational                      [Page 2]
-
-RFC 1952             GZIP File Format Specification             May 1996
-
-
-      The data format defined by this specification does not attempt to:
-
-          * Provide random access to compressed data;
-          * Compress specialized data (e.g., raster graphics) as well as
-            the best currently available specialized algorithms.
-
-   1.2. Intended audience
-
-      This specification is intended for use by implementors of software
-      to compress data into gzip format and/or decompress data from gzip
-      format.
-
-      The text of the specification assumes a basic background in
-      programming at the level of bits and other primitive data
-      representations.
-
-   1.3. Scope
-
-      The specification specifies a compression method and a file format
-      (the latter assuming only that a file can store a sequence of
-      arbitrary bytes).  It does not specify any particular interface to
-      a file system or anything about character sets or encodings
-      (except for file names and comments, which are optional).
-
-   1.4. Compliance
-
-      Unless otherwise indicated below, a compliant decompressor must be
-      able to accept and decompress any file that conforms to all the
-      specifications presented here; a compliant compressor must produce
-      files that conform to all the specifications presented here.  The
-      material in the appendices is not part of the specification per se
-      and is not relevant to compliance.
-
-   1.5. Definitions of terms and conventions used
-
-      byte: 8 bits stored or transmitted as a unit (same as an octet).
-      (For this specification, a byte is exactly 8 bits, even on
-      machines which store a character on a number of bits different
-      from 8.)  See below for the numbering of bits within a byte.
-
-   1.6. Changes from previous versions
-
-      There have been no technical changes to the gzip format since
-      version 4.1 of this specification.  In version 4.2, some
-      terminology was changed, and the sample CRC code was rewritten for
-      clarity and to eliminate the requirement for the caller to do pre-
-      and post-conditioning.  Version 4.3 is a conversion of the
-      specification to RFC style.
-
-
-
-Deutsch                      Informational                      [Page 3]
-
-RFC 1952             GZIP File Format Specification             May 1996
-
-
-2. Detailed specification
-
-   2.1. Overall conventions
-
-      In the diagrams below, a box like this:
-
-         +---+
-         |   | <-- the vertical bars might be missing
-         +---+
-
-      represents one byte; a box like this:
-
-         +==============+
-         |              |
-         +==============+
-
-      represents a variable number of bytes.
-
-      Bytes stored within a computer do not have a "bit order", since
-      they are always treated as a unit.  However, a byte considered as
-      an integer between 0 and 255 does have a most- and least-
-      significant bit, and since we write numbers with the most-
-      significant digit on the left, we also write bytes with the most-
-      significant bit on the left.  In the diagrams below, we number the
-      bits of a byte so that bit 0 is the least-significant bit, i.e.,
-      the bits are numbered:
-
-         +--------+
-         |76543210|
-         +--------+
-
-      This document does not address the issue of the order in which
-      bits of a byte are transmitted on a bit-sequential medium, since
-      the data format described here is byte- rather than bit-oriented.
-
-      Within a computer, a number may occupy multiple bytes.  All
-      multi-byte numbers in the format described here are stored with
-      the least-significant byte first (at the lower memory address).
-      For example, the decimal number 520 is stored as:
-
-             0        1
-         +--------+--------+
-         |00001000|00000010|
-         +--------+--------+
-          ^        ^
-          |        |
-          |        + more significant byte = 2 x 256
-          + less significant byte = 8
-
-
-
-Deutsch                      Informational                      [Page 4]
-
-RFC 1952             GZIP File Format Specification             May 1996
-
-
-   2.2. File format
-
-      A gzip file consists of a series of "members" (compressed data
-      sets).  The format of each member is specified in the following
-      section.  The members simply appear one after another in the file,
-      with no additional information before, between, or after them.
-
-   2.3. Member format
-
-      Each member has the following structure:
-
-         +---+---+---+---+---+---+---+---+---+---+
-         |ID1|ID2|CM |FLG|     MTIME     |XFL|OS | (more-->)
-         +---+---+---+---+---+---+---+---+---+---+
-
-      (if FLG.FEXTRA set)
-
-         +---+---+=================================+
-         | XLEN  |...XLEN bytes of "extra field"...| (more-->)
-         +---+---+=================================+
-
-      (if FLG.FNAME set)
-
-         +=========================================+
-         |...original file name, zero-terminated...| (more-->)
-         +=========================================+
-
-      (if FLG.FCOMMENT set)
-
-         +===================================+
-         |...file comment, zero-terminated...| (more-->)
-         +===================================+
-
-      (if FLG.FHCRC set)
-
-         +---+---+
-         | CRC16 |
-         +---+---+
-
-         +=======================+
-         |...compressed blocks...| (more-->)
-         +=======================+
-
-           0   1   2   3   4   5   6   7
-         +---+---+---+---+---+---+---+---+
-         |     CRC32     |     ISIZE     |
-         +---+---+---+---+---+---+---+---+
-
-
-
-
-Deutsch                      Informational                      [Page 5]
-
-RFC 1952             GZIP File Format Specification             May 1996
-
-
-      2.3.1. Member header and trailer
-
-         ID1 (IDentification 1)
-         ID2 (IDentification 2)
-            These have the fixed values ID1 = 31 (0x1f, \037), ID2 = 139
-            (0x8b, \213), to identify the file as being in gzip format.
-
-         CM (Compression Method)
-            This identifies the compression method used in the file.  CM
-            = 0-7 are reserved.  CM = 8 denotes the "deflate"
-            compression method, which is the one customarily used by
-            gzip and which is documented elsewhere.
-
-         FLG (FLaGs)
-            This flag byte is divided into individual bits as follows:
-
-               bit 0   FTEXT
-               bit 1   FHCRC
-               bit 2   FEXTRA
-               bit 3   FNAME
-               bit 4   FCOMMENT
-               bit 5   reserved
-               bit 6   reserved
-               bit 7   reserved
-
-            If FTEXT is set, the file is probably ASCII text.  This is
-            an optional indication, which the compressor may set by
-            checking a small amount of the input data to see whether any
-            non-ASCII characters are present.  In case of doubt, FTEXT
-            is cleared, indicating binary data. For systems which have
-            different file formats for ascii text and binary data, the
-            decompressor can use FTEXT to choose the appropriate format.
-            We deliberately do not specify the algorithm used to set
-            this bit, since a compressor always has the option of
-            leaving it cleared and a decompressor always has the option
-            of ignoring it and letting some other program handle issues
-            of data conversion.
-
-            If FHCRC is set, a CRC16 for the gzip header is present,
-            immediately before the compressed data. The CRC16 consists
-            of the two least significant bytes of the CRC32 for all
-            bytes of the gzip header up to and not including the CRC16.
-            [The FHCRC bit was never set by versions of gzip up to
-            1.2.4, even though it was documented with a different
-            meaning in gzip 1.2.4.]
-
-            If FEXTRA is set, optional extra fields are present, as
-            described in a following section.
-
-
-
-Deutsch                      Informational                      [Page 6]
-
-RFC 1952             GZIP File Format Specification             May 1996
-
-
-            If FNAME is set, an original file name is present,
-            terminated by a zero byte.  The name must consist of ISO
-            8859-1 (LATIN-1) characters; on operating systems using
-            EBCDIC or any other character set for file names, the name
-            must be translated to the ISO LATIN-1 character set.  This
-            is the original name of the file being compressed, with any
-            directory components removed, and, if the file being
-            compressed is on a file system with case insensitive names,
-            forced to lower case. There is no original file name if the
-            data was compressed from a source other than a named file;
-            for example, if the source was stdin on a Unix system, there
-            is no file name.
-
-            If FCOMMENT is set, a zero-terminated file comment is
-            present.  This comment is not interpreted; it is only
-            intended for human consumption.  The comment must consist of
-            ISO 8859-1 (LATIN-1) characters.  Line breaks should be
-            denoted by a single line feed character (10 decimal).
-
-            Reserved FLG bits must be zero.
-
-         MTIME (Modification TIME)
-            This gives the most recent modification time of the original
-            file being compressed.  The time is in Unix format, i.e.,
-            seconds since 00:00:00 GMT, Jan.  1, 1970.  (Note that this
-            may cause problems for MS-DOS and other systems that use
-            local rather than Universal time.)  If the compressed data
-            did not come from a file, MTIME is set to the time at which
-            compression started.  MTIME = 0 means no time stamp is
-            available.
-
-         XFL (eXtra FLags)
-            These flags are available for use by specific compression
-            methods.  The "deflate" method (CM = 8) sets these flags as
-            follows:
-
-               XFL = 2 - compressor used maximum compression,
-                         slowest algorithm
-               XFL = 4 - compressor used fastest algorithm
-
-         OS (Operating System)
-            This identifies the type of file system on which compression
-            took place.  This may be useful in determining end-of-line
-            convention for text files.  The currently defined values are
-            as follows:
-
-
-
-
-
-
-Deutsch                      Informational                      [Page 7]
-
-RFC 1952             GZIP File Format Specification             May 1996
-
-
-                 0 - FAT filesystem (MS-DOS, OS/2, NT/Win32)
-                 1 - Amiga
-                 2 - VMS (or OpenVMS)
-                 3 - Unix
-                 4 - VM/CMS
-                 5 - Atari TOS
-                 6 - HPFS filesystem (OS/2, NT)
-                 7 - Macintosh
-                 8 - Z-System
-                 9 - CP/M
-                10 - TOPS-20
-                11 - NTFS filesystem (NT)
-                12 - QDOS
-                13 - Acorn RISCOS
-               255 - unknown
-
-         XLEN (eXtra LENgth)
-            If FLG.FEXTRA is set, this gives the length of the optional
-            extra field.  See below for details.
-
-         CRC32 (CRC-32)
-            This contains a Cyclic Redundancy Check value of the
-            uncompressed data computed according to CRC-32 algorithm
-            used in the ISO 3309 standard and in section 8.1.1.6.2 of
-            ITU-T recommendation V.42.  (See http://www.iso.ch for
-            ordering ISO documents. See gopher://info.itu.ch for an
-            online version of ITU-T V.42.)
-
-         ISIZE (Input SIZE)
-            This contains the size of the original (uncompressed) input
-            data modulo 2^32.
-
-      2.3.1.1. Extra field
-
-         If the FLG.FEXTRA bit is set, an "extra field" is present in
-         the header, with total length XLEN bytes.  It consists of a
-         series of subfields, each of the form:
-
-            +---+---+---+---+==================================+
-            |SI1|SI2|  LEN  |... LEN bytes of subfield data ...|
-            +---+---+---+---+==================================+
-
-         SI1 and SI2 provide a subfield ID, typically two ASCII letters
-         with some mnemonic value.  Jean-Loup Gailly
-         <gzip@prep.ai.mit.edu> is maintaining a registry of subfield
-         IDs; please send him any subfield ID you wish to use.  Subfield
-         IDs with SI2 = 0 are reserved for future use.  The following
-         IDs are currently defined:
-
-
-
-Deutsch                      Informational                      [Page 8]
-
-RFC 1952             GZIP File Format Specification             May 1996
-
-
-            SI1         SI2         Data
-            ----------  ----------  ----
-            0x41 ('A')  0x70 ('P')  Apollo file type information
-
-         LEN gives the length of the subfield data, excluding the 4
-         initial bytes.
-
-      2.3.1.2. Compliance
-
-         A compliant compressor must produce files with correct ID1,
-         ID2, CM, CRC32, and ISIZE, but may set all the other fields in
-         the fixed-length part of the header to default values (255 for
-         OS, 0 for all others).  The compressor must set all reserved
-         bits to zero.
-
-         A compliant decompressor must check ID1, ID2, and CM, and
-         provide an error indication if any of these have incorrect
-         values.  It must examine FEXTRA/XLEN, FNAME, FCOMMENT and FHCRC
-         at least so it can skip over the optional fields if they are
-         present.  It need not examine any other part of the header or
-         trailer; in particular, a decompressor may ignore FTEXT and OS
-         and always produce binary output, and still be compliant.  A
-         compliant decompressor must give an error indication if any
-         reserved bit is non-zero, since such a bit could indicate the
-         presence of a new field that would cause subsequent data to be
-         interpreted incorrectly.
-
-3. References
-
-   [1] "Information Processing - 8-bit single-byte coded graphic
-       character sets - Part 1: Latin alphabet No.1" (ISO 8859-1:1987).
-       The ISO 8859-1 (Latin-1) character set is a superset of 7-bit
-       ASCII. Files defining this character set are available as
-       iso_8859-1.* in ftp://ftp.uu.net/graphics/png/documents/
-
-   [2] ISO 3309
-
-   [3] ITU-T recommendation V.42
-
-   [4] Deutsch, L.P.,"DEFLATE Compressed Data Format Specification",
-       available in ftp://ftp.uu.net/pub/archiving/zip/doc/
-
-   [5] Gailly, J.-L., GZIP documentation, available as gzip-*.tar in
-       ftp://prep.ai.mit.edu/pub/gnu/
-
-   [6] Sarwate, D.V., "Computation of Cyclic Redundancy Checks via Table
-       Look-Up", Communications of the ACM, 31(8), pp.1008-1013.
-
-
-
-
-Deutsch                      Informational                      [Page 9]
-
-RFC 1952             GZIP File Format Specification             May 1996
-
-
-   [7] Schwaderer, W.D., "CRC Calculation", April 85 PC Tech Journal,
-       pp.118-133.
-
-   [8] ftp://ftp.adelaide.edu.au/pub/rocksoft/papers/crc_v3.txt,
-       describing the CRC concept.
-
-4. Security Considerations
-
-   Any data compression method involves the reduction of redundancy in
-   the data.  Consequently, any corruption of the data is likely to have
-   severe effects and be difficult to correct.  Uncompressed text, on
-   the other hand, will probably still be readable despite the presence
-   of some corrupted bytes.
-
-   It is recommended that systems using this data format provide some
-   means of validating the integrity of the compressed data, such as by
-   setting and checking the CRC-32 check value.
-
-5. Acknowledgements
-
-   Trademarks cited in this document are the property of their
-   respective owners.
-
-   Jean-Loup Gailly designed the gzip format and wrote, with Mark Adler,
-   the related software described in this specification.  Glenn
-   Randers-Pehrson converted this document to RFC and HTML format.
-
-6. Author's Address
-
-   L. Peter Deutsch
-   Aladdin Enterprises
-   203 Santa Margarita Ave.
-   Menlo Park, CA 94025
-
-   Phone: (415) 322-0103 (AM only)
-   FAX:   (415) 322-1734
-   EMail: <ghost@aladdin.com>
-
-   Questions about the technical content of this specification can be
-   sent by email to:
-
-   Jean-Loup Gailly <gzip@prep.ai.mit.edu> and
-   Mark Adler <madler@alumni.caltech.edu>
-
-   Editorial comments on this specification can be sent by email to:
-
-   L. Peter Deutsch <ghost@aladdin.com> and
-   Glenn Randers-Pehrson <randeg@alumni.rpi.edu>
-
-
-
-Deutsch                      Informational                     [Page 10]
-
-RFC 1952             GZIP File Format Specification             May 1996
-
-
-7. Appendix: Jean-Loup Gailly's gzip utility
-
-   The most widely used implementation of gzip compression, and the
-   original documentation on which this specification is based, were
-   created by Jean-Loup Gailly <gzip@prep.ai.mit.edu>.  Since this
-   implementation is a de facto standard, we mention some more of its
-   features here.  Again, the material in this section is not part of
-   the specification per se, and implementations need not follow it to
-   be compliant.
-
-   When compressing or decompressing a file, gzip preserves the
-   protection, ownership, and modification time attributes on the local
-   file system, since there is no provision for representing protection
-   attributes in the gzip file format itself.  Since the file format
-   includes a modification time, the gzip decompressor provides a
-   command line switch that assigns the modification time from the file,
-   rather than the local modification time of the compressed input, to
-   the decompressed output.
-
-8. Appendix: Sample CRC Code
-
-   The following sample code represents a practical implementation of
-   the CRC (Cyclic Redundancy Check). (See also ISO 3309 and ITU-T V.42
-   for a formal specification.)
-
-   The sample code is in the ANSI C programming language. Non C users
-   may find it easier to read with these hints:
-
-      &      Bitwise AND operator.
-      ^      Bitwise exclusive-OR operator.
-      >>     Bitwise right shift operator. When applied to an
-             unsigned quantity, as here, right shift inserts zero
-             bit(s) at the left.
-      !      Logical NOT operator.
-      ++     "n++" increments the variable n.
-      0xNNN  0x introduces a hexadecimal (base 16) constant.
-             Suffix L indicates a long value (at least 32 bits).
-
-      /* Table of CRCs of all 8-bit messages. */
-      unsigned long crc_table[256];
-
-      /* Flag: has the table been computed? Initially false. */
-      int crc_table_computed = 0;
-
-      /* Make the table for a fast CRC. */
-      void make_crc_table(void)
-      {
-        unsigned long c;
-
-
-
-Deutsch                      Informational                     [Page 11]
-
-RFC 1952             GZIP File Format Specification             May 1996
-
-
-        int n, k;
-        for (n = 0; n < 256; n++) {
-          c = (unsigned long) n;
-          for (k = 0; k < 8; k++) {
-            if (c & 1) {
-              c = 0xedb88320L ^ (c >> 1);
-            } else {
-              c = c >> 1;
-            }
-          }
-          crc_table[n] = c;
-        }
-        crc_table_computed = 1;
-      }
-
-      /*
-         Update a running crc with the bytes buf[0..len-1] and return
-       the updated crc. The crc should be initialized to zero. Pre- and
-       post-conditioning (one's complement) is performed within this
-       function so it shouldn't be done by the caller. Usage example:
-
-         unsigned long crc = 0L;
-
-         while (read_buffer(buffer, length) != EOF) {
-           crc = update_crc(crc, buffer, length);
-         }
-         if (crc != original_crc) error();
-      */
-      unsigned long update_crc(unsigned long crc,
-                      unsigned char *buf, int len)
-      {
-        unsigned long c = crc ^ 0xffffffffL;
-        int n;
-
-        if (!crc_table_computed)
-          make_crc_table();
-        for (n = 0; n < len; n++) {
-          c = crc_table[(c ^ buf[n]) & 0xff] ^ (c >> 8);
-        }
-        return c ^ 0xffffffffL;
-      }
-
-      /* Return the CRC of the bytes buf[0..len-1]. */
-      unsigned long crc(unsigned char *buf, int len)
-      {
-        return update_crc(0L, buf, len);
-      }
-
-
-
-
-Deutsch                      Informational                     [Page 12]
-
diff --git a/contrib/libzlib-ng/doc/txtvsbin.txt b/contrib/libzlib-ng/doc/txtvsbin.txt
deleted file mode 100644
index 3d0f0634f72..00000000000
--- a/contrib/libzlib-ng/doc/txtvsbin.txt
+++ /dev/null
@@ -1,107 +0,0 @@
-A Fast Method for Identifying Plain Text Files
-==============================================
-
-
-Introduction
-------------
-
-Given a file coming from an unknown source, it is sometimes desirable
-to find out whether the format of that file is plain text.  Although
-this may appear like a simple task, a fully accurate detection of the
-file type requires heavy-duty semantic analysis on the file contents.
-It is, however, possible to obtain satisfactory results by employing
-various heuristics.
-
-Previous versions of PKZip and other zip-compatible compression tools
-were using a crude detection scheme: if more than 80% (4/5) of the bytes
-found in a certain buffer are within the range [7..127], the file is
-labeled as plain text, otherwise it is labeled as binary.  A prominent
-limitation of this scheme is the restriction to Latin-based alphabets.
-Other alphabets, like Greek, Cyrillic or Asian, make extensive use of
-the bytes within the range [128..255], and texts using these alphabets
-are most often misidentified by this scheme; in other words, the rate
-of false negatives is sometimes too high, which means that the recall
-is low.  Another weakness of this scheme is a reduced precision, due to
-the false positives that may occur when binary files containing large
-amounts of textual characters are misidentified as plain text.
-
-In this article we propose a new, simple detection scheme that features
-a much increased precision and a near-100% recall.  This scheme is
-designed to work on ASCII, Unicode and other ASCII-derived alphabets,
-and it handles single-byte encodings (ISO-8859, MacRoman, KOI8, etc.)
-and variable-sized encodings (ISO-2022, UTF-8, etc.).  Wider encodings
-(UCS-2/UTF-16 and UCS-4/UTF-32) are not handled, however.
-
-
-The Algorithm
--------------
-
-The algorithm works by dividing the set of bytecodes [0..255] into three
-categories:
-- The white list of textual bytecodes:
-  9 (TAB), 10 (LF), 13 (CR), 32 (SPACE) to 255.
-- The gray list of tolerated bytecodes:
-  7 (BEL), 8 (BS), 11 (VT), 12 (FF), 26 (SUB), 27 (ESC).
-- The black list of undesired, non-textual bytecodes:
-  0 (NUL) to 6, 14 to 31.
-
-If a file contains at least one byte that belongs to the white list and
-no byte that belongs to the black list, then the file is categorized as
-plain text; otherwise, it is categorized as binary.  (The boundary case,
-when the file is empty, automatically falls into the latter category.)
-
-
-Rationale
----------
-
-The idea behind this algorithm relies on two observations.
-
-The first observation is that, although the full range of 7-bit codes
-[0..127] is properly specified by the ASCII standard, most control
-characters in the range [0..31] are not used in practice.  The only
-widely-used, almost universally-portable control codes are 9 (TAB),
-10 (LF) and 13 (CR).  There are a few more control codes that are
-recognized on a reduced range of platforms and text viewers/editors:
-7 (BEL), 8 (BS), 11 (VT), 12 (FF), 26 (SUB) and 27 (ESC); but these
-codes are rarely (if ever) used alone, without being accompanied by
-some printable text.  Even the newer, portable text formats such as
-XML avoid using control characters outside the list mentioned here.
-
-The second observation is that most of the binary files tend to contain
-control characters, especially 0 (NUL).  Even though the older text
-detection schemes observe the presence of non-ASCII codes from the range
-[128..255], the precision rarely has to suffer if this upper range is
-labeled as textual, because the files that are genuinely binary tend to
-contain both control characters and codes from the upper range.  On the
-other hand, the upper range needs to be labeled as textual, because it
-is used by virtually all ASCII extensions.  In particular, this range is
-used for encoding non-Latin scripts.
-
-Since there is no counting involved, other than simply observing the
-presence or the absence of some byte values, the algorithm produces
-consistent results, regardless what alphabet encoding is being used.
-(If counting were involved, it could be possible to obtain different
-results on a text encoded, say, using ISO-8859-16 versus UTF-8.)
-
-There is an extra category of plain text files that are "polluted" with
-one or more black-listed codes, either by mistake or by peculiar design
-considerations.  In such cases, a scheme that tolerates a small fraction
-of black-listed codes would provide an increased recall (i.e. more true
-positives).  This, however, incurs a reduced precision overall, since
-false positives are more likely to appear in binary files that contain
-large chunks of textual data.  Furthermore, "polluted" plain text should
-be regarded as binary by general-purpose text detection schemes, because
-general-purpose text processing algorithms might not be applicable.
-Under this premise, it is safe to say that our detection method provides
-a near-100% recall.
-
-Experiments have been run on many files coming from various platforms
-and applications.  We tried plain text files, system logs, source code,
-formatted office documents, compiled object code, etc.  The results
-confirm the optimistic assumptions about the capabilities of this
-algorithm.
-
-
---
-Cosmin Truta
-Last updated: 2006-May-28
diff --git a/contrib/libzlib-ng/gzclose.c b/contrib/libzlib-ng/gzclose.c
deleted file mode 100644
index 48d6a86f04b..00000000000
--- a/contrib/libzlib-ng/gzclose.c
+++ /dev/null
@@ -1,23 +0,0 @@
-/* gzclose.c -- zlib gzclose() function
- * Copyright (C) 2004, 2010 Mark Adler
- * For conditions of distribution and use, see copyright notice in zlib.h
- */
-
-#include "gzguts.h"
-
-/* gzclose() is in a separate file so that it is linked in only if it is used.
-   That way the other gzclose functions can be used instead to avoid linking in
-   unneeded compression or decompression routines. */
-int ZEXPORT gzclose(gzFile file) {
-#ifndef NO_GZCOMPRESS
-    gz_statep state;
-
-    if (file == NULL)
-        return Z_STREAM_ERROR;
-    state = (gz_statep)file;
-
-    return state->mode == GZ_READ ? gzclose_r(file) : gzclose_w(file);
-#else
-    return gzclose_r(file);
-#endif
-}
diff --git a/contrib/libzlib-ng/gzguts.h b/contrib/libzlib-ng/gzguts.h
deleted file mode 100644
index 0921f176abf..00000000000
--- a/contrib/libzlib-ng/gzguts.h
+++ /dev/null
@@ -1,158 +0,0 @@
-#ifndef GZGUTS_H_
-#define GZGUTS_H_
-/* gzguts.h -- zlib internal header definitions for gz* operations
- * Copyright (C) 2004, 2005, 2010, 2011, 2012, 2013 Mark Adler
- * For conditions of distribution and use, see copyright notice in zlib.h
- */
-
-#ifdef _LARGEFILE64_SOURCE
-#  ifndef _LARGEFILE_SOURCE
-#    define _LARGEFILE_SOURCE 1
-#  endif
-#  ifdef _FILE_OFFSET_BITS
-#    undef _FILE_OFFSET_BITS
-#  endif
-#endif
-
-#if defined(HAVE_INTERNAL)
-#  define ZLIB_INTERNAL __attribute__((visibility ("internal")))
-#elif defined(HAVE_HIDDEN)
-#  define ZLIB_INTERNAL __attribute__((visibility ("hidden")))
-#else
-#  define ZLIB_INTERNAL
-#endif
-
-#include <stdio.h>
-#include <string.h>
-#include <stdlib.h>
-#include <limits.h>
-#include <fcntl.h>
-#include "zlib.h"
-
-#ifdef WIN32
-#  include <stddef.h>
-#endif
-
-#if defined(_MSC_VER) || defined(WIN32)
-#  include <io.h>
-#endif
-
-#if defined(_WIN32) || defined(__CYGWIN__) || defined(__MINGW__)
-#  define WIDECHAR
-#endif
-
-#ifdef WINAPI_FAMILY
-#  define open _open
-#  define read _read
-#  define write _write
-#  define close _close
-#endif
-
-/* In Win32, vsnprintf is available as the "non-ANSI" _vsnprintf. */
-#if !defined(STDC99) && !defined(__CYGWIN__) && !defined(__MINGW__) && defined(WIN32)
-#  if !defined(vsnprintf)
-#    if !defined(_MSC_VER) || ( defined(_MSC_VER) && _MSC_VER < 1500 )
-#       define vsnprintf _vsnprintf
-#    endif
-#  endif
-#endif
-
-/* unlike snprintf (which is required in C99), _snprintf does not guarantee
-   null termination of the result -- however this is only used in gzlib.c
-   where the result is assured to fit in the space provided */
-#if defined(_MSC_VER) && _MSC_VER < 1900
-#  define snprintf _snprintf
-#endif
-
-#ifndef local
-#  define local static
-#endif
-/* compile with -Dlocal if your debugger can't find static symbols */
-
-/* get errno and strerror definition */
-#ifndef NO_STRERROR
-#  include <errno.h>
-#  define zstrerror() strerror(errno)
-#else
-#  define zstrerror() "stdio error (consult errno)"
-#endif
-
-/* provide prototypes for these when building zlib without LFS */
-#if (!defined(_LARGEFILE64_SOURCE) || _LFS64_LARGEFILE-0 == 0) && defined(WITH_GZFILEOP)
-    ZEXTERN gzFile ZEXPORT gzopen64(const char *, const char *);
-    ZEXTERN z_off64_t ZEXPORT gzseek64(gzFile, z_off64_t, int);
-    ZEXTERN z_off64_t ZEXPORT gztell64(gzFile);
-    ZEXTERN z_off64_t ZEXPORT gzoffset64(gzFile);
-#endif
-
-/* default memLevel */
-#if MAX_MEM_LEVEL >= 8
-#  define DEF_MEM_LEVEL 8
-#else
-#  define DEF_MEM_LEVEL  MAX_MEM_LEVEL
-#endif
-
-/* default i/o buffer size -- double this for output when reading (this and
-   twice this must be able to fit in an unsigned type) */
-#define GZBUFSIZE 8192
-
-/* gzip modes, also provide a little integrity check on the passed structure */
-#define GZ_NONE 0
-#define GZ_READ 7247
-#define GZ_WRITE 31153
-#define GZ_APPEND 1     /* mode set to GZ_WRITE after the file is opened */
-
-/* values for gz_state how */
-#define LOOK 0      /* look for a gzip header */
-#define COPY 1      /* copy input directly */
-#define GZIP 2      /* decompress a gzip stream */
-
-/* internal gzip file state data structure */
-typedef struct {
-        /* exposed contents for gzgetc() macro */
-    struct gzFile_s x;      /* "x" for exposed */
-                            /* x.have: number of bytes available at x.next */
-                            /* x.next: next output data to deliver or write */
-                            /* x.pos: current position in uncompressed data */
-        /* used for both reading and writing */
-    int mode;               /* see gzip modes above */
-    int fd;                 /* file descriptor */
-    char *path;             /* path or fd for error messages */
-    unsigned size;          /* buffer size, zero if not allocated yet */
-    unsigned want;          /* requested buffer size, default is GZBUFSIZE */
-    unsigned char *in;      /* input buffer (double-sized when writing) */
-    unsigned char *out;     /* output buffer (double-sized when reading) */
-    int direct;             /* 0 if processing gzip, 1 if transparent */
-        /* just for reading */
-    int how;                /* 0: get header, 1: copy, 2: decompress */
-    z_off64_t start;        /* where the gzip data started, for rewinding */
-    int eof;                /* true if end of input file reached */
-    int past;               /* true if read requested past end */
-        /* just for writing */
-    int level;              /* compression level */
-    int strategy;           /* compression strategy */
-        /* seek request */
-    z_off64_t skip;         /* amount to skip (already rewound if backwards) */
-    int seek;               /* true if seek request pending */
-        /* error information */
-    int err;                /* error code */
-    char *msg;              /* error message */
-        /* zlib inflate or deflate stream */
-    z_stream strm;          /* stream structure in-place (not a pointer) */
-} gz_state;
-typedef gz_state *gz_statep;
-
-/* shared functions */
-void ZLIB_INTERNAL gz_error(gz_statep, int, const char *);
-
-/* GT_OFF(x), where x is an unsigned value, is true if x > maximum z_off64_t
-   value -- needed when comparing unsigned to z_off64_t, which is signed
-   (possible z_off64_t types off_t, off64_t, and long are all signed) */
-#ifdef INT_MAX
-#  define GT_OFF(x) (sizeof(int) == sizeof(z_off64_t) && (x) > INT_MAX)
-#else
-unsigned ZLIB_INTERNAL gz_intmax(void);
-#  define GT_OFF(x) (sizeof(int) == sizeof(z_off64_t) && (x) > gz_intmax())
-#endif
-
-#endif /* GZGUTS_H_ */
diff --git a/contrib/libzlib-ng/gzlib.c b/contrib/libzlib-ng/gzlib.c
deleted file mode 100644
index e5ebe5fa7fa..00000000000
--- a/contrib/libzlib-ng/gzlib.c
+++ /dev/null
@@ -1,518 +0,0 @@
-/* gzlib.c -- zlib functions common to reading and writing gzip files
- * Copyright (C) 2004, 2010, 2011, 2012, 2013 Mark Adler
- * For conditions of distribution and use, see copyright notice in zlib.h
- */
-
-#include "gzguts.h"
-
-#if defined(WIN32) && !defined(__BORLANDC__) && !defined(__MINGW32__)
-#  define LSEEK _lseeki64
-#else
-#if defined(_LARGEFILE64_SOURCE) && _LFS64_LARGEFILE-0
-#  define LSEEK lseek64
-#else
-#  define LSEEK lseek
-#endif
-#endif
-
-/* Local functions */
-local void gz_reset(gz_statep);
-local gzFile gz_open(const void *, int, const char *);
-
-/* Reset gzip file state */
-local void gz_reset(gz_statep state) {
-    state->x.have = 0;              /* no output data available */
-    if (state->mode == GZ_READ) {   /* for reading ... */
-        state->eof = 0;             /* not at end of file */
-        state->past = 0;            /* have not read past end yet */
-        state->how = LOOK;          /* look for gzip header */
-    }
-    state->seek = 0;                /* no seek request pending */
-    gz_error(state, Z_OK, NULL);    /* clear error */
-    state->x.pos = 0;               /* no uncompressed data yet */
-    state->strm.avail_in = 0;       /* no input data yet */
-}
-
-/* Open a gzip file either by name or file descriptor. */
-local gzFile gz_open(const void *path, int fd, const char *mode) {
-    gz_statep state;
-    size_t len;
-    int oflag;
-#ifdef O_CLOEXEC
-    int cloexec = 0;
-#endif
-#ifdef O_EXCL
-    int exclusive = 0;
-#endif
-
-    /* check input */
-    if (path == NULL)
-        return NULL;
-
-    /* allocate gzFile structure to return */
-    state = (gz_statep)malloc(sizeof(gz_state));
-    if (state == NULL)
-        return NULL;
-    state->size = 0;            /* no buffers allocated yet */
-    state->want = GZBUFSIZE;    /* requested buffer size */
-    state->msg = NULL;          /* no error message yet */
-
-    /* interpret mode */
-    state->mode = GZ_NONE;
-    state->level = Z_DEFAULT_COMPRESSION;
-    state->strategy = Z_DEFAULT_STRATEGY;
-    state->direct = 0;
-    while (*mode) {
-        if (*mode >= '0' && *mode <= '9') {
-            state->level = *mode - '0';
-        } else {
-            switch (*mode) {
-            case 'r':
-                state->mode = GZ_READ;
-                break;
-#ifndef NO_GZCOMPRESS
-            case 'w':
-                state->mode = GZ_WRITE;
-                break;
-            case 'a':
-                state->mode = GZ_APPEND;
-                break;
-#endif
-            case '+':       /* can't read and write at the same time */
-                free(state);
-                return NULL;
-            case 'b':       /* ignore -- will request binary anyway */
-                break;
-#ifdef O_CLOEXEC
-            case 'e':
-                cloexec = 1;
-                break;
-#endif
-#ifdef O_EXCL
-            case 'x':
-                exclusive = 1;
-                break;
-#endif
-            case 'f':
-                state->strategy = Z_FILTERED;
-                break;
-            case 'h':
-                state->strategy = Z_HUFFMAN_ONLY;
-                break;
-            case 'R':
-                state->strategy = Z_RLE;
-                break;
-            case 'F':
-                state->strategy = Z_FIXED;
-                break;
-            case 'T':
-                state->direct = 1;
-                break;
-            default:        /* could consider as an error, but just ignore */
-                {}
-            }
-        }
-        mode++;
-    }
-
-    /* must provide an "r", "w", or "a" */
-    if (state->mode == GZ_NONE) {
-        free(state);
-        return NULL;
-    }
-
-    /* can't force transparent read */
-    if (state->mode == GZ_READ) {
-        if (state->direct) {
-            free(state);
-            return NULL;
-        }
-        state->direct = 1;      /* for empty file */
-    }
-
-    /* save the path name for error messages */
-#ifdef WIDECHAR
-    if (fd == -2) {
-        len = wcstombs(NULL, path, 0);
-        if (len == (size_t)-1)
-            len = 0;
-    } else
-#endif
-        len = strlen((const char *)path);
-    state->path = (char *)malloc(len + 1);
-    if (state->path == NULL) {
-        free(state);
-        return NULL;
-    }
-#ifdef WIDECHAR
-    if (fd == -2)
-        if (len) {
-            wcstombs(state->path, path, len + 1);
-        } else {
-            *(state->path) = 0;
-        }
-    else
-#endif
-        snprintf(state->path, len + 1, "%s", (const char *)path);
-
-    /* compute the flags for open() */
-    oflag =
-#ifdef O_LARGEFILE
-        O_LARGEFILE |
-#endif
-#ifdef O_BINARY
-        O_BINARY |
-#endif
-#ifdef O_CLOEXEC
-        (cloexec ? O_CLOEXEC : 0) |
-#endif
-        (state->mode == GZ_READ ?
-         O_RDONLY :
-         (O_WRONLY | O_CREAT |
-#ifdef O_EXCL
-          (exclusive ? O_EXCL : 0) |
-#endif
-          (state->mode == GZ_WRITE ?
-           O_TRUNC :
-           O_APPEND)));
-
-    /* open the file with the appropriate flags (or just use fd) */
-    state->fd = fd > -1 ? fd : (
-#if defined(WIN32) || defined(__MINGW__)
-        fd == -2 ? _wopen(path, oflag, 0666) :
-#elif __CYGWIN__
-        fd == -2 ? open(state->path, oflag, 0666) :
-#endif
-        open((const char *)path, oflag, 0666));
-    if (state->fd == -1) {
-        free(state->path);
-        free(state);
-        return NULL;
-    }
-    if (state->mode == GZ_APPEND) {
-        LSEEK(state->fd, 0, SEEK_END);  /* so gzoffset() is correct */
-        state->mode = GZ_WRITE;         /* simplify later checks */
-    }
-
-    /* save the current position for rewinding (only if reading) */
-    if (state->mode == GZ_READ) {
-        state->start = LSEEK(state->fd, 0, SEEK_CUR);
-        if (state->start == -1) state->start = 0;
-    }
-
-    /* initialize stream */
-    gz_reset(state);
-
-    /* return stream */
-    return (gzFile)state;
-}
-
-/* -- see zlib.h -- */
-gzFile ZEXPORT gzopen(const char *path, const char *mode) {
-    return gz_open(path, -1, mode);
-}
-
-/* -- see zlib.h -- */
-gzFile ZEXPORT gzopen64(const char *path, const char *mode) {
-    return gz_open(path, -1, mode);
-}
-
-/* -- see zlib.h -- */
-gzFile ZEXPORT gzdopen(int fd, const char *mode) {
-    char *path;         /* identifier for error messages */
-    gzFile gz;
-
-    if (fd == -1 || (path = (char *)malloc(7 + 3 * sizeof(int))) == NULL)
-        return NULL;
-    snprintf(path, 7 + 3 * sizeof(int), "<fd:%d>", fd); /* for debugging */
-    gz = gz_open(path, fd, mode);
-    free(path);
-    return gz;
-}
-
-/* -- see zlib.h -- */
-#ifdef WIDECHAR
-gzFile ZEXPORT gzopen_w(const wchar_t *path, const char *mode) {
-    return gz_open(path, -2, mode);
-}
-#endif
-
-/* -- see zlib.h -- */
-int ZEXPORT gzbuffer(gzFile file, unsigned size) {
-    gz_statep state;
-
-    /* get internal structure and check integrity */
-    if (file == NULL)
-        return -1;
-    state = (gz_statep)file;
-    if (state->mode != GZ_READ && state->mode != GZ_WRITE)
-        return -1;
-
-    /* make sure we haven't already allocated memory */
-    if (state->size != 0)
-        return -1;
-
-    /* check and set requested size */
-    if ((size << 1) < size)
-        return -1;              /* need to be able to double it */
-    if (size < 2)
-        size = 2;               /* need two bytes to check magic header */
-    state->want = size;
-    return 0;
-}
-
-/* -- see zlib.h -- */
-int ZEXPORT gzrewind(gzFile file) {
-    gz_statep state;
-
-    /* get internal structure */
-    if (file == NULL)
-        return -1;
-    state = (gz_statep)file;
-
-    /* check that we're reading and that there's no error */
-    if (state->mode != GZ_READ || (state->err != Z_OK && state->err != Z_BUF_ERROR))
-        return -1;
-
-    /* back up and start over */
-    if (LSEEK(state->fd, state->start, SEEK_SET) == -1)
-        return -1;
-    gz_reset(state);
-    return 0;
-}
-
-/* -- see zlib.h -- */
-z_off64_t ZEXPORT gzseek64(gzFile file, z_off64_t offset, int whence) {
-    unsigned n;
-    z_off64_t ret;
-    gz_statep state;
-
-    /* get internal structure and check integrity */
-    if (file == NULL)
-        return -1;
-    state = (gz_statep)file;
-    if (state->mode != GZ_READ && state->mode != GZ_WRITE)
-        return -1;
-
-    /* check that there's no error */
-    if (state->err != Z_OK && state->err != Z_BUF_ERROR)
-        return -1;
-
-    /* can only seek from start or relative to current position */
-    if (whence != SEEK_SET && whence != SEEK_CUR)
-        return -1;
-
-    /* normalize offset to a SEEK_CUR specification */
-    if (whence == SEEK_SET)
-        offset -= state->x.pos;
-    else if (state->seek)
-        offset += state->skip;
-    state->seek = 0;
-
-    /* if within raw area while reading, just go there */
-    if (state->mode == GZ_READ && state->how == COPY && state->x.pos + offset >= 0) {
-        ret = LSEEK(state->fd, offset - state->x.have, SEEK_CUR);
-        if (ret == -1)
-            return -1;
-        state->x.have = 0;
-        state->eof = 0;
-        state->past = 0;
-        state->seek = 0;
-        gz_error(state, Z_OK, NULL);
-        state->strm.avail_in = 0;
-        state->x.pos += offset;
-        return state->x.pos;
-    }
-
-    /* calculate skip amount, rewinding if needed for back seek when reading */
-    if (offset < 0) {
-        if (state->mode != GZ_READ)         /* writing -- can't go backwards */
-            return -1;
-        offset += state->x.pos;
-        if (offset < 0)                     /* before start of file! */
-            return -1;
-        if (gzrewind(file) == -1)           /* rewind, then skip to offset */
-            return -1;
-    }
-
-    /* if reading, skip what's in output buffer (one less gzgetc() check) */
-    if (state->mode == GZ_READ) {
-        n = GT_OFF(state->x.have) || (z_off64_t)state->x.have > offset ? (unsigned)offset : state->x.have;
-        state->x.have -= n;
-        state->x.next += n;
-        state->x.pos += n;
-        offset -= n;
-    }
-
-    /* request skip (if not zero) */
-    if (offset) {
-        state->seek = 1;
-        state->skip = offset;
-    }
-    return state->x.pos + offset;
-}
-
-/* -- see zlib.h -- */
-z_off_t ZEXPORT gzseek(gzFile file, z_off_t offset, int whence) {
-    z_off64_t ret;
-
-    ret = gzseek64(file, (z_off64_t)offset, whence);
-    return ret == (z_off_t)ret ? (z_off_t)ret : -1;
-}
-
-/* -- see zlib.h -- */
-z_off64_t ZEXPORT gztell64(gzFile file) {
-    gz_statep state;
-
-    /* get internal structure and check integrity */
-    if (file == NULL)
-        return -1;
-    state = (gz_statep)file;
-    if (state->mode != GZ_READ && state->mode != GZ_WRITE)
-        return -1;
-
-    /* return position */
-    return state->x.pos + (state->seek ? state->skip : 0);
-}
-
-/* -- see zlib.h -- */
-z_off_t ZEXPORT gztell(gzFile file) {
-    z_off64_t ret;
-
-    ret = gztell64(file);
-    return ret == (z_off_t)ret ? (z_off_t)ret : -1;
-}
-
-/* -- see zlib.h -- */
-z_off64_t ZEXPORT gzoffset64(gzFile file) {
-    z_off64_t offset;
-    gz_statep state;
-
-    /* get internal structure and check integrity */
-    if (file == NULL)
-        return -1;
-    state = (gz_statep)file;
-    if (state->mode != GZ_READ && state->mode != GZ_WRITE)
-        return -1;
-
-    /* compute and return effective offset in file */
-    offset = LSEEK(state->fd, 0, SEEK_CUR);
-    if (offset == -1)
-        return -1;
-    if (state->mode == GZ_READ)             /* reading */
-        offset -= state->strm.avail_in;     /* don't count buffered input */
-    return offset;
-}
-
-/* -- see zlib.h -- */
-z_off_t ZEXPORT gzoffset(gzFile file) {
-    z_off64_t ret;
-
-    ret = gzoffset64(file);
-    return ret == (z_off_t)ret ? (z_off_t)ret : -1;
-}
-
-/* -- see zlib.h -- */
-int ZEXPORT gzeof(gzFile file) {
-    gz_statep state;
-
-    /* get internal structure and check integrity */
-    if (file == NULL)
-        return 0;
-    state = (gz_statep)file;
-    if (state->mode != GZ_READ && state->mode != GZ_WRITE)
-        return 0;
-
-    /* return end-of-file state */
-    return state->mode == GZ_READ ? state->past : 0;
-}
-
-/* -- see zlib.h -- */
-const char * ZEXPORT gzerror(gzFile file, int *errnum) {
-    gz_statep state;
-
-    /* get internal structure and check integrity */
-    if (file == NULL)
-        return NULL;
-    state = (gz_statep)file;
-    if (state->mode != GZ_READ && state->mode != GZ_WRITE)
-        return NULL;
-
-    /* return error information */
-    if (errnum != NULL)
-        *errnum = state->err;
-    return state->err == Z_MEM_ERROR ? "out of memory" : (state->msg == NULL ? "" : state->msg);
-}
-
-/* -- see zlib.h -- */
-void ZEXPORT gzclearerr(gzFile file) {
-    gz_statep state;
-
-    /* get internal structure and check integrity */
-    if (file == NULL)
-        return;
-    state = (gz_statep)file;
-    if (state->mode != GZ_READ && state->mode != GZ_WRITE)
-        return;
-
-    /* clear error and end-of-file */
-    if (state->mode == GZ_READ) {
-        state->eof = 0;
-        state->past = 0;
-    }
-    gz_error(state, Z_OK, NULL);
-}
-
-/* Create an error message in allocated memory and set state->err and
-   state->msg accordingly.  Free any previous error message already there.  Do
-   not try to free or allocate space if the error is Z_MEM_ERROR (out of
-   memory).  Simply save the error message as a static string.  If there is an
-   allocation failure constructing the error message, then convert the error to
-   out of memory. */
-void ZLIB_INTERNAL gz_error(gz_statep state, int err, const char *msg) {
-    /* free previously allocated message and clear */
-    if (state->msg != NULL) {
-        if (state->err != Z_MEM_ERROR)
-            free(state->msg);
-        state->msg = NULL;
-    }
-
-    /* if fatal, set state->x.have to 0 so that the gzgetc() macro fails */
-    if (err != Z_OK && err != Z_BUF_ERROR)
-        state->x.have = 0;
-
-    /* set error code, and if no message, then done */
-    state->err = err;
-    if (msg == NULL)
-        return;
-
-    /* for an out of memory error, return literal string when requested */
-    if (err == Z_MEM_ERROR)
-        return;
-
-    /* construct error message with path */
-    if ((state->msg = (char *)malloc(strlen(state->path) + strlen(msg) + 3)) == NULL) {
-        state->err = Z_MEM_ERROR;
-        return;
-    }
-    snprintf(state->msg, strlen(state->path) + strlen(msg) + 3, "%s%s%s", state->path, ": ", msg);
-    return;
-}
-
-#ifndef INT_MAX
-/* portably return maximum value for an int (when limits.h presumed not
-   available) -- we need to do this to cover cases where 2's complement not
-   used, since C standard permits 1's complement and sign-bit representations,
-   otherwise we could just use ((unsigned)-1) >> 1 */
-unsigned ZLIB_INTERNAL gz_intmax() {
-    unsigned p, q;
-
-    p = 1;
-    do {
-        q = p;
-        p <<= 1;
-        p++;
-    } while (p > q);
-    return q >> 1;
-}
-#endif
diff --git a/contrib/libzlib-ng/gzread.c b/contrib/libzlib-ng/gzread.c
deleted file mode 100644
index 5db2c5045ba..00000000000
--- a/contrib/libzlib-ng/gzread.c
+++ /dev/null
@@ -1,538 +0,0 @@
-/* gzread.c -- zlib functions for reading gzip files
- * Copyright (C) 2004, 2005, 2010, 2011, 2012, 2013 Mark Adler
- * For conditions of distribution and use, see copyright notice in zlib.h
- */
-
-#include "gzguts.h"
-
-/* Local functions */
-local int gz_load(gz_statep, unsigned char *, unsigned, unsigned *);
-local int gz_avail(gz_statep);
-local int gz_look(gz_statep);
-local int gz_decomp(gz_statep);
-local int gz_fetch(gz_statep);
-local int gz_skip(gz_statep, z_off64_t);
-
-/* Use read() to load a buffer -- return -1 on error, otherwise 0.  Read from
-   state->fd, and update state->eof, state->err, and state->msg as appropriate.
-   This function needs to loop on read(), since read() is not guaranteed to
-   read the number of bytes requested, depending on the type of descriptor. */
-local int gz_load(gz_statep state, unsigned char *buf, unsigned len, unsigned *have) {
-    int ret;
-
-    *have = 0;
-    do {
-        ret = read(state->fd, buf + *have, len - *have);
-        if (ret <= 0)
-            break;
-        *have += ret;
-    } while (*have < len);
-    if (ret < 0) {
-        gz_error(state, Z_ERRNO, zstrerror());
-        return -1;
-    }
-    if (ret == 0)
-        state->eof = 1;
-    return 0;
-}
-
-/* Load up input buffer and set eof flag if last data loaded -- return -1 on
-   error, 0 otherwise.  Note that the eof flag is set when the end of the input
-   file is reached, even though there may be unused data in the buffer.  Once
-   that data has been used, no more attempts will be made to read the file.
-   If strm->avail_in != 0, then the current data is moved to the beginning of
-   the input buffer, and then the remainder of the buffer is loaded with the
-   available data from the input file. */
-local int gz_avail(gz_statep state) {
-    unsigned got;
-    z_stream *strm = &(state->strm);
-
-    if (state->err != Z_OK && state->err != Z_BUF_ERROR)
-        return -1;
-    if (state->eof == 0) {
-        if (strm->avail_in) {       /* copy what's there to the start */
-            unsigned char *p = state->in;
-            unsigned const char *q = strm->next_in;
-            unsigned n = strm->avail_in;
-            do {
-                *p++ = *q++;
-            } while (--n);
-        }
-        if (gz_load(state, state->in + strm->avail_in, state->size - strm->avail_in, &got) == -1)
-            return -1;
-        strm->avail_in += got;
-        strm->next_in = state->in;
-    }
-    return 0;
-}
-
-/* Look for gzip header, set up for inflate or copy.  state->x.have must be 0.
-   If this is the first time in, allocate required memory.  state->how will be
-   left unchanged if there is no more input data available, will be set to COPY
-   if there is no gzip header and direct copying will be performed, or it will
-   be set to GZIP for decompression.  If direct copying, then leftover input
-   data from the input buffer will be copied to the output buffer.  In that
-   case, all further file reads will be directly to either the output buffer or
-   a user buffer.  If decompressing, the inflate state will be initialized.
-   gz_look() will return 0 on success or -1 on failure. */
-local int gz_look(gz_statep state) {
-    z_stream *strm = &(state->strm);
-
-    /* allocate read buffers and inflate memory */
-    if (state->size == 0) {
-        /* allocate buffers */
-        state->in = (unsigned char *)malloc(state->want);
-        state->out = (unsigned char *)malloc(state->want << 1);
-        if (state->in == NULL || state->out == NULL) {
-            if (state->out != NULL)
-                free(state->out);
-            if (state->in != NULL)
-                free(state->in);
-            gz_error(state, Z_MEM_ERROR, "out of memory");
-            return -1;
-        }
-        state->size = state->want;
-
-        /* allocate inflate memory */
-        state->strm.zalloc = Z_NULL;
-        state->strm.zfree = Z_NULL;
-        state->strm.opaque = Z_NULL;
-        state->strm.avail_in = 0;
-        state->strm.next_in = Z_NULL;
-        if (inflateInit2(&(state->strm), 15 + 16) != Z_OK) {    /* gunzip */
-            free(state->out);
-            free(state->in);
-            state->size = 0;
-            gz_error(state, Z_MEM_ERROR, "out of memory");
-            return -1;
-        }
-    }
-
-    /* get at least the magic bytes in the input buffer */
-    if (strm->avail_in < 2) {
-        if (gz_avail(state) == -1)
-            return -1;
-        if (strm->avail_in == 0)
-            return 0;
-    }
-
-    /* look for gzip magic bytes -- if there, do gzip decoding (note: there is
-       a logical dilemma here when considering the case of a partially written
-       gzip file, to wit, if a single 31 byte is written, then we cannot tell
-       whether this is a single-byte file, or just a partially written gzip
-       file -- for here we assume that if a gzip file is being written, then
-       the header will be written in a single operation, so that reading a
-       single byte is sufficient indication that it is not a gzip file) */
-    if (strm->avail_in > 1 &&
-            strm->next_in[0] == 31 && strm->next_in[1] == 139) {
-        inflateReset(strm);
-        state->how = GZIP;
-        state->direct = 0;
-        return 0;
-    }
-
-    /* no gzip header -- if we were decoding gzip before, then this is trailing
-       garbage.  Ignore the trailing garbage and finish. */
-    if (state->direct == 0) {
-        strm->avail_in = 0;
-        state->eof = 1;
-        state->x.have = 0;
-        return 0;
-    }
-
-    /* doing raw i/o, copy any leftover input to output -- this assumes that
-       the output buffer is larger than the input buffer, which also assures
-       space for gzungetc() */
-    state->x.next = state->out;
-    if (strm->avail_in) {
-        memcpy(state->x.next, strm->next_in, strm->avail_in);
-        state->x.have = strm->avail_in;
-        strm->avail_in = 0;
-    }
-    state->how = COPY;
-    state->direct = 1;
-    return 0;
-}
-
-/* Decompress from input to the provided next_out and avail_out in the state.
-   On return, state->x.have and state->x.next point to the just decompressed
-   data.  If the gzip stream completes, state->how is reset to LOOK to look for
-   the next gzip stream or raw data, once state->x.have is depleted.  Returns 0
-   on success, -1 on failure. */
-local int gz_decomp(gz_statep state) {
-    int ret = Z_OK;
-    unsigned had;
-    z_stream *strm = &(state->strm);
-
-    /* fill output buffer up to end of deflate stream */
-    had = strm->avail_out;
-    do {
-        /* get more input for inflate() */
-        if (strm->avail_in == 0 && gz_avail(state) == -1)
-            return -1;
-        if (strm->avail_in == 0) {
-            gz_error(state, Z_BUF_ERROR, "unexpected end of file");
-            break;
-        }
-
-        /* decompress and handle errors */
-        ret = inflate(strm, Z_NO_FLUSH);
-        if (ret == Z_STREAM_ERROR || ret == Z_NEED_DICT) {
-            gz_error(state, Z_STREAM_ERROR, "internal error: inflate stream corrupt");
-            return -1;
-        }
-        if (ret == Z_MEM_ERROR) {
-            gz_error(state, Z_MEM_ERROR, "out of memory");
-            return -1;
-        }
-        if (ret == Z_DATA_ERROR) {              /* deflate stream invalid */
-            gz_error(state, Z_DATA_ERROR, strm->msg == NULL ? "compressed data error" : strm->msg);
-            return -1;
-        }
-    } while (strm->avail_out && ret != Z_STREAM_END);
-
-    /* update available output */
-    state->x.have = had - strm->avail_out;
-    state->x.next = strm->next_out - state->x.have;
-
-    /* if the gzip stream completed successfully, look for another */
-    if (ret == Z_STREAM_END)
-        state->how = LOOK;
-
-    /* good decompression */
-    return 0;
-}
-
-/* Fetch data and put it in the output buffer.  Assumes state->x.have is 0.
-   Data is either copied from the input file or decompressed from the input
-   file depending on state->how.  If state->how is LOOK, then a gzip header is
-   looked for to determine whether to copy or decompress.  Returns -1 on error,
-   otherwise 0.  gz_fetch() will leave state->how as COPY or GZIP unless the
-   end of the input file has been reached and all data has been processed.  */
-local int gz_fetch(gz_statep state) {
-    z_stream *strm = &(state->strm);
-
-    do {
-        switch (state->how) {
-        case LOOK:      /* -> LOOK, COPY (only if never GZIP), or GZIP */
-            if (gz_look(state) == -1)
-                return -1;
-            if (state->how == LOOK)
-                return 0;
-            break;
-        case COPY:      /* -> COPY */
-            if (gz_load(state, state->out, state->size << 1, &(state->x.have))
-                    == -1)
-                return -1;
-            state->x.next = state->out;
-            return 0;
-        case GZIP:      /* -> GZIP or LOOK (if end of gzip stream) */
-            strm->avail_out = state->size << 1;
-            strm->next_out = state->out;
-            if (gz_decomp(state) == -1)
-                return -1;
-        }
-    } while (state->x.have == 0 && (!state->eof || strm->avail_in));
-    return 0;
-}
-
-/* Skip len uncompressed bytes of output.  Return -1 on error, 0 on success. */
-local int gz_skip(gz_statep state, z_off64_t len) {
-    unsigned n;
-
-    /* skip over len bytes or reach end-of-file, whichever comes first */
-    while (len)
-        /* skip over whatever is in output buffer */
-        if (state->x.have) {
-            n = GT_OFF(state->x.have) || (z_off64_t)state->x.have > len ?
-                (unsigned)len : state->x.have;
-            state->x.have -= n;
-            state->x.next += n;
-            state->x.pos += n;
-            len -= n;
-        } else if (state->eof && state->strm.avail_in == 0) {
-            /* output buffer empty -- return if we're at the end of the input */
-            break;
-        } else {
-            /* need more data to skip -- load up output buffer */
-            /* get more output, looking for header if required */
-            if (gz_fetch(state) == -1)
-                return -1;
-        }
-    return 0;
-}
-
-/* -- see zlib.h -- */
-int ZEXPORT gzread(gzFile file, void *buf, unsigned len) {
-    unsigned got, n;
-    gz_statep state;
-    z_stream *strm;
-
-    /* get internal structure */
-    if (file == NULL)
-        return -1;
-    state = (gz_statep)file;
-    strm = &(state->strm);
-
-    /* check that we're reading and that there's no (serious) error */
-    if (state->mode != GZ_READ || (state->err != Z_OK && state->err != Z_BUF_ERROR))
-        return -1;
-
-    /* since an int is returned, make sure len fits in one, otherwise return
-       with an error (this avoids the flaw in the interface) */
-    if ((int)len < 0) {
-        gz_error(state, Z_DATA_ERROR, "requested length does not fit in int");
-        return -1;
-    }
-
-    /* if len is zero, avoid unnecessary operations */
-    if (len == 0)
-        return 0;
-
-    /* process a skip request */
-    if (state->seek) {
-        state->seek = 0;
-        if (gz_skip(state, state->skip) == -1)
-            return -1;
-    }
-
-    /* get len bytes to buf, or less than len if at the end */
-    got = 0;
-    do {
-        /* first just try copying data from the output buffer */
-        if (state->x.have) {
-            n = state->x.have > len ? len : state->x.have;
-            memcpy(buf, state->x.next, n);
-            state->x.next += n;
-            state->x.have -= n;
-        } else if (state->eof && strm->avail_in == 0) {
-            /* output buffer empty -- return if we're at the end of the input */
-            state->past = 1;        /* tried to read past end */
-            break;
-        } else if (state->how == LOOK || len < (state->size << 1)) {
-            /* need output data -- for small len or new stream load up our output buffer */
-            /* get more output, looking for header if required */
-            if (gz_fetch(state) == -1)
-                return -1;
-            continue;       /* no progress yet -- go back to copy above */
-            /* the copy above assures that we will leave with space in the
-               output buffer, allowing at least one gzungetc() to succeed */
-        } else if (state->how == COPY) {      /* read directly */
-            /* large len -- read directly into user buffer */
-            if (gz_load(state, (unsigned char *)buf, len, &n) == -1)
-                return -1;
-        } else {  /* state->how == GZIP */
-            /* large len -- decompress directly into user buffer */
-            strm->avail_out = len;
-            strm->next_out = (unsigned char *)buf;
-            if (gz_decomp(state) == -1)
-                return -1;
-            n = state->x.have;
-            state->x.have = 0;
-        }
-
-        /* update progress */
-        len -= n;
-        buf = (char *)buf + n;
-        got += n;
-        state->x.pos += n;
-    } while (len);
-
-    /* return number of bytes read into user buffer (will fit in int) */
-    return (int)got;
-}
-
-/* -- see zlib.h -- */
-#undef gzgetc
-int ZEXPORT gzgetc(gzFile file) {
-    int ret;
-    unsigned char buf[1];
-    gz_statep state;
-
-    /* get internal structure */
-    if (file == NULL)
-        return -1;
-    state = (gz_statep)file;
-
-    /* check that we're reading and that there's no (serious) error */
-    if (state->mode != GZ_READ || (state->err != Z_OK && state->err != Z_BUF_ERROR))
-        return -1;
-
-    /* try output buffer (no need to check for skip request) */
-    if (state->x.have) {
-        state->x.have--;
-        state->x.pos++;
-        return *(state->x.next)++;
-    }
-
-    /* nothing there -- try gzread() */
-    ret = gzread(file, buf, 1);
-    return ret < 1 ? -1 : buf[0];
-}
-
-int ZEXPORT gzgetc_(gzFile file) {
-    return gzgetc(file);
-}
-
-/* -- see zlib.h -- */
-int ZEXPORT gzungetc(int c, gzFile file) {
-    gz_statep state;
-
-    /* get internal structure */
-    if (file == NULL)
-        return -1;
-    state = (gz_statep)file;
-
-    /* check that we're reading and that there's no (serious) error */
-    if (state->mode != GZ_READ || (state->err != Z_OK && state->err != Z_BUF_ERROR))
-        return -1;
-
-    /* process a skip request */
-    if (state->seek) {
-        state->seek = 0;
-        if (gz_skip(state, state->skip) == -1)
-            return -1;
-    }
-
-    /* can't push EOF */
-    if (c < 0)
-        return -1;
-
-    /* if output buffer empty, put byte at end (allows more pushing) */
-    if (state->x.have == 0) {
-        state->x.have = 1;
-        state->x.next = state->out + (state->size << 1) - 1;
-        state->x.next[0] = c;
-        state->x.pos--;
-        state->past = 0;
-        return c;
-    }
-
-    /* if no room, give up (must have already done a gzungetc()) */
-    if (state->x.have == (state->size << 1)) {
-        gz_error(state, Z_DATA_ERROR, "out of room to push characters");
-        return -1;
-    }
-
-    /* slide output data if needed and insert byte before existing data */
-    if (state->x.next == state->out) {
-        unsigned char *src = state->out + state->x.have;
-        unsigned char *dest = state->out + (state->size << 1);
-        while (src > state->out)
-            *--dest = *--src;
-        state->x.next = dest;
-    }
-    state->x.have++;
-    state->x.next--;
-    state->x.next[0] = c;
-    state->x.pos--;
-    state->past = 0;
-    return c;
-}
-
-/* -- see zlib.h -- */
-char * ZEXPORT gzgets(gzFile file, char *buf, int len) {
-    unsigned left, n;
-    char *str;
-    unsigned char *eol;
-    gz_statep state;
-
-    /* check parameters and get internal structure */
-    if (file == NULL || buf == NULL || len < 1)
-        return NULL;
-    state = (gz_statep)file;
-
-    /* check that we're reading and that there's no (serious) error */
-    if (state->mode != GZ_READ || (state->err != Z_OK && state->err != Z_BUF_ERROR))
-        return NULL;
-
-    /* process a skip request */
-    if (state->seek) {
-        state->seek = 0;
-        if (gz_skip(state, state->skip) == -1)
-            return NULL;
-    }
-
-    /* copy output bytes up to new line or len - 1, whichever comes first --
-       append a terminating zero to the string (we don't check for a zero in
-       the contents, let the user worry about that) */
-    str = buf;
-    left = (unsigned)len - 1;
-    if (left) do {
-        /* assure that something is in the output buffer */
-        if (state->x.have == 0 && gz_fetch(state) == -1)
-            return NULL;                /* error */
-        if (state->x.have == 0) {       /* end of file */
-            state->past = 1;            /* read past end */
-            break;                      /* return what we have */
-        }
-
-        /* look for end-of-line in current output buffer */
-        n = state->x.have > left ? left : state->x.have;
-        eol = (unsigned char *)memchr(state->x.next, '\n', n);
-        if (eol != NULL)
-            n = (unsigned)(eol - state->x.next) + 1;
-
-        /* copy through end-of-line, or remainder if not found */
-        memcpy(buf, state->x.next, n);
-        state->x.have -= n;
-        state->x.next += n;
-        state->x.pos += n;
-        left -= n;
-        buf += n;
-    } while (left && eol == NULL);
-
-    /* return terminated string, or if nothing, end of file */
-    if (buf == str)
-        return NULL;
-    buf[0] = 0;
-    return str;
-}
-
-/* -- see zlib.h -- */
-int ZEXPORT gzdirect(gzFile file) {
-    gz_statep state;
-
-    /* get internal structure */
-    if (file == NULL)
-        return 0;
-
-    state = (gz_statep)file;
-
-    /* if the state is not known, but we can find out, then do so (this is
-       mainly for right after a gzopen() or gzdopen()) */
-    if (state->mode == GZ_READ && state->how == LOOK && state->x.have == 0)
-        (void)gz_look(state);
-
-    /* return 1 if transparent, 0 if processing a gzip stream */
-    return state->direct;
-}
-
-/* -- see zlib.h -- */
-int ZEXPORT gzclose_r(gzFile file) {
-    int ret, err;
-    gz_statep state;
-
-    /* get internal structure */
-    if (file == NULL)
-        return Z_STREAM_ERROR;
-
-    state = (gz_statep)file;
-
-    /* check that we're reading */
-    if (state->mode != GZ_READ)
-        return Z_STREAM_ERROR;
-
-    /* free memory and close file */
-    if (state->size) {
-        inflateEnd(&(state->strm));
-        free(state->out);
-        free(state->in);
-    }
-    err = state->err == Z_BUF_ERROR ? Z_BUF_ERROR : Z_OK;
-    gz_error(state, Z_OK, NULL);
-    free(state->path);
-    ret = close(state->fd);
-    free(state);
-    return ret ? Z_ERRNO : err;
-}
diff --git a/contrib/libzlib-ng/gzwrite.c b/contrib/libzlib-ng/gzwrite.c
deleted file mode 100644
index dedaee0cd45..00000000000
--- a/contrib/libzlib-ng/gzwrite.c
+++ /dev/null
@@ -1,457 +0,0 @@
-/* gzwrite.c -- zlib functions for writing gzip files
- * Copyright (C) 2004, 2005, 2010, 2011, 2012, 2013 Mark Adler
- * For conditions of distribution and use, see copyright notice in zlib.h
- */
-
-#include <stdarg.h>
-#include "gzguts.h"
-
-/* Local functions */
-local int gz_init(gz_statep);
-local int gz_comp(gz_statep, int);
-local int gz_zero(gz_statep, z_off64_t);
-
-/* Initialize state for writing a gzip file.  Mark initialization by setting
-   state->size to non-zero.  Return -1 on failure or 0 on success. */
-local int gz_init(gz_statep state) {
-    int ret;
-    z_stream *strm = &(state->strm);
-
-    /* allocate input buffer (double size for gzprintf) */
-    state->in = (unsigned char *)malloc(state->want << 1);
-    if (state->in == NULL) {
-        gz_error(state, Z_MEM_ERROR, "out of memory");
-        return -1;
-    }
-
-    /* only need output buffer and deflate state if compressing */
-    if (!state->direct) {
-        /* allocate output buffer */
-        state->out = (unsigned char *)malloc(state->want);
-        if (state->out == NULL) {
-            free(state->in);
-            gz_error(state, Z_MEM_ERROR, "out of memory");
-            return -1;
-        }
-
-        /* allocate deflate memory, set up for gzip compression */
-        strm->zalloc = Z_NULL;
-        strm->zfree = Z_NULL;
-        strm->opaque = Z_NULL;
-        ret = deflateInit2(strm, state->level, Z_DEFLATED, MAX_WBITS + 16, DEF_MEM_LEVEL, state->strategy);
-        if (ret != Z_OK) {
-            free(state->out);
-            free(state->in);
-            gz_error(state, Z_MEM_ERROR, "out of memory");
-            return -1;
-        }
-        strm->next_in = NULL;
-    }
-
-    /* mark state as initialized */
-    state->size = state->want;
-
-    /* initialize write buffer if compressing */
-    if (!state->direct) {
-        strm->avail_out = state->size;
-        strm->next_out = state->out;
-        state->x.next = strm->next_out;
-    }
-    return 0;
-}
-
-/* Compress whatever is at avail_in and next_in and write to the output file.
-   Return -1 if there is an error writing to the output file, otherwise 0.
-   flush is assumed to be a valid deflate() flush value.  If flush is Z_FINISH,
-   then the deflate() state is reset to start a new gzip stream.  If gz->direct
-   is true, then simply write to the output file without compressing, and
-   ignore flush. */
-local int gz_comp(gz_statep state, int flush) {
-    int ret, got;
-    unsigned have;
-    z_stream *strm = &(state->strm);
-
-    /* allocate memory if this is the first time through */
-    if (state->size == 0 && gz_init(state) == -1)
-        return -1;
-
-    /* write directly if requested */
-    if (state->direct) {
-        while (strm->avail_in) {
-            if ((got = write(state->fd, strm->next_in, strm->avail_in)) < 0) {
-                gz_error(state, Z_ERRNO, zstrerror());
-                return -1;
-            }
-            strm->avail_in -= got;
-            strm->next_in += got;
-        }
-        return 0;
-    }
-
-    /* run deflate() on provided input until it produces no more output */
-    ret = Z_OK;
-    do {
-        /* write out current buffer contents if full, or if flushing, but if
-           doing Z_FINISH then don't write until we get to Z_STREAM_END */
-        if (strm->avail_out == 0 || (flush != Z_NO_FLUSH && (flush != Z_FINISH || ret == Z_STREAM_END))) {
-            while (strm->next_out > state->x.next) {
-                if ((got = write(state->fd, state->x.next, strm->next_out - state->x.next)) < 0) {
-                    gz_error(state, Z_ERRNO, zstrerror());
-                    return -1;
-                }
-                state->x.next += got;
-            }
-            if (strm->avail_out == 0) {
-                strm->avail_out = state->size;
-                strm->next_out = state->out;
-            }
-        }
-
-        /* compress */
-        have = strm->avail_out;
-        ret = deflate(strm, flush);
-        if (ret == Z_STREAM_ERROR) {
-            gz_error(state, Z_STREAM_ERROR, "internal error: deflate stream corrupt");
-            return -1;
-        }
-        have -= strm->avail_out;
-    } while (have);
-
-    /* if that completed a deflate stream, allow another to start */
-    if (flush == Z_FINISH)
-        deflateReset(strm);
-
-    /* all done, no errors */
-    return 0;
-}
-
-/* Compress len zeros to output.  Return -1 on error, 0 on success. */
-local int gz_zero(gz_statep state, z_off64_t len) {
-    int first;
-    unsigned n;
-    z_stream *strm = &(state->strm);
-
-    /* consume whatever's left in the input buffer */
-    if (strm->avail_in && gz_comp(state, Z_NO_FLUSH) == -1)
-        return -1;
-
-    /* compress len zeros (len guaranteed > 0) */
-    first = 1;
-    while (len) {
-        n = GT_OFF(state->size) || (z_off64_t)state->size > len ? (unsigned)len : state->size;
-        if (first) {
-            memset(state->in, 0, n);
-            first = 0;
-        }
-        strm->avail_in = n;
-        strm->next_in = state->in;
-        state->x.pos += n;
-        if (gz_comp(state, Z_NO_FLUSH) == -1)
-            return -1;
-        len -= n;
-    }
-    return 0;
-}
-
-/* -- see zlib.h -- */
-int ZEXPORT gzwrite(gzFile file, void const *buf, unsigned len) {
-    unsigned put = len;
-    gz_statep state;
-    z_stream *strm;
-
-    /* get internal structure */
-    if (file == NULL)
-        return 0;
-    state = (gz_statep)file;
-    strm = &(state->strm);
-
-    /* check that we're writing and that there's no error */
-    if (state->mode != GZ_WRITE || state->err != Z_OK)
-        return 0;
-
-    /* since an int is returned, make sure len fits in one, otherwise return
-       with an error (this avoids the flaw in the interface) */
-    if ((int)len < 0) {
-        gz_error(state, Z_DATA_ERROR, "requested length does not fit in int");
-        return 0;
-    }
-
-    /* if len is zero, avoid unnecessary operations */
-    if (len == 0)
-        return 0;
-
-    /* allocate memory if this is the first time through */
-    if (state->size == 0 && gz_init(state) == -1)
-        return 0;
-
-    /* check for seek request */
-    if (state->seek) {
-        state->seek = 0;
-        if (gz_zero(state, state->skip) == -1)
-            return 0;
-    }
-
-    /* for small len, copy to input buffer, otherwise compress directly */
-    if (len < state->size) {
-        /* copy to input buffer, compress when full */
-        do {
-            unsigned have, copy;
-
-            if (strm->avail_in == 0)
-                strm->next_in = state->in;
-            have = (unsigned)((strm->next_in + strm->avail_in) - state->in);
-            copy = state->size - have;
-            if (copy > len)
-                copy = len;
-            memcpy(state->in + have, buf, copy);
-            strm->avail_in += copy;
-            state->x.pos += copy;
-            buf = (const char *)buf + copy;
-            len -= copy;
-            if (len && gz_comp(state, Z_NO_FLUSH) == -1)
-                return 0;
-        } while (len);
-    } else {
-        /* consume whatever's left in the input buffer */
-        if (strm->avail_in && gz_comp(state, Z_NO_FLUSH) == -1)
-            return 0;
-
-        /* directly compress user buffer to file */
-        strm->avail_in = len;
-        strm->next_in = (const unsigned char *)buf;
-        state->x.pos += len;
-        if (gz_comp(state, Z_NO_FLUSH) == -1)
-            return 0;
-    }
-
-    /* input was all buffered or compressed (put will fit in int) */
-    return (int)put;
-}
-
-/* -- see zlib.h -- */
-int ZEXPORT gzputc(gzFile file, int c) {
-    unsigned have;
-    unsigned char buf[1];
-    gz_statep state;
-    z_stream *strm;
-
-    /* get internal structure */
-    if (file == NULL)
-        return -1;
-    state = (gz_statep)file;
-    strm = &(state->strm);
-
-    /* check that we're writing and that there's no error */
-    if (state->mode != GZ_WRITE || state->err != Z_OK)
-        return -1;
-
-    /* check for seek request */
-    if (state->seek) {
-        state->seek = 0;
-        if (gz_zero(state, state->skip) == -1)
-            return -1;
-    }
-
-    /* try writing to input buffer for speed (state->size == 0 if buffer not
-       initialized) */
-    if (state->size) {
-        if (strm->avail_in == 0)
-            strm->next_in = state->in;
-        have = (unsigned)((strm->next_in + strm->avail_in) - state->in);
-        if (have < state->size) {
-            state->in[have] = c;
-            strm->avail_in++;
-            state->x.pos++;
-            return c & 0xff;
-        }
-    }
-
-    /* no room in buffer or not initialized, use gz_write() */
-    buf[0] = c;
-    if (gzwrite(file, buf, 1) != 1)
-        return -1;
-    return c & 0xff;
-}
-
-/* -- see zlib.h -- */
-int ZEXPORT gzputs(gzFile file, const char *str) {
-    int ret;
-    unsigned len;
-
-    /* write string */
-    len = (unsigned)strlen(str);
-    ret = gzwrite(file, str, len);
-    return ret == 0 && len != 0 ? -1 : ret;
-}
-
-/* -- see zlib.h -- */
-int ZEXPORTVA gzvprintf(gzFile file, const char *format, va_list va) {
-    int len, left;
-    char *next;
-    gz_statep state;
-    z_stream *strm;
-
-    /* get internal structure */
-    if (file == NULL)
-        return -1;
-    state = (gz_statep)file;
-    strm = &(state->strm);
-
-    /* check that we're writing and that there's no error */
-    if (state->mode != GZ_WRITE || state->err != Z_OK)
-        return 0;
-
-    /* make sure we have some buffer space */
-    if (state->size == 0 && gz_init(state) == -1)
-        return 0;
-
-    /* check for seek request */
-    if (state->seek) {
-        state->seek = 0;
-        if (gz_zero(state, state->skip) == -1)
-            return 0;
-    }
-
-    /* do the printf() into the input buffer, put length in len -- the input
-       buffer is double-sized just for this function, so there is guaranteed to
-       be state->size bytes available after the current contents */
-    if (strm->avail_in == 0)
-        strm->next_in = state->in;
-    next = (char *)(strm->next_in + strm->avail_in);
-    next[state->size - 1] = 0;
-    len = vsnprintf(next, state->size, format, va);
-
-    /* check that printf() results fit in buffer */
-    if (len == 0 || len >= state->size || next[state->size - 1] != 0)
-        return 0;
-
-    /* update buffer and position, compress first half if past that */
-    strm->avail_in += len;
-    state->x.pos += len;
-    if (strm->avail_in >= state->size) {
-        left = strm->avail_in - state->size;
-        strm->avail_in = state->size;
-        if (gz_comp(state, Z_NO_FLUSH) == -1)
-            return 0;
-        memcpy(state->in, state->in + state->size, left);
-        strm->next_in = state->in;
-        strm->avail_in = left;
-    }
-    return (int)len;
-}
-
-int ZEXPORTVA gzprintf(gzFile file, const char *format, ...) {
-    va_list va;
-    int ret;
-
-    va_start(va, format);
-    ret = gzvprintf(file, format, va);
-    va_end(va);
-    return ret;
-}
-
-/* -- see zlib.h -- */
-int ZEXPORT gzflush(gzFile file, int flush) {
-    gz_statep state;
-
-    /* get internal structure */
-    if (file == NULL)
-        return -1;
-    state = (gz_statep)file;
-
-    /* check that we're writing and that there's no error */
-    if (state->mode != GZ_WRITE || state->err != Z_OK)
-        return Z_STREAM_ERROR;
-
-    /* check flush parameter */
-    if (flush < 0 || flush > Z_FINISH)
-        return Z_STREAM_ERROR;
-
-    /* check for seek request */
-    if (state->seek) {
-        state->seek = 0;
-        if (gz_zero(state, state->skip) == -1)
-            return -1;
-    }
-
-    /* compress remaining data with requested flush */
-    gz_comp(state, flush);
-    return state->err;
-}
-
-/* -- see zlib.h -- */
-int ZEXPORT gzsetparams(gzFile file, int level, int strategy) {
-    gz_statep state;
-    z_stream *strm;
-
-    /* get internal structure */
-    if (file == NULL)
-        return Z_STREAM_ERROR;
-    state = (gz_statep)file;
-    strm = &(state->strm);
-
-    /* check that we're writing and that there's no error */
-    if (state->mode != GZ_WRITE || state->err != Z_OK)
-        return Z_STREAM_ERROR;
-
-    /* if no change is requested, then do nothing */
-    if (level == state->level && strategy == state->strategy)
-        return Z_OK;
-
-    /* check for seek request */
-    if (state->seek) {
-        state->seek = 0;
-        if (gz_zero(state, state->skip) == -1)
-            return -1;
-    }
-
-    /* change compression parameters for subsequent input */
-    if (state->size) {
-        /* flush previous input with previous parameters before changing */
-        if (strm->avail_in && gz_comp(state, Z_PARTIAL_FLUSH) == -1)
-            return state->err;
-        deflateParams(strm, level, strategy);
-    }
-    state->level = level;
-    state->strategy = strategy;
-    return Z_OK;
-}
-
-/* -- see zlib.h -- */
-int ZEXPORT gzclose_w(gzFile file) {
-    int ret = Z_OK;
-    gz_statep state;
-
-    /* get internal structure */
-    if (file == NULL)
-        return Z_STREAM_ERROR;
-    state = (gz_statep)file;
-
-    /* check that we're writing */
-    if (state->mode != GZ_WRITE)
-        return Z_STREAM_ERROR;
-
-    /* check for seek request */
-    if (state->seek) {
-        state->seek = 0;
-        if (gz_zero(state, state->skip) == -1)
-            ret = state->err;
-    }
-
-    /* flush, free memory, and close file */
-    if (gz_comp(state, Z_FINISH) == -1)
-        ret = state->err;
-    if (state->size) {
-        if (!state->direct) {
-            (void)deflateEnd(&(state->strm));
-            free(state->out);
-        }
-        free(state->in);
-    }
-    gz_error(state, Z_OK, NULL);
-    free(state->path);
-    if (close(state->fd) == -1)
-        ret = Z_ERRNO;
-    free(state);
-    return ret;
-}
diff --git a/contrib/libzlib-ng/infback.c b/contrib/libzlib-ng/infback.c
deleted file mode 100644
index 9f3dc4645e8..00000000000
--- a/contrib/libzlib-ng/infback.c
+++ /dev/null
@@ -1,612 +0,0 @@
-/* infback.c -- inflate using a call-back interface
- * Copyright (C) 1995-2011 Mark Adler
- * For conditions of distribution and use, see copyright notice in zlib.h
- */
-
-/*
-   This code is largely copied from inflate.c.  Normally either infback.o or
-   inflate.o would be linked into an application--not both.  The interface
-   with inffast.c is retained so that optimized assembler-coded versions of
-   inflate_fast() can be used with either inflate.c or infback.c.
- */
-
-#include "zutil.h"
-#include "inftrees.h"
-#include "inflate.h"
-#include "inffast.h"
-
-/* function prototypes */
-local void fixedtables(struct inflate_state *state);
-
-/*
-   strm provides memory allocation functions in zalloc and zfree, or
-   Z_NULL to use the library memory allocation functions.
-
-   windowBits is in the range 8..15, and window is a user-supplied
-   window and output buffer that is 2**windowBits bytes.
- */
-int ZEXPORT inflateBackInit_(z_stream *strm, int windowBits, unsigned char *window,
-                              const char *version, int stream_size) {
-    struct inflate_state *state;
-
-    if (version == Z_NULL || version[0] != ZLIB_VERSION[0] || stream_size != (int)(sizeof(z_stream)))
-        return Z_VERSION_ERROR;
-    if (strm == Z_NULL || window == Z_NULL || windowBits < 8 || windowBits > 15)
-        return Z_STREAM_ERROR;
-    strm->msg = Z_NULL;                 /* in case we return an error */
-    if (strm->zalloc == (alloc_func)0) {
-        strm->zalloc = zcalloc;
-        strm->opaque = NULL;
-    }
-    if (strm->zfree == (free_func)0)
-        strm->zfree = zcfree;
-    state = (struct inflate_state *)ZALLOC(strm, 1, sizeof(struct inflate_state));
-    if (state == Z_NULL)
-        return Z_MEM_ERROR;
-    Tracev((stderr, "inflate: allocated\n"));
-    strm->state = (struct internal_state *)state;
-    state->dmax = 32768U;
-    state->wbits = windowBits;
-    state->wsize = 1U << windowBits;
-    state->window = window;
-    state->wnext = 0;
-    state->whave = 0;
-    return Z_OK;
-}
-
-/*
-   Return state with length and distance decoding tables and index sizes set to
-   fixed code decoding.  Normally this returns fixed tables from inffixed.h.
-   If BUILDFIXED is defined, then instead this routine builds the tables the
-   first time it's called, and returns those tables the first time and
-   thereafter.  This reduces the size of the code by about 2K bytes, in
-   exchange for a little execution time.  However, BUILDFIXED should not be
-   used for threaded applications, since the rewriting of the tables and virgin
-   may not be thread-safe.
- */
-local void fixedtables(struct inflate_state *state) {
-#ifdef BUILDFIXED
-    static int virgin = 1;
-    static code *lenfix, *distfix;
-    static code fixed[544];
-
-    /* build fixed huffman tables if first call (may not be thread safe) */
-    if (virgin) {
-        unsigned sym, bits;
-        static code *next;
-
-        /* literal/length table */
-        sym = 0;
-        while (sym < 144) state->lens[sym++] = 8;
-        while (sym < 256) state->lens[sym++] = 9;
-        while (sym < 280) state->lens[sym++] = 7;
-        while (sym < 288) state->lens[sym++] = 8;
-        next = fixed;
-        lenfix = next;
-        bits = 9;
-        inflate_table(LENS, state->lens, 288, &(next), &(bits), state->work);
-
-        /* distance table */
-        sym = 0;
-        while (sym < 32) state->lens[sym++] = 5;
-        distfix = next;
-        bits = 5;
-        inflate_table(DISTS, state->lens, 32, &(next), &(bits), state->work);
-
-        /* do this just once */
-        virgin = 0;
-    }
-#else /* !BUILDFIXED */
-#   include "inffixed.h"
-#endif /* BUILDFIXED */
-    state->lencode = lenfix;
-    state->lenbits = 9;
-    state->distcode = distfix;
-    state->distbits = 5;
-}
-
-/* Macros for inflateBack(): */
-
-/* Load returned state from inflate_fast() */
-#define LOAD() \
-    do { \
-        put = strm->next_out; \
-        left = strm->avail_out; \
-        next = strm->next_in; \
-        have = strm->avail_in; \
-        hold = state->hold; \
-        bits = state->bits; \
-    } while (0)
-
-/* Set state from registers for inflate_fast() */
-#define RESTORE() \
-    do { \
-        strm->next_out = put; \
-        strm->avail_out = left; \
-        strm->next_in = next; \
-        strm->avail_in = have; \
-        state->hold = hold; \
-        state->bits = bits; \
-    } while (0)
-
-/* Clear the input bit accumulator */
-#define INITBITS() \
-    do { \
-        hold = 0; \
-        bits = 0; \
-    } while (0)
-
-/* Assure that some input is available.  If input is requested, but denied,
-   then return a Z_BUF_ERROR from inflateBack(). */
-#define PULL() \
-    do { \
-        if (have == 0) { \
-            have = in(in_desc, &next); \
-            if (have == 0) { \
-                next = Z_NULL; \
-                ret = Z_BUF_ERROR; \
-                goto inf_leave; \
-            } \
-        } \
-    } while (0)
-
-/* Get a byte of input into the bit accumulator, or return from inflateBack()
-   with an error if there is no input available. */
-#define PULLBYTE() \
-    do { \
-        PULL(); \
-        have--; \
-        hold += (*next++ << bits); \
-        bits += 8; \
-    } while (0)
-
-/* Assure that there are at least n bits in the bit accumulator.  If there is
-   not enough available input to do that, then return from inflateBack() with
-   an error. */
-#define NEEDBITS(n) \
-    do { \
-        while (bits < (unsigned)(n)) \
-            PULLBYTE(); \
-    } while (0)
-
-/* Return the low n bits of the bit accumulator (n < 16) */
-#define BITS(n) \
-    (hold & ((1U << (n)) - 1))
-
-/* Remove n bits from the bit accumulator */
-#define DROPBITS(n) \
-    do { \
-        hold >>= (n); \
-        bits -= (unsigned)(n); \
-    } while (0)
-
-/* Remove zero to seven bits as needed to go to a byte boundary */
-#define BYTEBITS() \
-    do { \
-        hold >>= bits & 7; \
-        bits -= bits & 7; \
-    } while (0)
-
-/* Assure that some output space is available, by writing out the window
-   if it's full.  If the write fails, return from inflateBack() with a
-   Z_BUF_ERROR. */
-#define ROOM() \
-    do { \
-        if (left == 0) { \
-            put = state->window; \
-            left = state->wsize; \
-            state->whave = left; \
-            if (out(out_desc, put, left)) { \
-                ret = Z_BUF_ERROR; \
-                goto inf_leave; \
-            } \
-        } \
-    } while (0)
-
-/*
-   strm provides the memory allocation functions and window buffer on input,
-   and provides information on the unused input on return.  For Z_DATA_ERROR
-   returns, strm will also provide an error message.
-
-   in() and out() are the call-back input and output functions.  When
-   inflateBack() needs more input, it calls in().  When inflateBack() has
-   filled the window with output, or when it completes with data in the
-   window, it calls out() to write out the data.  The application must not
-   change the provided input until in() is called again or inflateBack()
-   returns.  The application must not change the window/output buffer until
-   inflateBack() returns.
-
-   in() and out() are called with a descriptor parameter provided in the
-   inflateBack() call.  This parameter can be a structure that provides the
-   information required to do the read or write, as well as accumulated
-   information on the input and output such as totals and check values.
-
-   in() should return zero on failure.  out() should return non-zero on
-   failure.  If either in() or out() fails, than inflateBack() returns a
-   Z_BUF_ERROR.  strm->next_in can be checked for Z_NULL to see whether it
-   was in() or out() that caused in the error.  Otherwise,  inflateBack()
-   returns Z_STREAM_END on success, Z_DATA_ERROR for an deflate format
-   error, or Z_MEM_ERROR if it could not allocate memory for the state.
-   inflateBack() can also return Z_STREAM_ERROR if the input parameters
-   are not correct, i.e. strm is Z_NULL or the state was not initialized.
- */
-int ZEXPORT inflateBack(z_stream *strm, in_func in, void *in_desc, out_func out, void *out_desc) {
-    struct inflate_state *state;
-    const unsigned char *next;  /* next input */
-    unsigned char *put;         /* next output */
-    unsigned have, left;        /* available input and output */
-    uint32_t hold;              /* bit buffer */
-    unsigned bits;              /* bits in bit buffer */
-    unsigned copy;              /* number of stored or match bytes to copy */
-    unsigned char *from;        /* where to copy match bytes from */
-    code here;                  /* current decoding table entry */
-    code last;                  /* parent table entry */
-    unsigned len;               /* length to copy for repeats, bits to drop */
-    int ret;                    /* return code */
-    static const uint16_t order[19] = /* permutation of code lengths */
-        {16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15};
-
-    /* Check that the strm exists and that the state was initialized */
-    if (strm == Z_NULL || strm->state == Z_NULL)
-        return Z_STREAM_ERROR;
-    state = (struct inflate_state *)strm->state;
-
-    /* Reset the state */
-    strm->msg = Z_NULL;
-    state->mode = TYPE;
-    state->last = 0;
-    state->whave = 0;
-    next = strm->next_in;
-    have = next != Z_NULL ? strm->avail_in : 0;
-    hold = 0;
-    bits = 0;
-    put = state->window;
-    left = state->wsize;
-
-    /* Inflate until end of block marked as last */
-    for (;;)
-        switch (state->mode) {
-        case TYPE:
-            /* determine and dispatch block type */
-            if (state->last) {
-                BYTEBITS();
-                state->mode = DONE;
-                break;
-            }
-            NEEDBITS(3);
-            state->last = BITS(1);
-            DROPBITS(1);
-            switch (BITS(2)) {
-            case 0:                             /* stored block */
-                Tracev((stderr, "inflate:     stored block%s\n", state->last ? " (last)" : ""));
-                state->mode = STORED;
-                break;
-            case 1:                             /* fixed block */
-                fixedtables(state);
-                Tracev((stderr, "inflate:     fixed codes block%s\n", state->last ? " (last)" : ""));
-                state->mode = LEN;              /* decode codes */
-                break;
-            case 2:                             /* dynamic block */
-                Tracev((stderr, "inflate:     dynamic codes block%s\n", state->last ? " (last)" : ""));
-                state->mode = TABLE;
-                break;
-            case 3:
-                strm->msg = (char *)"invalid block type";
-                state->mode = BAD;
-            }
-            DROPBITS(2);
-            break;
-
-        case STORED:
-            /* get and verify stored block length */
-            BYTEBITS();                         /* go to byte boundary */
-            NEEDBITS(32);
-            if ((hold & 0xffff) != ((hold >> 16) ^ 0xffff)) {
-                strm->msg = (char *)"invalid stored block lengths";
-                state->mode = BAD;
-                break;
-            }
-            state->length = (uint16_t)hold;
-            Tracev((stderr, "inflate:       stored length %u\n", state->length));
-            INITBITS();
-
-            /* copy stored block from input to output */
-            while (state->length != 0) {
-                copy = state->length;
-                PULL();
-                ROOM();
-                if (copy > have)
-                    copy = have;
-                if (copy > left)
-                    copy = left;
-                memcpy(put, next, copy);
-                have -= copy;
-                next += copy;
-                left -= copy;
-                put += copy;
-                state->length -= copy;
-            }
-            Tracev((stderr, "inflate:       stored end\n"));
-            state->mode = TYPE;
-            break;
-
-        case TABLE:
-            /* get dynamic table entries descriptor */
-            NEEDBITS(14);
-            state->nlen = BITS(5) + 257;
-            DROPBITS(5);
-            state->ndist = BITS(5) + 1;
-            DROPBITS(5);
-            state->ncode = BITS(4) + 4;
-            DROPBITS(4);
-#ifndef PKZIP_BUG_WORKAROUND
-            if (state->nlen > 286 || state->ndist > 30) {
-                strm->msg = (char *)"too many length or distance symbols";
-                state->mode = BAD;
-                break;
-            }
-#endif
-            Tracev((stderr, "inflate:       table sizes ok\n"));
-
-            /* get code length code lengths (not a typo) */
-            state->have = 0;
-            while (state->have < state->ncode) {
-                NEEDBITS(3);
-                state->lens[order[state->have++]] = (uint16_t)BITS(3);
-                DROPBITS(3);
-            }
-            while (state->have < 19)
-                state->lens[order[state->have++]] = 0;
-            state->next = state->codes;
-            state->lencode = (code const *)(state->next);
-            state->lenbits = 7;
-            ret = inflate_table(CODES, state->lens, 19, &(state->next), &(state->lenbits), state->work);
-            if (ret) {
-                strm->msg = (char *)"invalid code lengths set";
-                state->mode = BAD;
-                break;
-            }
-            Tracev((stderr, "inflate:       code lengths ok\n"));
-
-            /* get length and distance code code lengths */
-            state->have = 0;
-            while (state->have < state->nlen + state->ndist) {
-                for (;;) {
-                    here = state->lencode[BITS(state->lenbits)];
-                    if (here.bits <= bits)
-                        break;
-                    PULLBYTE();
-                }
-                if (here.val < 16) {
-                    DROPBITS(here.bits);
-                    state->lens[state->have++] = here.val;
-                } else {
-                    if (here.val == 16) {
-                        NEEDBITS(here.bits + 2);
-                        DROPBITS(here.bits);
-                        if (state->have == 0) {
-                            strm->msg = (char *)"invalid bit length repeat";
-                            state->mode = BAD;
-                            break;
-                        }
-                        len = (unsigned)(state->lens[state->have - 1]);
-                        copy = 3 + BITS(2);
-                        DROPBITS(2);
-                    } else if (here.val == 17) {
-                        NEEDBITS(here.bits + 3);
-                        DROPBITS(here.bits);
-                        len = 0;
-                        copy = 3 + BITS(3);
-                        DROPBITS(3);
-                    } else {
-                        NEEDBITS(here.bits + 7);
-                        DROPBITS(here.bits);
-                        len = 0;
-                        copy = 11 + BITS(7);
-                        DROPBITS(7);
-                    }
-                    if (state->have + copy > state->nlen + state->ndist) {
-                        strm->msg = (char *)"invalid bit length repeat";
-                        state->mode = BAD;
-                        break;
-                    }
-                    while (copy--)
-                        state->lens[state->have++] = (uint16_t)len;
-                }
-            }
-
-            /* handle error breaks in while */
-            if (state->mode == BAD)
-                break;
-
-            /* check for end-of-block code (better have one) */
-            if (state->lens[256] == 0) {
-                strm->msg = (char *)"invalid code -- missing end-of-block";
-                state->mode = BAD;
-                break;
-            }
-
-            /* build code tables -- note: do not change the lenbits or distbits
-               values here (9 and 6) without reading the comments in inftrees.h
-               concerning the ENOUGH constants, which depend on those values */
-            state->next = state->codes;
-            state->lencode = (code const *)(state->next);
-            state->lenbits = 9;
-            ret = inflate_table(LENS, state->lens, state->nlen, &(state->next), &(state->lenbits), state->work);
-            if (ret) {
-                strm->msg = (char *)"invalid literal/lengths set";
-                state->mode = BAD;
-                break;
-            }
-            state->distcode = (code const *)(state->next);
-            state->distbits = 6;
-            ret = inflate_table(DISTS, state->lens + state->nlen, state->ndist,
-                                &(state->next), &(state->distbits), state->work);
-            if (ret) {
-                strm->msg = (char *)"invalid distances set";
-                state->mode = BAD;
-                break;
-            }
-            Tracev((stderr, "inflate:       codes ok\n"));
-            state->mode = LEN;
-
-        case LEN:
-            /* use inflate_fast() if we have enough input and output */
-            if (have >= 6 && left >= 258) {
-                RESTORE();
-                if (state->whave < state->wsize)
-                    state->whave = state->wsize - left;
-                inflate_fast(strm, state->wsize);
-                LOAD();
-                break;
-            }
-
-            /* get a literal, length, or end-of-block code */
-            for (;;) {
-                here = state->lencode[BITS(state->lenbits)];
-                if (here.bits <= bits)
-                    break;
-                PULLBYTE();
-            }
-            if (here.op && (here.op & 0xf0) == 0) {
-                last = here;
-                for (;;) {
-                    here = state->lencode[last.val +
-                            (BITS(last.bits + last.op) >> last.bits)];
-                    if ((unsigned)last.bits + (unsigned)here.bits <= bits)
-                        break;
-                    PULLBYTE();
-                }
-                DROPBITS(last.bits);
-            }
-            DROPBITS(here.bits);
-            state->length = here.val;
-
-            /* process literal */
-            if (here.op == 0) {
-                Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ?
-                        "inflate:         literal '%c'\n" :
-                        "inflate:         literal 0x%02x\n", here.val));
-                ROOM();
-                *put++ = (unsigned char)(state->length);
-                left--;
-                state->mode = LEN;
-                break;
-            }
-
-            /* process end of block */
-            if (here.op & 32) {
-                Tracevv((stderr, "inflate:         end of block\n"));
-                state->mode = TYPE;
-                break;
-            }
-
-            /* invalid code */
-            if (here.op & 64) {
-                strm->msg = (char *)"invalid literal/length code";
-                state->mode = BAD;
-                break;
-            }
-
-            /* length code -- get extra bits, if any */
-            state->extra = (here.op & 15);
-            if (state->extra != 0) {
-                NEEDBITS(state->extra);
-                state->length += BITS(state->extra);
-                DROPBITS(state->extra);
-            }
-            Tracevv((stderr, "inflate:         length %u\n", state->length));
-
-            /* get distance code */
-            for (;;) {
-                here = state->distcode[BITS(state->distbits)];
-                if (here.bits <= bits)
-                    break;
-                PULLBYTE();
-            }
-            if ((here.op & 0xf0) == 0) {
-                last = here;
-                for (;;) {
-                    here = state->distcode[last.val + (BITS(last.bits + last.op) >> last.bits)];
-                    if ((unsigned)last.bits + (unsigned)here.bits <= bits)
-                        break;
-                    PULLBYTE();
-                }
-                DROPBITS(last.bits);
-            }
-            DROPBITS(here.bits);
-            if (here.op & 64) {
-                strm->msg = (char *)"invalid distance code";
-                state->mode = BAD;
-                break;
-            }
-            state->offset = here.val;
-
-            /* get distance extra bits, if any */
-            state->extra = (here.op & 15);
-            if (state->extra != 0) {
-                NEEDBITS(state->extra);
-                state->offset += BITS(state->extra);
-                DROPBITS(state->extra);
-            }
-            if (state->offset > state->wsize - (state->whave < state->wsize ? left : 0)) {
-                strm->msg = (char *)"invalid distance too far back";
-                state->mode = BAD;
-                break;
-            }
-            Tracevv((stderr, "inflate:         distance %u\n", state->offset));
-
-            /* copy match from window to output */
-            do {
-                ROOM();
-                copy = state->wsize - state->offset;
-                if (copy < left) {
-                    from = put + copy;
-                    copy = left - copy;
-                } else {
-                    from = put - state->offset;
-                    copy = left;
-                }
-                if (copy > state->length)
-                    copy = state->length;
-                state->length -= copy;
-                left -= copy;
-                do {
-                    *put++ = *from++;
-                } while (--copy);
-            } while (state->length != 0);
-            break;
-
-        case DONE:
-            /* inflate stream terminated properly -- write leftover output */
-            ret = Z_STREAM_END;
-            if (left < state->wsize) {
-                if (out(out_desc, state->window, state->wsize - left))
-                    ret = Z_BUF_ERROR;
-            }
-            goto inf_leave;
-
-        case BAD:
-            ret = Z_DATA_ERROR;
-            goto inf_leave;
-
-        default:                /* can't happen, but makes compilers happy */
-            ret = Z_STREAM_ERROR;
-            goto inf_leave;
-        }
-
-    /* Return unused input */
-  inf_leave:
-    strm->next_in = next;
-    strm->avail_in = have;
-    return ret;
-}
-
-int ZEXPORT inflateBackEnd(z_stream *strm) {
-    if (strm == Z_NULL || strm->state == Z_NULL || strm->zfree == (free_func)0)
-        return Z_STREAM_ERROR;
-    ZFREE(strm, strm->state);
-    strm->state = Z_NULL;
-    Tracev((stderr, "inflate: end\n"));
-    return Z_OK;
-}
diff --git a/contrib/libzlib-ng/inffast.c b/contrib/libzlib-ng/inffast.c
deleted file mode 100644
index 8acb261d008..00000000000
--- a/contrib/libzlib-ng/inffast.c
+++ /dev/null
@@ -1,328 +0,0 @@
-/* inffast.c -- fast decoding
- * Copyright (C) 1995-2008, 2010, 2013 Mark Adler
- * For conditions of distribution and use, see copyright notice in zlib.h
- */
-
-#include "zutil.h"
-#include "inftrees.h"
-#include "inflate.h"
-#include "inffast.h"
-
-/* Allow machine dependent optimization for post-increment or pre-increment.
-   Based on testing to date,
-   Pre-increment preferred for:
-   - PowerPC G3 (Adler)
-   - MIPS R5000 (Randers-Pehrson)
-   Post-increment preferred for:
-   - none
-   No measurable difference:
-   - Pentium III (Anderson)
-   - M68060 (Nikl)
- */
-#ifdef POSTINC
-#  define OFF 0
-#  define PUP(a) *(a)++
-#else
-#  define OFF 1
-#  define PUP(a) *++(a)
-#endif
-
-/* Return the low n bits of the bit accumulator (n < 16) */
-#define BITS(n) \
-    (hold & ((1U << (n)) - 1))
-
-/* Remove n bits from the bit accumulator */
-#define DROPBITS(n) \
-    do { \
-        hold >>= (n); \
-        bits -= (unsigned)(n); \
-    } while (0)
-
-/*
-   Decode literal, length, and distance codes and write out the resulting
-   literal and match bytes until either not enough input or output is
-   available, an end-of-block is encountered, or a data error is encountered.
-   When large enough input and output buffers are supplied to inflate(), for
-   example, a 16K input buffer and a 64K output buffer, more than 95% of the
-   inflate execution time is spent in this routine.
-
-   Entry assumptions:
-
-        state->mode == LEN
-        strm->avail_in >= 6
-        strm->avail_out >= 258
-        start >= strm->avail_out
-        state->bits < 8
-
-   On return, state->mode is one of:
-
-        LEN -- ran out of enough output space or enough available input
-        TYPE -- reached end of block code, inflate() to interpret next block
-        BAD -- error in block data
-
-   Notes:
-
-    - The maximum input bits used by a length/distance pair is 15 bits for the
-      length code, 5 bits for the length extra, 15 bits for the distance code,
-      and 13 bits for the distance extra.  This totals 48 bits, or six bytes.
-      Therefore if strm->avail_in >= 6, then there is enough input to avoid
-      checking for available input while decoding.
-
-    - The maximum bytes that a single length/distance pair can output is 258
-      bytes, which is the maximum length that can be coded.  inflate_fast()
-      requires strm->avail_out >= 258 for each loop to avoid checking for
-      output space.
- */
-void ZLIB_INTERNAL inflate_fast(z_stream *strm, unsigned long start) {
-    /* start: inflate()'s starting value for strm->avail_out */
-    struct inflate_state *state;
-    const unsigned char *in;    /* local strm->next_in */
-    const unsigned char *last;  /* have enough input while in < last */
-    unsigned char *out;         /* local strm->next_out */
-    unsigned char *beg;         /* inflate()'s initial strm->next_out */
-    unsigned char *end;         /* while out < end, enough space available */
-#ifdef INFLATE_STRICT
-    unsigned dmax;              /* maximum distance from zlib header */
-#endif
-    unsigned wsize;             /* window size or zero if not using window */
-    unsigned whave;             /* valid bytes in the window */
-    unsigned wnext;             /* window write index */
-    unsigned char *window;      /* allocated sliding window, if wsize != 0 */
-    uint32_t hold;              /* local strm->hold */
-    unsigned bits;              /* local strm->bits */
-    code const *lcode;          /* local strm->lencode */
-    code const *dcode;          /* local strm->distcode */
-    unsigned lmask;             /* mask for first level of length codes */
-    unsigned dmask;             /* mask for first level of distance codes */
-    code here;                  /* retrieved table entry */
-    unsigned op;                /* code bits, operation, extra bits, or */
-                                /*  window position, window bytes to copy */
-    unsigned len;               /* match length, unused bytes */
-    unsigned dist;              /* match distance */
-    unsigned char *from;        /* where to copy match from */
-
-    /* copy state to local variables */
-    state = (struct inflate_state *)strm->state;
-    in = strm->next_in - OFF;
-    last = in + (strm->avail_in - 5);
-    out = strm->next_out - OFF;
-    beg = out - (start - strm->avail_out);
-    end = out + (strm->avail_out - 257);
-#ifdef INFLATE_STRICT
-    dmax = state->dmax;
-#endif
-    wsize = state->wsize;
-    whave = state->whave;
-    wnext = state->wnext;
-    window = state->window;
-    hold = state->hold;
-    bits = state->bits;
-    lcode = state->lencode;
-    dcode = state->distcode;
-    lmask = (1U << state->lenbits) - 1;
-    dmask = (1U << state->distbits) - 1;
-
-    /* decode literals and length/distances until end-of-block or not enough
-       input data or output space */
-    do {
-        if (bits < 15) {
-            hold += (PUP(in) << bits);
-            bits += 8;
-            hold += (PUP(in) << bits);
-            bits += 8;
-        }
-        here = lcode[hold & lmask];
-      dolen:
-        DROPBITS(here.bits);
-        op = here.op;
-        if (op == 0) {                          /* literal */
-            Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ?
-                    "inflate:         literal '%c'\n" :
-                    "inflate:         literal 0x%02x\n", here.val));
-            PUP(out) = (unsigned char)(here.val);
-        } else if (op & 16) {                     /* length base */
-            len = here.val;
-            op &= 15;                           /* number of extra bits */
-            if (op) {
-                if (bits < op) {
-                    hold += (PUP(in) << bits);
-                    bits += 8;
-                }
-                len += BITS(op);
-                DROPBITS(op);
-            }
-            Tracevv((stderr, "inflate:         length %u\n", len));
-            if (bits < 15) {
-                hold += (PUP(in) << bits);
-                bits += 8;
-                hold += (PUP(in) << bits);
-                bits += 8;
-            }
-            here = dcode[hold & dmask];
-          dodist:
-            DROPBITS(here.bits);
-            op = here.op;
-            if (op & 16) {                      /* distance base */
-                dist = here.val;
-                op &= 15;                       /* number of extra bits */
-                if (bits < op) {
-                    hold += (PUP(in) << bits);
-                    bits += 8;
-                    if (bits < op) {
-                        hold += (PUP(in) << bits);
-                        bits += 8;
-                    }
-                }
-                dist += BITS(op);
-#ifdef INFLATE_STRICT
-                if (dist > dmax) {
-                    strm->msg = (char *)"invalid distance too far back";
-                    state->mode = BAD;
-                    break;
-                }
-#endif
-                DROPBITS(op);
-                Tracevv((stderr, "inflate:         distance %u\n", dist));
-                op = (unsigned)(out - beg);     /* max distance in output */
-                if (dist > op) {                /* see if copy from window */
-                    op = dist - op;             /* distance back in window */
-                    if (op > whave) {
-                        if (state->sane) {
-                            strm->msg = (char *)"invalid distance too far back";
-                            state->mode = BAD;
-                            break;
-                        }
-#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR
-                        if (len <= op - whave) {
-                            do {
-                                PUP(out) = 0;
-                            } while (--len);
-                            continue;
-                        }
-                        len -= op - whave;
-                        do {
-                            PUP(out) = 0;
-                        } while (--op > whave);
-                        if (op == 0) {
-                            from = out - dist;
-                            do {
-                                PUP(out) = PUP(from);
-                            } while (--len);
-                            continue;
-                        }
-#endif
-                    }
-                    from = window - OFF;
-                    if (wnext == 0) {           /* very common case */
-                        from += wsize - op;
-                        if (op < len) {         /* some from window */
-                            len -= op;
-                            do {
-                                PUP(out) = PUP(from);
-                            } while (--op);
-                            from = out - dist;  /* rest from output */
-                        }
-                    } else if (wnext < op) {      /* wrap around window */
-                        from += wsize + wnext - op;
-                        op -= wnext;
-                        if (op < len) {         /* some from end of window */
-                            len -= op;
-                            do {
-                                PUP(out) = PUP(from);
-                            } while (--op);
-                            from = window - OFF;
-                            if (wnext < len) {  /* some from start of window */
-                                op = wnext;
-                                len -= op;
-                                do {
-                                    PUP(out) = PUP(from);
-                                } while (--op);
-                                from = out - dist;      /* rest from output */
-                            }
-                        }
-                    } else {                      /* contiguous in window */
-                        from += wnext - op;
-                        if (op < len) {         /* some from window */
-                            len -= op;
-                            do {
-                                PUP(out) = PUP(from);
-                            } while (--op);
-                            from = out - dist;  /* rest from output */
-                        }
-                    }
-                    while (len > 2) {
-                        PUP(out) = PUP(from);
-                        PUP(out) = PUP(from);
-                        PUP(out) = PUP(from);
-                        len -= 3;
-                    }
-                    if (len) {
-                        PUP(out) = PUP(from);
-                        if (len > 1)
-                            PUP(out) = PUP(from);
-                    }
-                } else {
-                    from = out - dist;          /* copy direct from output */
-                    do {                        /* minimum length is three */
-                        PUP(out) = PUP(from);
-                        PUP(out) = PUP(from);
-                        PUP(out) = PUP(from);
-                        len -= 3;
-                    } while (len > 2);
-                    if (len) {
-                        PUP(out) = PUP(from);
-                        if (len > 1)
-                            PUP(out) = PUP(from);
-                    }
-                }
-            } else if ((op & 64) == 0) {          /* 2nd level distance code */
-                here = dcode[here.val + BITS(op)];
-                goto dodist;
-            } else {
-                strm->msg = (char *)"invalid distance code";
-                state->mode = BAD;
-                break;
-            }
-        } else if ((op & 64) == 0) {              /* 2nd level length code */
-            here = lcode[here.val + BITS(op)];
-            goto dolen;
-        } else if (op & 32) {                     /* end-of-block */
-            Tracevv((stderr, "inflate:         end of block\n"));
-            state->mode = TYPE;
-            break;
-        } else {
-            strm->msg = (char *)"invalid literal/length code";
-            state->mode = BAD;
-            break;
-        }
-    } while (in < last && out < end);
-
-    /* return unused bytes (on entry, bits < 8, so in won't go too far back) */
-    len = bits >> 3;
-    in -= len;
-    bits -= len << 3;
-    hold &= (1U << bits) - 1;
-
-    /* update state and return */
-    strm->next_in = in + OFF;
-    strm->next_out = out + OFF;
-    strm->avail_in = (unsigned)(in < last ? 5 + (last - in) : 5 - (in - last));
-    strm->avail_out = (unsigned)(out < end ? 257 + (end - out) : 257 - (out - end));
-    state->hold = hold;
-    state->bits = bits;
-    return;
-}
-
-/*
-   inflate_fast() speedups that turned out slower (on a PowerPC G3 750CXe):
-   - Using bit fields for code structure
-   - Different op definition to avoid & for extra bits (do & for table bits)
-   - Three separate decoding do-loops for direct, window, and wnext == 0
-   - Special case for distance > 1 copies to do overlapped load and store copy
-   - Explicit branch predictions (based on measured branch probabilities)
-   - Deferring match copy and interspersed it with decoding subsequent codes
-   - Swapping literal/length else
-   - Swapping window/direct else
-   - Larger unrolled copy loops (three is about right)
-   - Moving len -= 3 statement into middle of loop
- */
diff --git a/contrib/libzlib-ng/inffast.h b/contrib/libzlib-ng/inffast.h
deleted file mode 100644
index 0d75614772a..00000000000
--- a/contrib/libzlib-ng/inffast.h
+++ /dev/null
@@ -1,15 +0,0 @@
-#ifndef INFFAST_H_
-#define INFFAST_H_
-/* inffast.h -- header to use inffast.c
- * Copyright (C) 1995-2003, 2010 Mark Adler
- * For conditions of distribution and use, see copyright notice in zlib.h
- */
-
-/* WARNING: this file should *not* be used by applications. It is
-   part of the implementation of the compression library and is
-   subject to change. Applications should only use zlib.h.
- */
-
-void ZLIB_INTERNAL inflate_fast(z_stream *strm, unsigned long start);
-
-#endif /* INFFAST_H_ */
diff --git a/contrib/libzlib-ng/inffixed.h b/contrib/libzlib-ng/inffixed.h
deleted file mode 100644
index d6283277694..00000000000
--- a/contrib/libzlib-ng/inffixed.h
+++ /dev/null
@@ -1,94 +0,0 @@
-    /* inffixed.h -- table for decoding fixed codes
-     * Generated automatically by makefixed().
-     */
-
-    /* WARNING: this file should *not* be used by applications.
-       It is part of the implementation of this library and is
-       subject to change. Applications should only use zlib.h.
-     */
-
-    static const code lenfix[512] = {
-        {96,7,0},{0,8,80},{0,8,16},{20,8,115},{18,7,31},{0,8,112},{0,8,48},
-        {0,9,192},{16,7,10},{0,8,96},{0,8,32},{0,9,160},{0,8,0},{0,8,128},
-        {0,8,64},{0,9,224},{16,7,6},{0,8,88},{0,8,24},{0,9,144},{19,7,59},
-        {0,8,120},{0,8,56},{0,9,208},{17,7,17},{0,8,104},{0,8,40},{0,9,176},
-        {0,8,8},{0,8,136},{0,8,72},{0,9,240},{16,7,4},{0,8,84},{0,8,20},
-        {21,8,227},{19,7,43},{0,8,116},{0,8,52},{0,9,200},{17,7,13},{0,8,100},
-        {0,8,36},{0,9,168},{0,8,4},{0,8,132},{0,8,68},{0,9,232},{16,7,8},
-        {0,8,92},{0,8,28},{0,9,152},{20,7,83},{0,8,124},{0,8,60},{0,9,216},
-        {18,7,23},{0,8,108},{0,8,44},{0,9,184},{0,8,12},{0,8,140},{0,8,76},
-        {0,9,248},{16,7,3},{0,8,82},{0,8,18},{21,8,163},{19,7,35},{0,8,114},
-        {0,8,50},{0,9,196},{17,7,11},{0,8,98},{0,8,34},{0,9,164},{0,8,2},
-        {0,8,130},{0,8,66},{0,9,228},{16,7,7},{0,8,90},{0,8,26},{0,9,148},
-        {20,7,67},{0,8,122},{0,8,58},{0,9,212},{18,7,19},{0,8,106},{0,8,42},
-        {0,9,180},{0,8,10},{0,8,138},{0,8,74},{0,9,244},{16,7,5},{0,8,86},
-        {0,8,22},{64,8,0},{19,7,51},{0,8,118},{0,8,54},{0,9,204},{17,7,15},
-        {0,8,102},{0,8,38},{0,9,172},{0,8,6},{0,8,134},{0,8,70},{0,9,236},
-        {16,7,9},{0,8,94},{0,8,30},{0,9,156},{20,7,99},{0,8,126},{0,8,62},
-        {0,9,220},{18,7,27},{0,8,110},{0,8,46},{0,9,188},{0,8,14},{0,8,142},
-        {0,8,78},{0,9,252},{96,7,0},{0,8,81},{0,8,17},{21,8,131},{18,7,31},
-        {0,8,113},{0,8,49},{0,9,194},{16,7,10},{0,8,97},{0,8,33},{0,9,162},
-        {0,8,1},{0,8,129},{0,8,65},{0,9,226},{16,7,6},{0,8,89},{0,8,25},
-        {0,9,146},{19,7,59},{0,8,121},{0,8,57},{0,9,210},{17,7,17},{0,8,105},
-        {0,8,41},{0,9,178},{0,8,9},{0,8,137},{0,8,73},{0,9,242},{16,7,4},
-        {0,8,85},{0,8,21},{16,8,258},{19,7,43},{0,8,117},{0,8,53},{0,9,202},
-        {17,7,13},{0,8,101},{0,8,37},{0,9,170},{0,8,5},{0,8,133},{0,8,69},
-        {0,9,234},{16,7,8},{0,8,93},{0,8,29},{0,9,154},{20,7,83},{0,8,125},
-        {0,8,61},{0,9,218},{18,7,23},{0,8,109},{0,8,45},{0,9,186},{0,8,13},
-        {0,8,141},{0,8,77},{0,9,250},{16,7,3},{0,8,83},{0,8,19},{21,8,195},
-        {19,7,35},{0,8,115},{0,8,51},{0,9,198},{17,7,11},{0,8,99},{0,8,35},
-        {0,9,166},{0,8,3},{0,8,131},{0,8,67},{0,9,230},{16,7,7},{0,8,91},
-        {0,8,27},{0,9,150},{20,7,67},{0,8,123},{0,8,59},{0,9,214},{18,7,19},
-        {0,8,107},{0,8,43},{0,9,182},{0,8,11},{0,8,139},{0,8,75},{0,9,246},
-        {16,7,5},{0,8,87},{0,8,23},{64,8,0},{19,7,51},{0,8,119},{0,8,55},
-        {0,9,206},{17,7,15},{0,8,103},{0,8,39},{0,9,174},{0,8,7},{0,8,135},
-        {0,8,71},{0,9,238},{16,7,9},{0,8,95},{0,8,31},{0,9,158},{20,7,99},
-        {0,8,127},{0,8,63},{0,9,222},{18,7,27},{0,8,111},{0,8,47},{0,9,190},
-        {0,8,15},{0,8,143},{0,8,79},{0,9,254},{96,7,0},{0,8,80},{0,8,16},
-        {20,8,115},{18,7,31},{0,8,112},{0,8,48},{0,9,193},{16,7,10},{0,8,96},
-        {0,8,32},{0,9,161},{0,8,0},{0,8,128},{0,8,64},{0,9,225},{16,7,6},
-        {0,8,88},{0,8,24},{0,9,145},{19,7,59},{0,8,120},{0,8,56},{0,9,209},
-        {17,7,17},{0,8,104},{0,8,40},{0,9,177},{0,8,8},{0,8,136},{0,8,72},
-        {0,9,241},{16,7,4},{0,8,84},{0,8,20},{21,8,227},{19,7,43},{0,8,116},
-        {0,8,52},{0,9,201},{17,7,13},{0,8,100},{0,8,36},{0,9,169},{0,8,4},
-        {0,8,132},{0,8,68},{0,9,233},{16,7,8},{0,8,92},{0,8,28},{0,9,153},
-        {20,7,83},{0,8,124},{0,8,60},{0,9,217},{18,7,23},{0,8,108},{0,8,44},
-        {0,9,185},{0,8,12},{0,8,140},{0,8,76},{0,9,249},{16,7,3},{0,8,82},
-        {0,8,18},{21,8,163},{19,7,35},{0,8,114},{0,8,50},{0,9,197},{17,7,11},
-        {0,8,98},{0,8,34},{0,9,165},{0,8,2},{0,8,130},{0,8,66},{0,9,229},
-        {16,7,7},{0,8,90},{0,8,26},{0,9,149},{20,7,67},{0,8,122},{0,8,58},
-        {0,9,213},{18,7,19},{0,8,106},{0,8,42},{0,9,181},{0,8,10},{0,8,138},
-        {0,8,74},{0,9,245},{16,7,5},{0,8,86},{0,8,22},{64,8,0},{19,7,51},
-        {0,8,118},{0,8,54},{0,9,205},{17,7,15},{0,8,102},{0,8,38},{0,9,173},
-        {0,8,6},{0,8,134},{0,8,70},{0,9,237},{16,7,9},{0,8,94},{0,8,30},
-        {0,9,157},{20,7,99},{0,8,126},{0,8,62},{0,9,221},{18,7,27},{0,8,110},
-        {0,8,46},{0,9,189},{0,8,14},{0,8,142},{0,8,78},{0,9,253},{96,7,0},
-        {0,8,81},{0,8,17},{21,8,131},{18,7,31},{0,8,113},{0,8,49},{0,9,195},
-        {16,7,10},{0,8,97},{0,8,33},{0,9,163},{0,8,1},{0,8,129},{0,8,65},
-        {0,9,227},{16,7,6},{0,8,89},{0,8,25},{0,9,147},{19,7,59},{0,8,121},
-        {0,8,57},{0,9,211},{17,7,17},{0,8,105},{0,8,41},{0,9,179},{0,8,9},
-        {0,8,137},{0,8,73},{0,9,243},{16,7,4},{0,8,85},{0,8,21},{16,8,258},
-        {19,7,43},{0,8,117},{0,8,53},{0,9,203},{17,7,13},{0,8,101},{0,8,37},
-        {0,9,171},{0,8,5},{0,8,133},{0,8,69},{0,9,235},{16,7,8},{0,8,93},
-        {0,8,29},{0,9,155},{20,7,83},{0,8,125},{0,8,61},{0,9,219},{18,7,23},
-        {0,8,109},{0,8,45},{0,9,187},{0,8,13},{0,8,141},{0,8,77},{0,9,251},
-        {16,7,3},{0,8,83},{0,8,19},{21,8,195},{19,7,35},{0,8,115},{0,8,51},
-        {0,9,199},{17,7,11},{0,8,99},{0,8,35},{0,9,167},{0,8,3},{0,8,131},
-        {0,8,67},{0,9,231},{16,7,7},{0,8,91},{0,8,27},{0,9,151},{20,7,67},
-        {0,8,123},{0,8,59},{0,9,215},{18,7,19},{0,8,107},{0,8,43},{0,9,183},
-        {0,8,11},{0,8,139},{0,8,75},{0,9,247},{16,7,5},{0,8,87},{0,8,23},
-        {64,8,0},{19,7,51},{0,8,119},{0,8,55},{0,9,207},{17,7,15},{0,8,103},
-        {0,8,39},{0,9,175},{0,8,7},{0,8,135},{0,8,71},{0,9,239},{16,7,9},
-        {0,8,95},{0,8,31},{0,9,159},{20,7,99},{0,8,127},{0,8,63},{0,9,223},
-        {18,7,27},{0,8,111},{0,8,47},{0,9,191},{0,8,15},{0,8,143},{0,8,79},
-        {0,9,255}
-    };
-
-    static const code distfix[32] = {
-        {16,5,1},{23,5,257},{19,5,17},{27,5,4097},{17,5,5},{25,5,1025},
-        {21,5,65},{29,5,16385},{16,5,3},{24,5,513},{20,5,33},{28,5,8193},
-        {18,5,9},{26,5,2049},{22,5,129},{64,5,0},{16,5,2},{23,5,385},
-        {19,5,25},{27,5,6145},{17,5,7},{25,5,1537},{21,5,97},{29,5,24577},
-        {16,5,4},{24,5,769},{20,5,49},{28,5,12289},{18,5,13},{26,5,3073},
-        {22,5,193},{64,5,0}
-    };
diff --git a/contrib/libzlib-ng/inflate.c b/contrib/libzlib-ng/inflate.c
deleted file mode 100644
index de1f0124e55..00000000000
--- a/contrib/libzlib-ng/inflate.c
+++ /dev/null
@@ -1,1467 +0,0 @@
-/* inflate.c -- zlib decompression
- * Copyright (C) 1995-2012 Mark Adler
- * For conditions of distribution and use, see copyright notice in zlib.h
- */
-
-/*
- * Change history:
- *
- * 1.2.beta0    24 Nov 2002
- * - First version -- complete rewrite of inflate to simplify code, avoid
- *   creation of window when not needed, minimize use of window when it is
- *   needed, make inffast.c even faster, implement gzip decoding, and to
- *   improve code readability and style over the previous zlib inflate code
- *
- * 1.2.beta1    25 Nov 2002
- * - Use pointers for available input and output checking in inffast.c
- * - Remove input and output counters in inffast.c
- * - Change inffast.c entry and loop from avail_in >= 7 to >= 6
- * - Remove unnecessary second byte pull from length extra in inffast.c
- * - Unroll direct copy to three copies per loop in inffast.c
- *
- * 1.2.beta2    4 Dec 2002
- * - Change external routine names to reduce potential conflicts
- * - Correct filename to inffixed.h for fixed tables in inflate.c
- * - Make hbuf[] unsigned char to match parameter type in inflate.c
- * - Change strm->next_out[-state->offset] to *(strm->next_out - state->offset)
- *   to avoid negation problem on Alphas (64 bit) in inflate.c
- *
- * 1.2.beta3    22 Dec 2002
- * - Add comments on state->bits assertion in inffast.c
- * - Add comments on op field in inftrees.h
- * - Fix bug in reuse of allocated window after inflateReset()
- * - Remove bit fields--back to byte structure for speed
- * - Remove distance extra == 0 check in inflate_fast()--only helps for lengths
- * - Change post-increments to pre-increments in inflate_fast(), PPC biased?
- * - Add compile time option, POSTINC, to use post-increments instead (Intel?)
- * - Make MATCH copy in inflate() much faster for when inflate_fast() not used
- * - Use local copies of stream next and avail values, as well as local bit
- *   buffer and bit count in inflate()--for speed when inflate_fast() not used
- *
- * 1.2.beta4    1 Jan 2003
- * - Split ptr - 257 statements in inflate_table() to avoid compiler warnings
- * - Move a comment on output buffer sizes from inffast.c to inflate.c
- * - Add comments in inffast.c to introduce the inflate_fast() routine
- * - Rearrange window copies in inflate_fast() for speed and simplification
- * - Unroll last copy for window match in inflate_fast()
- * - Use local copies of window variables in inflate_fast() for speed
- * - Pull out common wnext == 0 case for speed in inflate_fast()
- * - Make op and len in inflate_fast() unsigned for consistency
- * - Add FAR to lcode and dcode declarations in inflate_fast()
- * - Simplified bad distance check in inflate_fast()
- * - Added inflateBackInit(), inflateBack(), and inflateBackEnd() in new
- *   source file infback.c to provide a call-back interface to inflate for
- *   programs like gzip and unzip -- uses window as output buffer to avoid
- *   window copying
- *
- * 1.2.beta5    1 Jan 2003
- * - Improved inflateBack() interface to allow the caller to provide initial
- *   input in strm.
- * - Fixed stored blocks bug in inflateBack()
- *
- * 1.2.beta6    4 Jan 2003
- * - Added comments in inffast.c on effectiveness of POSTINC
- * - Typecasting all around to reduce compiler warnings
- * - Changed loops from while (1) or do {} while (1) to for (;;), again to
- *   make compilers happy
- * - Changed type of window in inflateBackInit() to unsigned char *
- *
- * 1.2.beta7    27 Jan 2003
- * - Changed many types to unsigned or unsigned short to avoid warnings
- * - Added inflateCopy() function
- *
- * 1.2.0        9 Mar 2003
- * - Changed inflateBack() interface to provide separate opaque descriptors
- *   for the in() and out() functions
- * - Changed inflateBack() argument and in_func typedef to swap the length
- *   and buffer address return values for the input function
- * - Check next_in and next_out for Z_NULL on entry to inflate()
- *
- * The history for versions after 1.2.0 are in ChangeLog in zlib distribution.
- */
-
-#include "zutil.h"
-#include "inftrees.h"
-#include "inflate.h"
-#include "inffast.h"
-
-#ifdef MAKEFIXED
-#  ifndef BUILDFIXED
-#    define BUILDFIXED
-#  endif
-#endif
-
-/* function prototypes */
-local void fixedtables(struct inflate_state *state);
-local int updatewindow(z_stream *strm, const unsigned char *end, uint32_t copy);
-#ifdef BUILDFIXED
-    void makefixed(void);
-#endif
-local uint32_t syncsearch(uint32_t *have, const unsigned char *buf, uint32_t len);
-
-int ZEXPORT inflateResetKeep(z_stream *strm) {
-    struct inflate_state *state;
-
-    if (strm == Z_NULL || strm->state == Z_NULL)
-        return Z_STREAM_ERROR;
-    state = (struct inflate_state *)strm->state;
-    strm->total_in = strm->total_out = state->total = 0;
-    strm->msg = Z_NULL;
-    if (state->wrap)        /* to support ill-conceived Java test suite */
-        strm->adler = state->wrap & 1;
-    state->mode = HEAD;
-    state->last = 0;
-    state->havedict = 0;
-    state->dmax = 32768U;
-    state->head = Z_NULL;
-    state->hold = 0;
-    state->bits = 0;
-    state->lencode = state->distcode = state->next = state->codes;
-    state->sane = 1;
-    state->back = -1;
-    Tracev((stderr, "inflate: reset\n"));
-    return Z_OK;
-}
-
-int ZEXPORT inflateReset(z_stream *strm) {
-    struct inflate_state *state;
-
-    if (strm == Z_NULL || strm->state == Z_NULL)
-        return Z_STREAM_ERROR;
-    state = (struct inflate_state *)strm->state;
-    state->wsize = 0;
-    state->whave = 0;
-    state->wnext = 0;
-    return inflateResetKeep(strm);
-}
-
-int ZEXPORT inflateReset2(z_stream *strm, int windowBits) {
-    int wrap;
-    struct inflate_state *state;
-
-    /* get the state */
-    if (strm == Z_NULL || strm->state == Z_NULL)
-        return Z_STREAM_ERROR;
-    state = (struct inflate_state *)strm->state;
-
-    /* extract wrap request from windowBits parameter */
-    if (windowBits < 0) {
-        wrap = 0;
-        windowBits = -windowBits;
-    } else {
-        wrap = (windowBits >> 4) + 1;
-#ifdef GUNZIP
-        if (windowBits < 48)
-            windowBits &= 15;
-#endif
-    }
-
-    /* set number of window bits, free window if different */
-    if (windowBits && (windowBits < 8 || windowBits > 15))
-        return Z_STREAM_ERROR;
-    if (state->window != Z_NULL && state->wbits != (unsigned)windowBits) {
-        ZFREE(strm, state->window);
-        state->window = Z_NULL;
-    }
-
-    /* update state and reset the rest of it */
-    state->wrap = wrap;
-    state->wbits = (unsigned)windowBits;
-    return inflateReset(strm);
-}
-
-int ZEXPORT inflateInit2_(z_stream *strm, int windowBits, const char *version, int stream_size) {
-    int ret;
-    struct inflate_state *state;
-
-    if (version == Z_NULL || version[0] != ZLIB_VERSION[0] || stream_size != (int)(sizeof(z_stream)))
-        return Z_VERSION_ERROR;
-    if (strm == Z_NULL)
-        return Z_STREAM_ERROR;
-    strm->msg = Z_NULL;                 /* in case we return an error */
-    if (strm->zalloc == (alloc_func)0) {
-        strm->zalloc = zcalloc;
-        strm->opaque = NULL;
-    }
-    if (strm->zfree == (free_func)0)
-        strm->zfree = zcfree;
-    state = (struct inflate_state *) ZALLOC(strm, 1, sizeof(struct inflate_state));
-    if (state == Z_NULL)
-        return Z_MEM_ERROR;
-    Tracev((stderr, "inflate: allocated\n"));
-    strm->state = (struct internal_state *)state;
-    state->window = Z_NULL;
-    ret = inflateReset2(strm, windowBits);
-    if (ret != Z_OK) {
-        ZFREE(strm, state);
-        strm->state = Z_NULL;
-    }
-    return ret;
-}
-
-int ZEXPORT inflateInit_(z_stream *strm, const char *version, int stream_size) {
-    return inflateInit2_(strm, DEF_WBITS, version, stream_size);
-}
-
-int ZEXPORT inflatePrime(z_stream *strm, int bits, int value) {
-    struct inflate_state *state;
-
-    if (strm == Z_NULL || strm->state == Z_NULL)
-        return Z_STREAM_ERROR;
-    state = (struct inflate_state *)strm->state;
-    if (bits < 0) {
-        state->hold = 0;
-        state->bits = 0;
-        return Z_OK;
-    }
-    if (bits > 16 || state->bits + bits > 32)
-        return Z_STREAM_ERROR;
-    value &= (1L << bits) - 1;
-    state->hold += (unsigned)value << state->bits;
-    state->bits += bits;
-    return Z_OK;
-}
-
-/*
-   Return state with length and distance decoding tables and index sizes set to
-   fixed code decoding.  Normally this returns fixed tables from inffixed.h.
-   If BUILDFIXED is defined, then instead this routine builds the tables the
-   first time it's called, and returns those tables the first time and
-   thereafter.  This reduces the size of the code by about 2K bytes, in
-   exchange for a little execution time.  However, BUILDFIXED should not be
-   used for threaded applications, since the rewriting of the tables and virgin
-   may not be thread-safe.
- */
-local void fixedtables(struct inflate_state *state) {
-#ifdef BUILDFIXED
-    static int virgin = 1;
-    static code *lenfix, *distfix;
-    static code fixed[544];
-
-    /* build fixed huffman tables if first call (may not be thread safe) */
-    if (virgin) {
-        unsigned sym, bits;
-        static code *next;
-
-        /* literal/length table */
-        sym = 0;
-        while (sym < 144) state->lens[sym++] = 8;
-        while (sym < 256) state->lens[sym++] = 9;
-        while (sym < 280) state->lens[sym++] = 7;
-        while (sym < 288) state->lens[sym++] = 8;
-        next = fixed;
-        lenfix = next;
-        bits = 9;
-        inflate_table(LENS, state->lens, 288, &(next), &(bits), state->work);
-
-        /* distance table */
-        sym = 0;
-        while (sym < 32) state->lens[sym++] = 5;
-        distfix = next;
-        bits = 5;
-        inflate_table(DISTS, state->lens, 32, &(next), &(bits), state->work);
-
-        /* do this just once */
-        virgin = 0;
-    }
-#else /* !BUILDFIXED */
-#   include "inffixed.h"
-#endif /* BUILDFIXED */
-    state->lencode = lenfix;
-    state->lenbits = 9;
-    state->distcode = distfix;
-    state->distbits = 5;
-}
-
-#ifdef MAKEFIXED
-#include <stdio.h>
-
-/*
-   Write out the inffixed.h that is #include'd above.  Defining MAKEFIXED also
-   defines BUILDFIXED, so the tables are built on the fly.  makefixed() writes
-   those tables to stdout, which would be piped to inffixed.h.  A small program
-   can simply call makefixed to do this:
-
-    void makefixed(void);
-
-    int main(void)
-    {
-        makefixed();
-        return 0;
-    }
-
-   Then that can be linked with zlib built with MAKEFIXED defined and run:
-
-    a.out > inffixed.h
- */
-void makefixed(void) {
-    unsigned low, size;
-    struct inflate_state state;
-
-    fixedtables(&state);
-    puts("    /* inffixed.h -- table for decoding fixed codes");
-    puts("     * Generated automatically by makefixed().");
-    puts("     */");
-    puts("");
-    puts("    /* WARNING: this file should *not* be used by applications.");
-    puts("       It is part of the implementation of this library and is");
-    puts("       subject to change. Applications should only use zlib.h.");
-    puts("     */");
-    puts("");
-    size = 1U << 9;
-    printf("    static const code lenfix[%u] = {", size);
-    low = 0;
-    for (;;) {
-        if ((low % 7) == 0)
-            printf("\n        ");
-        printf("{%u,%u,%d}", (low & 127) == 99 ? 64 : state.lencode[low].op,
-            state.lencode[low].bits, state.lencode[low].val);
-        if (++low == size)
-            break;
-        putchar(',');
-    }
-    puts("\n    };");
-    size = 1U << 5;
-    printf("\n    static const code distfix[%u] = {", size);
-    low = 0;
-    for (;;) {
-        if ((low % 6) == 0)
-            printf("\n        ");
-        printf("{%u,%u,%d}", state.distcode[low].op, state.distcode[low].bits, state.distcode[low].val);
-        if (++low == size)
-            break;
-        putchar(',');
-    }
-    puts("\n    };");
-}
-#endif /* MAKEFIXED */
-
-/*
-   Update the window with the last wsize (normally 32K) bytes written before
-   returning.  If window does not exist yet, create it.  This is only called
-   when a window is already in use, or when output has been written during this
-   inflate call, but the end of the deflate stream has not been reached yet.
-   It is also called to create a window for dictionary data when a dictionary
-   is loaded.
-
-   Providing output buffers larger than 32K to inflate() should provide a speed
-   advantage, since only the last 32K of output is copied to the sliding window
-   upon return from inflate(), and since all distances after the first 32K of
-   output will fall in the output data, making match copies simpler and faster.
-   The advantage may be dependent on the size of the processor's data caches.
- */
-local int updatewindow(z_stream *strm, const unsigned char *end, uint32_t copy) {
-    struct inflate_state *state;
-    uint32_t dist;
-
-    state = (struct inflate_state *)strm->state;
-
-    /* if it hasn't been done already, allocate space for the window */
-    if (state->window == Z_NULL) {
-        state->window = (unsigned char *) ZALLOC(strm, 1U << state->wbits, sizeof(unsigned char));
-        if (state->window == Z_NULL)
-            return 1;
-    }
-
-    /* if window not in use yet, initialize */
-    if (state->wsize == 0) {
-        state->wsize = 1U << state->wbits;
-        state->wnext = 0;
-        state->whave = 0;
-    }
-
-    /* copy state->wsize or less output bytes into the circular window */
-    if (copy >= state->wsize) {
-        memcpy(state->window, end - state->wsize, state->wsize);
-        state->wnext = 0;
-        state->whave = state->wsize;
-    } else {
-        dist = state->wsize - state->wnext;
-        if (dist > copy)
-            dist = copy;
-        memcpy(state->window + state->wnext, end - copy, dist);
-        copy -= dist;
-        if (copy) {
-            memcpy(state->window, end - copy, copy);
-            state->wnext = copy;
-            state->whave = state->wsize;
-        } else {
-            state->wnext += dist;
-            if (state->wnext == state->wsize)
-                state->wnext = 0;
-            if (state->whave < state->wsize)
-                state->whave += dist;
-        }
-    }
-    return 0;
-}
-
-/* Macros for inflate(): */
-
-/* check function to use adler32() for zlib or crc32() for gzip */
-#ifdef GUNZIP
-#  define UPDATE(check, buf, len) \
-    (state->flags ? crc32(check, buf, len) : adler32(check, buf, len))
-#else
-#  define UPDATE(check, buf, len) adler32(check, buf, len)
-#endif
-
-/* check macros for header crc */
-#ifdef GUNZIP
-#  define CRC2(check, word) \
-    do { \
-        hbuf[0] = (unsigned char)(word); \
-        hbuf[1] = (unsigned char)((word) >> 8); \
-        check = crc32(check, hbuf, 2); \
-    } while (0)
-
-#  define CRC4(check, word) \
-    do { \
-        hbuf[0] = (unsigned char)(word); \
-        hbuf[1] = (unsigned char)((word) >> 8); \
-        hbuf[2] = (unsigned char)((word) >> 16); \
-        hbuf[3] = (unsigned char)((word) >> 24); \
-        check = crc32(check, hbuf, 4); \
-    } while (0)
-#endif
-
-/* Load registers with state in inflate() for speed */
-#define LOAD() \
-    do { \
-        put = strm->next_out; \
-        left = strm->avail_out; \
-        next = strm->next_in; \
-        have = strm->avail_in; \
-        hold = state->hold; \
-        bits = state->bits; \
-    } while (0)
-
-/* Restore state from registers in inflate() */
-#define RESTORE() \
-    do { \
-        strm->next_out = put; \
-        strm->avail_out = left; \
-        strm->next_in = next; \
-        strm->avail_in = have; \
-        state->hold = hold; \
-        state->bits = bits; \
-    } while (0)
-
-/* Clear the input bit accumulator */
-#define INITBITS() \
-    do { \
-        hold = 0; \
-        bits = 0; \
-    } while (0)
-
-/* Get a byte of input into the bit accumulator, or return from inflate()
-   if there is no input available. */
-#define PULLBYTE() \
-    do { \
-        if (have == 0) goto inf_leave; \
-        have--; \
-        hold += (*next++ << bits); \
-        bits += 8; \
-    } while (0)
-
-/* Assure that there are at least n bits in the bit accumulator.  If there is
-   not enough available input to do that, then return from inflate(). */
-#define NEEDBITS(n) \
-    do { \
-        while (bits < (unsigned)(n)) \
-            PULLBYTE(); \
-    } while (0)
-
-/* Return the low n bits of the bit accumulator (n < 16) */
-#define BITS(n) \
-    (hold & ((1U << (n)) - 1))
-
-/* Remove n bits from the bit accumulator */
-#define DROPBITS(n) \
-    do { \
-        hold >>= (n); \
-        bits -= (unsigned)(n); \
-    } while (0)
-
-/* Remove zero to seven bits as needed to go to a byte boundary */
-#define BYTEBITS() \
-    do { \
-        hold >>= bits & 7; \
-        bits -= bits & 7; \
-    } while (0)
-
-/*
-   inflate() uses a state machine to process as much input data and generate as
-   much output data as possible before returning.  The state machine is
-   structured roughly as follows:
-
-    for (;;) switch (state) {
-    ...
-    case STATEn:
-        if (not enough input data or output space to make progress)
-            return;
-        ... make progress ...
-        state = STATEm;
-        break;
-    ...
-    }
-
-   so when inflate() is called again, the same case is attempted again, and
-   if the appropriate resources are provided, the machine proceeds to the
-   next state.  The NEEDBITS() macro is usually the way the state evaluates
-   whether it can proceed or should return.  NEEDBITS() does the return if
-   the requested bits are not available.  The typical use of the BITS macros
-   is:
-
-        NEEDBITS(n);
-        ... do something with BITS(n) ...
-        DROPBITS(n);
-
-   where NEEDBITS(n) either returns from inflate() if there isn't enough
-   input left to load n bits into the accumulator, or it continues.  BITS(n)
-   gives the low n bits in the accumulator.  When done, DROPBITS(n) drops
-   the low n bits off the accumulator.  INITBITS() clears the accumulator
-   and sets the number of available bits to zero.  BYTEBITS() discards just
-   enough bits to put the accumulator on a byte boundary.  After BYTEBITS()
-   and a NEEDBITS(8), then BITS(8) would return the next byte in the stream.
-
-   NEEDBITS(n) uses PULLBYTE() to get an available byte of input, or to return
-   if there is no input available.  The decoding of variable length codes uses
-   PULLBYTE() directly in order to pull just enough bytes to decode the next
-   code, and no more.
-
-   Some states loop until they get enough input, making sure that enough
-   state information is maintained to continue the loop where it left off
-   if NEEDBITS() returns in the loop.  For example, want, need, and keep
-   would all have to actually be part of the saved state in case NEEDBITS()
-   returns:
-
-    case STATEw:
-        while (want < need) {
-            NEEDBITS(n);
-            keep[want++] = BITS(n);
-            DROPBITS(n);
-        }
-        state = STATEx;
-    case STATEx:
-
-   As shown above, if the next state is also the next case, then the break
-   is omitted.
-
-   A state may also return if there is not enough output space available to
-   complete that state.  Those states are copying stored data, writing a
-   literal byte, and copying a matching string.
-
-   When returning, a "goto inf_leave" is used to update the total counters,
-   update the check value, and determine whether any progress has been made
-   during that inflate() call in order to return the proper return code.
-   Progress is defined as a change in either strm->avail_in or strm->avail_out.
-   When there is a window, goto inf_leave will update the window with the last
-   output written.  If a goto inf_leave occurs in the middle of decompression
-   and there is no window currently, goto inf_leave will create one and copy
-   output to the window for the next call of inflate().
-
-   In this implementation, the flush parameter of inflate() only affects the
-   return code (per zlib.h).  inflate() always writes as much as possible to
-   strm->next_out, given the space available and the provided input--the effect
-   documented in zlib.h of Z_SYNC_FLUSH.  Furthermore, inflate() always defers
-   the allocation of and copying into a sliding window until necessary, which
-   provides the effect documented in zlib.h for Z_FINISH when the entire input
-   stream available.  So the only thing the flush parameter actually does is:
-   when flush is set to Z_FINISH, inflate() cannot return Z_OK.  Instead it
-   will return Z_BUF_ERROR if it has not reached the end of the stream.
- */
-
-int ZEXPORT inflate(z_stream *strm, int flush) {
-    struct inflate_state *state;
-    const unsigned char *next;  /* next input */
-    unsigned char *put;         /* next output */
-    unsigned have, left;        /* available input and output */
-    uint32_t hold;              /* bit buffer */
-    unsigned bits;              /* bits in bit buffer */
-    uint32_t in, out;           /* save starting available input and output */
-    unsigned copy;              /* number of stored or match bytes to copy */
-    unsigned char *from;        /* where to copy match bytes from */
-    code here;                  /* current decoding table entry */
-    code last;                  /* parent table entry */
-    unsigned len;               /* length to copy for repeats, bits to drop */
-    int ret;                    /* return code */
-#ifdef GUNZIP
-    unsigned char hbuf[4];      /* buffer for gzip header crc calculation */
-#endif
-    static const uint16_t order[19] = /* permutation of code lengths */
-        {16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15};
-
-    if (strm == Z_NULL || strm->state == Z_NULL || strm->next_out == Z_NULL ||
-        (strm->next_in == Z_NULL && strm->avail_in != 0))
-        return Z_STREAM_ERROR;
-
-    state = (struct inflate_state *)strm->state;
-    if (state->mode == TYPE)      /* skip check */
-        state->mode = TYPEDO;
-    LOAD();
-    in = have;
-    out = left;
-    ret = Z_OK;
-    for (;;)
-        switch (state->mode) {
-        case HEAD:
-            if (state->wrap == 0) {
-                state->mode = TYPEDO;
-                break;
-            }
-            NEEDBITS(16);
-#ifdef GUNZIP
-            if ((state->wrap & 2) && hold == 0x8b1f) {  /* gzip header */
-                if (state->wbits == 0)
-                    state->wbits = 15;
-                state->check = crc32(0L, Z_NULL, 0);
-                CRC2(state->check, hold);
-                INITBITS();
-                state->mode = FLAGS;
-                break;
-            }
-            state->flags = 0;           /* expect zlib header */
-            if (state->head != Z_NULL)
-                state->head->done = -1;
-            if (!(state->wrap & 1) ||   /* check if zlib header allowed */
-#else
-            if (
-#endif
-                ((BITS(8) << 8) + (hold >> 8)) % 31) {
-                strm->msg = (char *)"incorrect header check";
-                state->mode = BAD;
-                break;
-            }
-            if (BITS(4) != Z_DEFLATED) {
-                strm->msg = (char *)"unknown compression method";
-                state->mode = BAD;
-                break;
-            }
-            DROPBITS(4);
-            len = BITS(4) + 8;
-            if (state->wbits == 0)
-                state->wbits = len;
-            if (len > 15 || len > state->wbits) {
-                strm->msg = (char *)"invalid window size";
-                state->mode = BAD;
-                break;
-            }
-            state->dmax = 1U << len;
-            Tracev((stderr, "inflate:   zlib header ok\n"));
-            strm->adler = state->check = adler32(0L, Z_NULL, 0);
-            state->mode = hold & 0x200 ? DICTID : TYPE;
-            INITBITS();
-            break;
-#ifdef GUNZIP
-        case FLAGS:
-            NEEDBITS(16);
-            state->flags = (int)(hold);
-            if ((state->flags & 0xff) != Z_DEFLATED) {
-                strm->msg = (char *)"unknown compression method";
-                state->mode = BAD;
-                break;
-            }
-            if (state->flags & 0xe000) {
-                strm->msg = (char *)"unknown header flags set";
-                state->mode = BAD;
-                break;
-            }
-            if (state->head != Z_NULL)
-                state->head->text = (int)((hold >> 8) & 1);
-            if (state->flags & 0x0200)
-                CRC2(state->check, hold);
-            INITBITS();
-            state->mode = TIME;
-        case TIME:
-            NEEDBITS(32);
-            if (state->head != Z_NULL)
-                state->head->time = hold;
-            if (state->flags & 0x0200)
-                CRC4(state->check, hold);
-            INITBITS();
-            state->mode = OS;
-        case OS:
-            NEEDBITS(16);
-            if (state->head != Z_NULL) {
-                state->head->xflags = (int)(hold & 0xff);
-                state->head->os = (int)(hold >> 8);
-            }
-            if (state->flags & 0x0200)
-                CRC2(state->check, hold);
-            INITBITS();
-            state->mode = EXLEN;
-        case EXLEN:
-            if (state->flags & 0x0400) {
-                NEEDBITS(16);
-                state->length = (uint16_t)hold;
-                if (state->head != Z_NULL)
-                    state->head->extra_len = (uint16_t)hold;
-                if (state->flags & 0x0200)
-                    CRC2(state->check, hold);
-                INITBITS();
-            } else if (state->head != Z_NULL) {
-                state->head->extra = Z_NULL;
-            }
-            state->mode = EXTRA;
-        case EXTRA:
-            if (state->flags & 0x0400) {
-                copy = state->length;
-                if (copy > have)
-                    copy = have;
-                if (copy) {
-                    if (state->head != Z_NULL &&
-                        state->head->extra != Z_NULL) {
-                        len = state->head->extra_len - state->length;
-                        memcpy(state->head->extra + len, next,
-                                len + copy > state->head->extra_max ?
-                                state->head->extra_max - len : copy);
-                    }
-                    if (state->flags & 0x0200)
-                        state->check = crc32(state->check, next, copy);
-                    have -= copy;
-                    next += copy;
-                    state->length -= copy;
-                }
-                if (state->length)
-                    goto inf_leave;
-            }
-            state->length = 0;
-            state->mode = NAME;
-        case NAME:
-            if (state->flags & 0x0800) {
-                if (have == 0) goto inf_leave;
-                copy = 0;
-                do {
-                    len = (unsigned)(next[copy++]);
-                    if (state->head != Z_NULL && state->head->name != Z_NULL && state->length < state->head->name_max)
-                        state->head->name[state->length++] = len;
-                } while (len && copy < have);
-                if (state->flags & 0x0200)
-                    state->check = crc32(state->check, next, copy);
-                have -= copy;
-                next += copy;
-                if (len)
-                    goto inf_leave;
-            } else if (state->head != Z_NULL) {
-                state->head->name = Z_NULL;
-            }
-            state->length = 0;
-            state->mode = COMMENT;
-        case COMMENT:
-            if (state->flags & 0x1000) {
-                if (have == 0) goto inf_leave;
-                copy = 0;
-                do {
-                    len = (unsigned)(next[copy++]);
-                    if (state->head != Z_NULL && state->head->comment != Z_NULL
-                        && state->length < state->head->comm_max)
-                        state->head->comment[state->length++] = len;
-                } while (len && copy < have);
-                if (state->flags & 0x0200)
-                    state->check = crc32(state->check, next, copy);
-                have -= copy;
-                next += copy;
-                if (len)
-                    goto inf_leave;
-            } else if (state->head != Z_NULL) {
-                state->head->comment = Z_NULL;
-            }
-            state->mode = HCRC;
-        case HCRC:
-            if (state->flags & 0x0200) {
-                NEEDBITS(16);
-                if (hold != (state->check & 0xffff)) {
-                    strm->msg = (char *)"header crc mismatch";
-                    state->mode = BAD;
-                    break;
-                }
-                INITBITS();
-            }
-            if (state->head != Z_NULL) {
-                state->head->hcrc = (int)((state->flags >> 9) & 1);
-                state->head->done = 1;
-            }
-            strm->adler = state->check = crc32(0L, Z_NULL, 0);
-            state->mode = TYPE;
-            break;
-#endif
-        case DICTID:
-            NEEDBITS(32);
-            strm->adler = state->check = ZSWAP32(hold);
-            INITBITS();
-            state->mode = DICT;
-        case DICT:
-            if (state->havedict == 0) {
-                RESTORE();
-                return Z_NEED_DICT;
-            }
-            strm->adler = state->check = adler32(0L, Z_NULL, 0);
-            state->mode = TYPE;
-        case TYPE:
-            if (flush == Z_BLOCK || flush == Z_TREES)
-                goto inf_leave;
-        case TYPEDO:
-            if (state->last) {
-                BYTEBITS();
-                state->mode = CHECK;
-                break;
-            }
-            NEEDBITS(3);
-            state->last = BITS(1);
-            DROPBITS(1);
-            switch (BITS(2)) {
-            case 0:                             /* stored block */
-                Tracev((stderr, "inflate:     stored block%s\n", state->last ? " (last)" : ""));
-                state->mode = STORED;
-                break;
-            case 1:                             /* fixed block */
-                fixedtables(state);
-                Tracev((stderr, "inflate:     fixed codes block%s\n", state->last ? " (last)" : ""));
-                state->mode = LEN_;             /* decode codes */
-                if (flush == Z_TREES) {
-                    DROPBITS(2);
-                    goto inf_leave;
-                }
-                break;
-            case 2:                             /* dynamic block */
-                Tracev((stderr, "inflate:     dynamic codes block%s\n", state->last ? " (last)" : ""));
-                state->mode = TABLE;
-                break;
-            case 3:
-                strm->msg = (char *)"invalid block type";
-                state->mode = BAD;
-            }
-            DROPBITS(2);
-            break;
-        case STORED:
-            BYTEBITS();                         /* go to byte boundary */
-            NEEDBITS(32);
-            if ((hold & 0xffff) != ((hold >> 16) ^ 0xffff)) {
-                strm->msg = (char *)"invalid stored block lengths";
-                state->mode = BAD;
-                break;
-            }
-            state->length = (uint16_t)hold;
-            Tracev((stderr, "inflate:       stored length %u\n", state->length));
-            INITBITS();
-            state->mode = COPY_;
-            if (flush == Z_TREES)
-                goto inf_leave;
-        case COPY_:
-            state->mode = COPY;
-        case COPY:
-            copy = state->length;
-            if (copy) {
-                if (copy > have) copy = have;
-                if (copy > left) copy = left;
-                if (copy == 0) goto inf_leave;
-                memcpy(put, next, copy);
-                have -= copy;
-                next += copy;
-                left -= copy;
-                put += copy;
-                state->length -= copy;
-                break;
-            }
-            Tracev((stderr, "inflate:       stored end\n"));
-            state->mode = TYPE;
-            break;
-        case TABLE:
-            NEEDBITS(14);
-            state->nlen = BITS(5) + 257;
-            DROPBITS(5);
-            state->ndist = BITS(5) + 1;
-            DROPBITS(5);
-            state->ncode = BITS(4) + 4;
-            DROPBITS(4);
-#ifndef PKZIP_BUG_WORKAROUND
-            if (state->nlen > 286 || state->ndist > 30) {
-                strm->msg = (char *)"too many length or distance symbols";
-                state->mode = BAD;
-                break;
-            }
-#endif
-            Tracev((stderr, "inflate:       table sizes ok\n"));
-            state->have = 0;
-            state->mode = LENLENS;
-        case LENLENS:
-            while (state->have < state->ncode) {
-                NEEDBITS(3);
-                state->lens[order[state->have++]] = (uint16_t)BITS(3);
-                DROPBITS(3);
-            }
-            while (state->have < 19)
-                state->lens[order[state->have++]] = 0;
-            state->next = state->codes;
-            state->lencode = (const code *)(state->next);
-            state->lenbits = 7;
-            ret = inflate_table(CODES, state->lens, 19, &(state->next), &(state->lenbits), state->work);
-            if (ret) {
-                strm->msg = (char *)"invalid code lengths set";
-                state->mode = BAD;
-                break;
-            }
-            Tracev((stderr, "inflate:       code lengths ok\n"));
-            state->have = 0;
-            state->mode = CODELENS;
-        case CODELENS:
-            while (state->have < state->nlen + state->ndist) {
-                for (;;) {
-                    here = state->lencode[BITS(state->lenbits)];
-                    if (here.bits <= bits) break;
-                    PULLBYTE();
-                }
-                if (here.val < 16) {
-                    DROPBITS(here.bits);
-                    state->lens[state->have++] = here.val;
-                } else {
-                    if (here.val == 16) {
-                        NEEDBITS(here.bits + 2);
-                        DROPBITS(here.bits);
-                        if (state->have == 0) {
-                            strm->msg = (char *)"invalid bit length repeat";
-                            state->mode = BAD;
-                            break;
-                        }
-                        len = state->lens[state->have - 1];
-                        copy = 3 + BITS(2);
-                        DROPBITS(2);
-                    } else if (here.val == 17) {
-                        NEEDBITS(here.bits + 3);
-                        DROPBITS(here.bits);
-                        len = 0;
-                        copy = 3 + BITS(3);
-                        DROPBITS(3);
-                    } else {
-                        NEEDBITS(here.bits + 7);
-                        DROPBITS(here.bits);
-                        len = 0;
-                        copy = 11 + BITS(7);
-                        DROPBITS(7);
-                    }
-                    if (state->have + copy > state->nlen + state->ndist) {
-                        strm->msg = (char *)"invalid bit length repeat";
-                        state->mode = BAD;
-                        break;
-                    }
-                    while (copy--)
-                        state->lens[state->have++] = (uint16_t)len;
-                }
-            }
-
-            /* handle error breaks in while */
-            if (state->mode == BAD)
-                break;
-
-            /* check for end-of-block code (better have one) */
-            if (state->lens[256] == 0) {
-                strm->msg = (char *)"invalid code -- missing end-of-block";
-                state->mode = BAD;
-                break;
-            }
-
-            /* build code tables -- note: do not change the lenbits or distbits
-               values here (9 and 6) without reading the comments in inftrees.h
-               concerning the ENOUGH constants, which depend on those values */
-            state->next = state->codes;
-            state->lencode = (const code *)(state->next);
-            state->lenbits = 9;
-            ret = inflate_table(LENS, state->lens, state->nlen, &(state->next), &(state->lenbits), state->work);
-            if (ret) {
-                strm->msg = (char *)"invalid literal/lengths set";
-                state->mode = BAD;
-                break;
-            }
-            state->distcode = (const code *)(state->next);
-            state->distbits = 6;
-            ret = inflate_table(DISTS, state->lens + state->nlen, state->ndist,
-                            &(state->next), &(state->distbits), state->work);
-            if (ret) {
-                strm->msg = (char *)"invalid distances set";
-                state->mode = BAD;
-                break;
-            }
-            Tracev((stderr, "inflate:       codes ok\n"));
-            state->mode = LEN_;
-            if (flush == Z_TREES)
-                goto inf_leave;
-        case LEN_:
-            state->mode = LEN;
-        case LEN:
-            if (have >= 6 && left >= 258) {
-                RESTORE();
-                inflate_fast(strm, out);
-                LOAD();
-                if (state->mode == TYPE)
-                    state->back = -1;
-                break;
-            }
-            state->back = 0;
-            for (;;) {
-                here = state->lencode[BITS(state->lenbits)];
-                if (here.bits <= bits)
-                    break;
-                PULLBYTE();
-            }
-            if (here.op && (here.op & 0xf0) == 0) {
-                last = here;
-                for (;;) {
-                    here = state->lencode[last.val + (BITS(last.bits + last.op) >> last.bits)];
-                    if ((unsigned)last.bits + (unsigned)here.bits <= bits)
-                        break;
-                    PULLBYTE();
-                }
-                DROPBITS(last.bits);
-                state->back += last.bits;
-            }
-            DROPBITS(here.bits);
-            state->back += here.bits;
-            state->length = here.val;
-            if ((int)(here.op) == 0) {
-                Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ?
-                        "inflate:         literal '%c'\n" :
-                        "inflate:         literal 0x%02x\n", here.val));
-                state->mode = LIT;
-                break;
-            }
-            if (here.op & 32) {
-                Tracevv((stderr, "inflate:         end of block\n"));
-                state->back = -1;
-                state->mode = TYPE;
-                break;
-            }
-            if (here.op & 64) {
-                strm->msg = (char *)"invalid literal/length code";
-                state->mode = BAD;
-                break;
-            }
-            state->extra = (here.op & 15);
-            state->mode = LENEXT;
-        case LENEXT:
-            if (state->extra) {
-                NEEDBITS(state->extra);
-                state->length += BITS(state->extra);
-                DROPBITS(state->extra);
-                state->back += state->extra;
-            }
-            Tracevv((stderr, "inflate:         length %u\n", state->length));
-            state->was = state->length;
-            state->mode = DIST;
-        case DIST:
-            for (;;) {
-                here = state->distcode[BITS(state->distbits)];
-                if (here.bits <= bits)
-                    break;
-                PULLBYTE();
-            }
-            if ((here.op & 0xf0) == 0) {
-                last = here;
-                for (;;) {
-                    here = state->distcode[last.val + (BITS(last.bits + last.op) >> last.bits)];
-                    if ((unsigned)last.bits + (unsigned)here.bits <= bits)
-                        break;
-                    PULLBYTE();
-                }
-                DROPBITS(last.bits);
-                state->back += last.bits;
-            }
-            DROPBITS(here.bits);
-            state->back += here.bits;
-            if (here.op & 64) {
-                strm->msg = (char *)"invalid distance code";
-                state->mode = BAD;
-                break;
-            }
-            state->offset = here.val;
-            state->extra = (here.op & 15);
-            state->mode = DISTEXT;
-        case DISTEXT:
-            if (state->extra) {
-                NEEDBITS(state->extra);
-                state->offset += BITS(state->extra);
-                DROPBITS(state->extra);
-                state->back += state->extra;
-            }
-#ifdef INFLATE_STRICT
-            if (state->offset > state->dmax) {
-                strm->msg = (char *)"invalid distance too far back";
-                state->mode = BAD;
-                break;
-            }
-#endif
-            Tracevv((stderr, "inflate:         distance %u\n", state->offset));
-            state->mode = MATCH;
-        case MATCH:
-            if (left == 0) goto inf_leave;
-            copy = out - left;
-            if (state->offset > copy) {         /* copy from window */
-                copy = state->offset - copy;
-                if (copy > state->whave) {
-                    if (state->sane) {
-                        strm->msg = (char *)"invalid distance too far back";
-                        state->mode = BAD;
-                        break;
-                    }
-#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR
-                    Trace((stderr, "inflate.c too far\n"));
-                    copy -= state->whave;
-                    if (copy > state->length)
-                        copy = state->length;
-                    if (copy > left)
-                        copy = left;
-                    left -= copy;
-                    state->length -= copy;
-                    do {
-                        *put++ = 0;
-                    } while (--copy);
-                    if (state->length == 0)
-                        state->mode = LEN;
-                    break;
-#endif
-                }
-                if (copy > state->wnext) {
-                    copy -= state->wnext;
-                    from = state->window + (state->wsize - copy);
-                } else {
-                    from = state->window + (state->wnext - copy);
-                }
-                if (copy > state->length)
-                    copy = state->length;
-            } else {                             /* copy from output */
-                from = put - state->offset;
-                copy = state->length;
-            }
-            if (copy > left)
-                copy = left;
-            left -= copy;
-            state->length -= copy;
-            do {
-                *put++ = *from++;
-            } while (--copy);
-            if (state->length == 0)
-                state->mode = LEN;
-            break;
-        case LIT:
-            if (left == 0)
-                goto inf_leave;
-            *put++ = (unsigned char)(state->length);
-            left--;
-            state->mode = LEN;
-            break;
-        case CHECK:
-            if (state->wrap) {
-                NEEDBITS(32);
-                out -= left;
-                strm->total_out += out;
-                state->total += out;
-                if (out)
-                    strm->adler = state->check = UPDATE(state->check, put - out, out);
-                out = left;
-                if ((
-#ifdef GUNZIP
-                     state->flags ? hold :
-#endif
-                     ZSWAP32(hold)) != state->check) {
-                    strm->msg = (char *)"incorrect data check";
-                    state->mode = BAD;
-                    break;
-                }
-                INITBITS();
-                Tracev((stderr, "inflate:   check matches trailer\n"));
-            }
-#ifdef GUNZIP
-            state->mode = LENGTH;
-        case LENGTH:
-            if (state->wrap && state->flags) {
-                NEEDBITS(32);
-                if (hold != (state->total & 0xffffffffUL)) {
-                    strm->msg = (char *)"incorrect length check";
-                    state->mode = BAD;
-                    break;
-                }
-                INITBITS();
-                Tracev((stderr, "inflate:   length matches trailer\n"));
-            }
-#endif
-            state->mode = DONE;
-        case DONE:
-            ret = Z_STREAM_END;
-            goto inf_leave;
-        case BAD:
-            ret = Z_DATA_ERROR;
-            goto inf_leave;
-        case MEM:
-            return Z_MEM_ERROR;
-        case SYNC:
-        default:
-            return Z_STREAM_ERROR;
-        }
-
-    /*
-       Return from inflate(), updating the total counts and the check value.
-       If there was no progress during the inflate() call, return a buffer
-       error.  Call updatewindow() to create and/or update the window state.
-       Note: a memory error from inflate() is non-recoverable.
-     */
-  inf_leave:
-    RESTORE();
-    if (state->wsize || (out != strm->avail_out && state->mode < BAD && (state->mode < CHECK || flush != Z_FINISH))) {
-        if (updatewindow(strm, strm->next_out, out - strm->avail_out)) {
-            state->mode = MEM;
-            return Z_MEM_ERROR;
-        }
-    }
-    in -= strm->avail_in;
-    out -= strm->avail_out;
-    strm->total_in += in;
-    strm->total_out += out;
-    state->total += out;
-    if (state->wrap && out)
-        strm->adler = state->check = UPDATE(state->check, strm->next_out - out, out);
-    strm->data_type = state->bits + (state->last ? 64 : 0) +
-                      (state->mode == TYPE ? 128 : 0) + (state->mode == LEN_ || state->mode == COPY_ ? 256 : 0);
-    if (((in == 0 && out == 0) || flush == Z_FINISH) && ret == Z_OK)
-        ret = Z_BUF_ERROR;
-    return ret;
-}
-
-int ZEXPORT inflateEnd(z_stream *strm) {
-    struct inflate_state *state;
-    if (strm == Z_NULL || strm->state == Z_NULL || strm->zfree == (free_func)0)
-        return Z_STREAM_ERROR;
-    state = (struct inflate_state *)strm->state;
-    if (state->window != Z_NULL)
-        ZFREE(strm, state->window);
-    ZFREE(strm, strm->state);
-    strm->state = Z_NULL;
-    Tracev((stderr, "inflate: end\n"));
-    return Z_OK;
-}
-
-int ZEXPORT inflateGetDictionary(z_stream *strm, unsigned char *dictionary, unsigned int *dictLength) {
-    struct inflate_state *state;
-
-    /* check state */
-    if (strm == Z_NULL || strm->state == Z_NULL)
-        return Z_STREAM_ERROR;
-    state = (struct inflate_state *)strm->state;
-
-    /* copy dictionary */
-    if (state->whave && dictionary != Z_NULL) {
-        memcpy(dictionary, state->window + state->wnext, state->whave - state->wnext);
-        memcpy(dictionary + state->whave - state->wnext, state->window, state->wnext);
-    }
-    if (dictLength != Z_NULL)
-        *dictLength = state->whave;
-    return Z_OK;
-}
-
-int ZEXPORT inflateSetDictionary(z_stream *strm, const unsigned char *dictionary, unsigned int dictLength) {
-    struct inflate_state *state;
-    unsigned long dictid;
-    int ret;
-
-    /* check state */
-    if (strm == Z_NULL || strm->state == Z_NULL)
-        return Z_STREAM_ERROR;
-    state = (struct inflate_state *)strm->state;
-    if (state->wrap != 0 && state->mode != DICT)
-        return Z_STREAM_ERROR;
-
-    /* check for correct dictionary identifier */
-    if (state->mode == DICT) {
-        dictid = adler32(0L, Z_NULL, 0);
-        dictid = adler32(dictid, dictionary, dictLength);
-        if (dictid != state->check)
-            return Z_DATA_ERROR;
-    }
-
-    /* copy dictionary to window using updatewindow(), which will amend the
-       existing dictionary if appropriate */
-    ret = updatewindow(strm, dictionary + dictLength, dictLength);
-    if (ret) {
-        state->mode = MEM;
-        return Z_MEM_ERROR;
-    }
-    state->havedict = 1;
-    Tracev((stderr, "inflate:   dictionary set\n"));
-    return Z_OK;
-}
-
-int ZEXPORT inflateGetHeader(z_stream *strm, gz_headerp head) {
-    struct inflate_state *state;
-
-    /* check state */
-    if (strm == Z_NULL || strm->state == Z_NULL)
-        return Z_STREAM_ERROR;
-    state = (struct inflate_state *)strm->state;
-    if ((state->wrap & 2) == 0)
-        return Z_STREAM_ERROR;
-
-    /* save header structure */
-    state->head = head;
-    head->done = 0;
-    return Z_OK;
-}
-
-/*
-   Search buf[0..len-1] for the pattern: 0, 0, 0xff, 0xff.  Return when found
-   or when out of input.  When called, *have is the number of pattern bytes
-   found in order so far, in 0..3.  On return *have is updated to the new
-   state.  If on return *have equals four, then the pattern was found and the
-   return value is how many bytes were read including the last byte of the
-   pattern.  If *have is less than four, then the pattern has not been found
-   yet and the return value is len.  In the latter case, syncsearch() can be
-   called again with more data and the *have state.  *have is initialized to
-   zero for the first call.
- */
-local unsigned syncsearch(uint32_t *have, const unsigned char *buf, uint32_t len) {
-    uint32_t got;
-    uint32_t next;
-
-    got = *have;
-    next = 0;
-    while (next < len && got < 4) {
-        if ((int)(buf[next]) == (got < 2 ? 0 : 0xff))
-            got++;
-        else if (buf[next])
-            got = 0;
-        else
-            got = 4 - got;
-        next++;
-    }
-    *have = got;
-    return next;
-}
-
-int ZEXPORT inflateSync(z_stream *strm) {
-    unsigned len;               /* number of bytes to look at or looked at */
-    size_t in, out;             /* temporary to save total_in and total_out */
-    unsigned char buf[4];       /* to restore bit buffer to byte string */
-    struct inflate_state *state;
-
-    /* check parameters */
-    if (strm == Z_NULL || strm->state == Z_NULL)
-        return Z_STREAM_ERROR;
-    state = (struct inflate_state *)strm->state;
-    if (strm->avail_in == 0 && state->bits < 8)
-        return Z_BUF_ERROR;
-
-    /* if first time, start search in bit buffer */
-    if (state->mode != SYNC) {
-        state->mode = SYNC;
-        state->hold <<= state->bits & 7;
-        state->bits -= state->bits & 7;
-        len = 0;
-        while (state->bits >= 8) {
-            buf[len++] = (unsigned char)(state->hold);
-            state->hold >>= 8;
-            state->bits -= 8;
-        }
-        state->have = 0;
-        syncsearch(&(state->have), buf, len);
-    }
-
-    /* search available input */
-    len = syncsearch(&(state->have), strm->next_in, strm->avail_in);
-    strm->avail_in -= len;
-    strm->next_in += len;
-    strm->total_in += len;
-
-    /* return no joy or set up to restart inflate() on a new block */
-    if (state->have != 4)
-        return Z_DATA_ERROR;
-    in = strm->total_in;
-    out = strm->total_out;
-    inflateReset(strm);
-    strm->total_in = in;
-    strm->total_out = out;
-    state->mode = TYPE;
-    return Z_OK;
-}
-
-/*
-   Returns true if inflate is currently at the end of a block generated by
-   Z_SYNC_FLUSH or Z_FULL_FLUSH. This function is used by one PPP
-   implementation to provide an additional safety check. PPP uses
-   Z_SYNC_FLUSH but removes the length bytes of the resulting empty stored
-   block. When decompressing, PPP checks that at the end of input packet,
-   inflate is waiting for these length bytes.
- */
-int ZEXPORT inflateSyncPoint(z_stream *strm) {
-    struct inflate_state *state;
-
-    if (strm == Z_NULL || strm->state == Z_NULL)
-        return Z_STREAM_ERROR;
-    state = (struct inflate_state *)strm->state;
-    return state->mode == STORED && state->bits == 0;
-}
-
-int ZEXPORT inflateCopy(z_stream *dest, z_stream *source) {
-    struct inflate_state *state;
-    struct inflate_state *copy;
-    unsigned char *window;
-    unsigned wsize;
-
-    /* check input */
-    if (dest == Z_NULL || source == Z_NULL || source->state == Z_NULL ||
-        source->zalloc == (alloc_func)0 || source->zfree == (free_func)0)
-        return Z_STREAM_ERROR;
-    state = (struct inflate_state *)source->state;
-
-    /* allocate space */
-    copy = (struct inflate_state *)
-           ZALLOC(source, 1, sizeof(struct inflate_state));
-    if (copy == Z_NULL)
-        return Z_MEM_ERROR;
-    window = Z_NULL;
-    if (state->window != Z_NULL) {
-        window = (unsigned char *) ZALLOC(source, 1U << state->wbits, sizeof(unsigned char));
-        if (window == Z_NULL) {
-            ZFREE(source, copy);
-            return Z_MEM_ERROR;
-        }
-    }
-
-    /* copy state */
-    memcpy((void *)dest, (void *)source, sizeof(z_stream));
-    memcpy((void *)copy, (void *)state, sizeof(struct inflate_state));
-    if (state->lencode >= state->codes && state->lencode <= state->codes + ENOUGH - 1) {
-        copy->lencode = copy->codes + (state->lencode - state->codes);
-        copy->distcode = copy->codes + (state->distcode - state->codes);
-    }
-    copy->next = copy->codes + (state->next - state->codes);
-    if (window != Z_NULL) {
-        wsize = 1U << state->wbits;
-        memcpy(window, state->window, wsize);
-    }
-    copy->window = window;
-    dest->state = (struct internal_state *)copy;
-    return Z_OK;
-}
-
-int ZEXPORT inflateUndermine(z_stream *strm, int subvert) {
-    struct inflate_state *state;
-
-    if (strm == Z_NULL || strm->state == Z_NULL)
-        return Z_STREAM_ERROR;
-    state = (struct inflate_state *)strm->state;
-#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR
-    state->sane = !subvert;
-    return Z_OK;
-#else
-    state->sane = 1;
-    return Z_DATA_ERROR;
-#endif
-}
-
-long ZEXPORT inflateMark(z_stream *strm) {
-    struct inflate_state *state;
-
-    if (strm == Z_NULL || strm->state == Z_NULL)
-        return 0xFFFFFFFFFFFF0000L;
-    state = (struct inflate_state *)strm->state;
-    return ((long)(state->back) << 16) + (state->mode == COPY ? state->length :
-            (state->mode == MATCH ? state->was - state->length : 0));
-}
diff --git a/contrib/libzlib-ng/inflate.h b/contrib/libzlib-ng/inflate.h
deleted file mode 100644
index 2bf129db153..00000000000
--- a/contrib/libzlib-ng/inflate.h
+++ /dev/null
@@ -1,127 +0,0 @@
-/* inflate.h -- internal inflate state definition
- * Copyright (C) 1995-2009 Mark Adler
- * For conditions of distribution and use, see copyright notice in zlib.h
- */
-
-/* WARNING: this file should *not* be used by applications. It is
-   part of the implementation of the compression library and is
-   subject to change. Applications should only use zlib.h.
- */
-
-#ifndef INFLATE_H_
-#define INFLATE_H_
-
-/* define NO_GZIP when compiling if you want to disable gzip header and
-   trailer decoding by inflate().  NO_GZIP would be used to avoid linking in
-   the crc code when it is not needed.  For shared libraries, gzip decoding
-   should be left enabled. */
-#ifndef NO_GZIP
-#  define GUNZIP
-#endif
-
-/* Possible inflate modes between inflate() calls */
-typedef enum {
-    HEAD,       /* i: waiting for magic header */
-    FLAGS,      /* i: waiting for method and flags (gzip) */
-    TIME,       /* i: waiting for modification time (gzip) */
-    OS,         /* i: waiting for extra flags and operating system (gzip) */
-    EXLEN,      /* i: waiting for extra length (gzip) */
-    EXTRA,      /* i: waiting for extra bytes (gzip) */
-    NAME,       /* i: waiting for end of file name (gzip) */
-    COMMENT,    /* i: waiting for end of comment (gzip) */
-    HCRC,       /* i: waiting for header crc (gzip) */
-    DICTID,     /* i: waiting for dictionary check value */
-    DICT,       /* waiting for inflateSetDictionary() call */
-        TYPE,       /* i: waiting for type bits, including last-flag bit */
-        TYPEDO,     /* i: same, but skip check to exit inflate on new block */
-        STORED,     /* i: waiting for stored size (length and complement) */
-        COPY_,      /* i/o: same as COPY below, but only first time in */
-        COPY,       /* i/o: waiting for input or output to copy stored block */
-        TABLE,      /* i: waiting for dynamic block table lengths */
-        LENLENS,    /* i: waiting for code length code lengths */
-        CODELENS,   /* i: waiting for length/lit and distance code lengths */
-            LEN_,       /* i: same as LEN below, but only first time in */
-            LEN,        /* i: waiting for length/lit/eob code */
-            LENEXT,     /* i: waiting for length extra bits */
-            DIST,       /* i: waiting for distance code */
-            DISTEXT,    /* i: waiting for distance extra bits */
-            MATCH,      /* o: waiting for output space to copy string */
-            LIT,        /* o: waiting for output space to write literal */
-    CHECK,      /* i: waiting for 32-bit check value */
-    LENGTH,     /* i: waiting for 32-bit length (gzip) */
-    DONE,       /* finished check, done -- remain here until reset */
-    BAD,        /* got a data error -- remain here until reset */
-    MEM,        /* got an inflate() memory error -- remain here until reset */
-    SYNC        /* looking for synchronization bytes to restart inflate() */
-} inflate_mode;
-
-/*
-    State transitions between above modes -
-
-    (most modes can go to BAD or MEM on error -- not shown for clarity)
-
-    Process header:
-        HEAD -> (gzip) or (zlib) or (raw)
-        (gzip) -> FLAGS -> TIME -> OS -> EXLEN -> EXTRA -> NAME -> COMMENT ->
-                  HCRC -> TYPE
-        (zlib) -> DICTID or TYPE
-        DICTID -> DICT -> TYPE
-        (raw) -> TYPEDO
-    Read deflate blocks:
-            TYPE -> TYPEDO -> STORED or TABLE or LEN_ or CHECK
-            STORED -> COPY_ -> COPY -> TYPE
-            TABLE -> LENLENS -> CODELENS -> LEN_
-            LEN_ -> LEN
-    Read deflate codes in fixed or dynamic block:
-                LEN -> LENEXT or LIT or TYPE
-                LENEXT -> DIST -> DISTEXT -> MATCH -> LEN
-                LIT -> LEN
-    Process trailer:
-        CHECK -> LENGTH -> DONE
- */
-
-/* state maintained between inflate() calls.  Approximately 10K bytes. */
-struct inflate_state {
-    inflate_mode mode;          /* current inflate mode */
-    int last;                   /* true if processing last block */
-    int wrap;                   /* bit 0 true for zlib, bit 1 true for gzip */
-    int havedict;               /* true if dictionary provided */
-    int flags;                  /* gzip header method and flags (0 if zlib) */
-    unsigned dmax;              /* zlib header max distance (INFLATE_STRICT) */
-    unsigned long check;        /* protected copy of check value */
-    unsigned long total;        /* protected copy of output count */
-    gz_headerp head;            /* where to save gzip header information */
-        /* sliding window */
-    unsigned wbits;             /* log base 2 of requested window size */
-    uint32_t wsize;             /* window size or zero if not using window */
-    uint32_t whave;             /* valid bytes in the window */
-    uint32_t wnext;             /* window write index */
-    unsigned char *window;      /* allocated sliding window, if needed */
-        /* bit accumulator */
-    uint32_t hold;              /* input bit accumulator */
-    unsigned bits;              /* number of bits in "in" */
-        /* for string and stored block copying */
-    uint32_t length;            /* literal or length of data to copy */
-    unsigned offset;            /* distance back to copy string from */
-        /* for table and code decoding */
-    unsigned extra;             /* extra bits needed */
-        /* fixed and dynamic code tables */
-    code const *lencode;        /* starting table for length/literal codes */
-    code const *distcode;       /* starting table for distance codes */
-    unsigned lenbits;           /* index bits for lencode */
-    unsigned distbits;          /* index bits for distcode */
-        /* dynamic table building */
-    unsigned ncode;             /* number of code length code lengths */
-    unsigned nlen;              /* number of length code lengths */
-    unsigned ndist;             /* number of distance code lengths */
-    uint32_t have;              /* number of code lengths in lens[] */
-    code *next;                 /* next available space in codes[] */
-    uint16_t lens[320];         /* temporary storage for code lengths */
-    uint16_t work[288];         /* work area for code table building */
-    code codes[ENOUGH];         /* space for code tables */
-    int sane;                   /* if false, allow invalid distance too far */
-    int back;                   /* bits back of last unprocessed length/lit */
-    unsigned was;               /* initial length of match */
-};
-
-#endif /* INFLATE_H_ */
diff --git a/contrib/libzlib-ng/inftrees.c b/contrib/libzlib-ng/inftrees.c
deleted file mode 100644
index e02272cf864..00000000000
--- a/contrib/libzlib-ng/inftrees.c
+++ /dev/null
@@ -1,298 +0,0 @@
-/* inftrees.c -- generate Huffman trees for efficient decoding
- * Copyright (C) 1995-2013 Mark Adler
- * For conditions of distribution and use, see copyright notice in zlib.h
- */
-
-#include "zutil.h"
-#include "inftrees.h"
-
-#define MAXBITS 15
-
-const char inflate_copyright[] = " inflate 1.2.8.f Copyright 1995-2013 Mark Adler ";
-/*
-  If you use the zlib library in a product, an acknowledgment is welcome
-  in the documentation of your product. If for some reason you cannot
-  include such an acknowledgment, I would appreciate that you keep this
-  copyright string in the executable of your product.
- */
-
-/*
-   Build a set of tables to decode the provided canonical Huffman code.
-   The code lengths are lens[0..codes-1].  The result starts at *table,
-   whose indices are 0..2^bits-1.  work is a writable array of at least
-   lens shorts, which is used as a work area.  type is the type of code
-   to be generated, CODES, LENS, or DISTS.  On return, zero is success,
-   -1 is an invalid code, and +1 means that ENOUGH isn't enough.  table
-   on return points to the next available entry's address.  bits is the
-   requested root table index bits, and on return it is the actual root
-   table index bits.  It will differ if the request is greater than the
-   longest code or if it is less than the shortest code.
- */
-int ZLIB_INTERNAL inflate_table(codetype type, uint16_t *lens, unsigned codes,
-                                code * *table, unsigned *bits, uint16_t  *work) {
-    unsigned len;               /* a code's length in bits */
-    unsigned sym;               /* index of code symbols */
-    unsigned min, max;          /* minimum and maximum code lengths */
-    unsigned root;              /* number of index bits for root table */
-    unsigned curr;              /* number of index bits for current table */
-    unsigned drop;              /* code bits to drop for sub-table */
-    int left;                   /* number of prefix codes available */
-    unsigned used;              /* code entries in table used */
-    unsigned huff;              /* Huffman code */
-    unsigned incr;              /* for incrementing code, index */
-    unsigned fill;              /* index for replicating entries */
-    unsigned low;               /* low bits for current root entry */
-    unsigned mask;              /* mask for low root bits */
-    code here;                  /* table entry for duplication */
-    code *next;                 /* next available space in table */
-    const uint16_t *base;       /* base value table to use */
-    const uint16_t *extra;      /* extra bits table to use */
-    int end;                    /* use base and extra for symbol > end */
-    uint16_t count[MAXBITS+1];  /* number of codes of each length */
-    uint16_t offs[MAXBITS+1];   /* offsets in table for each length */
-    static const uint16_t lbase[31] = { /* Length codes 257..285 base */
-        3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31,
-        35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0};
-    static const uint16_t lext[31] = { /* Length codes 257..285 extra */
-        16, 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 17, 18, 18, 18, 18,
-        19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 16, 72, 78};
-    static const uint16_t dbase[32] = { /* Distance codes 0..29 base */
-        1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193,
-        257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145,
-        8193, 12289, 16385, 24577, 0, 0};
-    static const uint16_t dext[32] = { /* Distance codes 0..29 extra */
-        16, 16, 16, 16, 17, 17, 18, 18, 19, 19, 20, 20, 21, 21, 22, 22,
-        23, 23, 24, 24, 25, 25, 26, 26, 27, 27,
-        28, 28, 29, 29, 64, 64};
-
-    /*
-       Process a set of code lengths to create a canonical Huffman code.  The
-       code lengths are lens[0..codes-1].  Each length corresponds to the
-       symbols 0..codes-1.  The Huffman code is generated by first sorting the
-       symbols by length from short to long, and retaining the symbol order
-       for codes with equal lengths.  Then the code starts with all zero bits
-       for the first code of the shortest length, and the codes are integer
-       increments for the same length, and zeros are appended as the length
-       increases.  For the deflate format, these bits are stored backwards
-       from their more natural integer increment ordering, and so when the
-       decoding tables are built in the large loop below, the integer codes
-       are incremented backwards.
-
-       This routine assumes, but does not check, that all of the entries in
-       lens[] are in the range 0..MAXBITS.  The caller must assure this.
-       1..MAXBITS is interpreted as that code length.  zero means that that
-       symbol does not occur in this code.
-
-       The codes are sorted by computing a count of codes for each length,
-       creating from that a table of starting indices for each length in the
-       sorted table, and then entering the symbols in order in the sorted
-       table.  The sorted table is work[], with that space being provided by
-       the caller.
-
-       The length counts are used for other purposes as well, i.e. finding
-       the minimum and maximum length codes, determining if there are any
-       codes at all, checking for a valid set of lengths, and looking ahead
-       at length counts to determine sub-table sizes when building the
-       decoding tables.
-     */
-
-    /* accumulate lengths for codes (assumes lens[] all in 0..MAXBITS) */
-    for (len = 0; len <= MAXBITS; len++)
-        count[len] = 0;
-    for (sym = 0; sym < codes; sym++)
-        count[lens[sym]]++;
-
-    /* bound code lengths, force root to be within code lengths */
-    root = *bits;
-    for (max = MAXBITS; max >= 1; max--)
-        if (count[max] != 0) break;
-    if (root > max) root = max;
-    if (max == 0) {                     /* no symbols to code at all */
-        here.op = (unsigned char)64;    /* invalid code marker */
-        here.bits = (unsigned char)1;
-        here.val = (uint16_t)0;
-        *(*table)++ = here;             /* make a table to force an error */
-        *(*table)++ = here;
-        *bits = 1;
-        return 0;     /* no symbols, but wait for decoding to report error */
-    }
-    for (min = 1; min < max; min++)
-        if (count[min] != 0) break;
-    if (root < min) root = min;
-
-    /* check for an over-subscribed or incomplete set of lengths */
-    left = 1;
-    for (len = 1; len <= MAXBITS; len++) {
-        left <<= 1;
-        left -= count[len];
-        if (left < 0) return -1;        /* over-subscribed */
-    }
-    if (left > 0 && (type == CODES || max != 1))
-        return -1;                      /* incomplete set */
-
-    /* generate offsets into symbol table for each length for sorting */
-    offs[1] = 0;
-    for (len = 1; len < MAXBITS; len++)
-        offs[len + 1] = offs[len] + count[len];
-
-    /* sort symbols by length, by symbol order within each length */
-    for (sym = 0; sym < codes; sym++)
-        if (lens[sym] != 0) work[offs[lens[sym]]++] = (uint16_t)sym;
-
-    /*
-       Create and fill in decoding tables.  In this loop, the table being
-       filled is at next and has curr index bits.  The code being used is huff
-       with length len.  That code is converted to an index by dropping drop
-       bits off of the bottom.  For codes where len is less than drop + curr,
-       those top drop + curr - len bits are incremented through all values to
-       fill the table with replicated entries.
-
-       root is the number of index bits for the root table.  When len exceeds
-       root, sub-tables are created pointed to by the root entry with an index
-       of the low root bits of huff.  This is saved in low to check for when a
-       new sub-table should be started.  drop is zero when the root table is
-       being filled, and drop is root when sub-tables are being filled.
-
-       When a new sub-table is needed, it is necessary to look ahead in the
-       code lengths to determine what size sub-table is needed.  The length
-       counts are used for this, and so count[] is decremented as codes are
-       entered in the tables.
-
-       used keeps track of how many table entries have been allocated from the
-       provided *table space.  It is checked for LENS and DIST tables against
-       the constants ENOUGH_LENS and ENOUGH_DISTS to guard against changes in
-       the initial root table size constants.  See the comments in inftrees.h
-       for more information.
-
-       sym increments through all symbols, and the loop terminates when
-       all codes of length max, i.e. all codes, have been processed.  This
-       routine permits incomplete codes, so another loop after this one fills
-       in the rest of the decoding tables with invalid code markers.
-     */
-
-    /* set up for code type */
-    switch (type) {
-    case CODES:
-        base = extra = work;    /* dummy value--not used */
-        end = 19;
-        break;
-    case LENS:
-        base = lbase;
-        base -= 257;
-        extra = lext;
-        extra -= 257;
-        end = 256;
-        break;
-    default:            /* DISTS */
-        base = dbase;
-        extra = dext;
-        end = -1;
-    }
-
-    /* initialize state for loop */
-    huff = 0;                   /* starting code */
-    sym = 0;                    /* starting code symbol */
-    len = min;                  /* starting code length */
-    next = *table;              /* current table to fill in */
-    curr = root;                /* current table index bits */
-    drop = 0;                   /* current bits to drop from code for index */
-    low = (unsigned)(-1);       /* trigger new sub-table when len > root */
-    used = 1U << root;          /* use root table entries */
-    mask = used - 1;            /* mask for comparing low */
-
-    /* check available table space */
-    if ((type == LENS && used > ENOUGH_LENS) ||
-        (type == DISTS && used > ENOUGH_DISTS))
-        return 1;
-
-    /* process all codes and make table entries */
-    for (;;) {
-        /* create table entry */
-        here.bits = (unsigned char)(len - drop);
-        if ((int)(work[sym]) < end) {
-            here.op = (unsigned char)0;
-            here.val = work[sym];
-        } else if ((int)(work[sym]) > end) {
-            here.op = (unsigned char)(extra[work[sym]]);
-            here.val = base[work[sym]];
-        } else {
-            here.op = (unsigned char)(32 + 64);         /* end of block */
-            here.val = 0;
-        }
-
-        /* replicate for those indices with low len bits equal to huff */
-        incr = 1U << (len - drop);
-        fill = 1U << curr;
-        min = fill;                 /* save offset to next table */
-        do {
-            fill -= incr;
-            next[(huff >> drop) + fill] = here;
-        } while (fill != 0);
-
-        /* backwards increment the len-bit code huff */
-        incr = 1U << (len - 1);
-        while (huff & incr)
-            incr >>= 1;
-        if (incr != 0) {
-            huff &= incr - 1;
-            huff += incr;
-        } else {
-            huff = 0;
-        }
-
-        /* go to next symbol, update count, len */
-        sym++;
-        if (--(count[len]) == 0) {
-            if (len == max)
-                break;
-            len = lens[work[sym]];
-        }
-
-        /* create new sub-table if needed */
-        if (len > root && (huff & mask) != low) {
-            /* if first time, transition to sub-tables */
-            if (drop == 0)
-                drop = root;
-
-            /* increment past last table */
-            next += min;            /* here min is 1 << curr */
-
-            /* determine length of next table */
-            curr = len - drop;
-            left = (int)(1 << curr);
-            while (curr + drop < max) {
-                left -= count[curr + drop];
-                if (left <= 0)
-                    break;
-                curr++;
-                left <<= 1;
-            }
-
-            /* check for enough space */
-            used += 1U << curr;
-            if ((type == LENS && used > ENOUGH_LENS) || (type == DISTS && used > ENOUGH_DISTS))
-                return 1;
-
-            /* point entry in root table to sub-table */
-            low = huff & mask;
-            (*table)[low].op = (unsigned char)curr;
-            (*table)[low].bits = (unsigned char)root;
-            (*table)[low].val = (uint16_t)(next - *table);
-        }
-    }
-
-    /* fill in remaining table entry if code is incomplete (guaranteed to have
-       at most one remaining entry, since if the code is incomplete, the
-       maximum code length that was allowed to get this far is one bit) */
-    if (huff != 0) {
-        here.op = (unsigned char)64;            /* invalid code marker */
-        here.bits = (unsigned char)(len - drop);
-        here.val = (uint16_t)0;
-        next[huff] = here;
-    }
-
-    /* set return parameters */
-    *table += used;
-    *bits = root;
-    return 0;
-}
diff --git a/contrib/libzlib-ng/inftrees.h b/contrib/libzlib-ng/inftrees.h
deleted file mode 100644
index eaf3df1ca66..00000000000
--- a/contrib/libzlib-ng/inftrees.h
+++ /dev/null
@@ -1,66 +0,0 @@
-#ifndef INFTREES_H_
-#define INFTREES_H_
-
-/* inftrees.h -- header to use inftrees.c
- * Copyright (C) 1995-2005, 2010 Mark Adler
- * For conditions of distribution and use, see copyright notice in zlib.h
- */
-
-/* WARNING: this file should *not* be used by applications. It is
-   part of the implementation of the compression library and is
-   subject to change. Applications should only use zlib.h.
- */
-
-/* Structure for decoding tables.  Each entry provides either the
-   information needed to do the operation requested by the code that
-   indexed that table entry, or it provides a pointer to another
-   table that indexes more bits of the code.  op indicates whether
-   the entry is a pointer to another table, a literal, a length or
-   distance, an end-of-block, or an invalid code.  For a table
-   pointer, the low four bits of op is the number of index bits of
-   that table.  For a length or distance, the low four bits of op
-   is the number of extra bits to get after the code.  bits is
-   the number of bits in this code or part of the code to drop off
-   of the bit buffer.  val is the actual byte to output in the case
-   of a literal, the base length or distance, or the offset from
-   the current table to the next table.  Each entry is four bytes. */
-typedef struct {
-    unsigned char op;         /* operation, extra bits, table bits */
-    unsigned char bits;       /* bits in this part of the code */
-    uint16_t val;             /* offset in table or code value */
-} code;
-
-/* op values as set by inflate_table():
-    00000000 - literal
-    0000tttt - table link, tttt != 0 is the number of table index bits
-    0001eeee - length or distance, eeee is the number of extra bits
-    01100000 - end of block
-    01000000 - invalid code
- */
-
-/* Maximum size of the dynamic table.  The maximum number of code structures is
-   1444, which is the sum of 852 for literal/length codes and 592 for distance
-   codes.  These values were found by exhaustive searches using the program
-   examples/enough.c found in the zlib distribtution.  The arguments to that
-   program are the number of symbols, the initial root table size, and the
-   maximum bit length of a code.  "enough 286 9 15" for literal/length codes
-   returns returns 852, and "enough 30 6 15" for distance codes returns 592.
-   The initial root table size (9 or 6) is found in the fifth argument of the
-   inflate_table() calls in inflate.c and infback.c.  If the root table size is
-   changed, then these maximum sizes would be need to be recalculated and
-   updated. */
-#define ENOUGH_LENS 852
-#define ENOUGH_DISTS 592
-#define ENOUGH (ENOUGH_LENS+ENOUGH_DISTS)
-
-/* Type of code to build for inflate_table() */
-typedef enum {
-    CODES,
-    LENS,
-    DISTS
-} codetype;
-
-int ZLIB_INTERNAL inflate_table (codetype type, uint16_t *lens, unsigned codes,
-                                  code * *table, unsigned *bits, uint16_t *work);
-
-#endif /* INFTREES_H_ */
diff --git a/contrib/libzlib-ng/match.c b/contrib/libzlib-ng/match.c
deleted file mode 100644
index 25b3b14ce07..00000000000
--- a/contrib/libzlib-ng/match.c
+++ /dev/null
@@ -1,471 +0,0 @@
-/*
- * Set match_start to the longest match starting at the given string and
- * return its length. Matches shorter or equal to prev_length are discarded,
- * in which case the result is equal to prev_length and match_start is garbage.
- *
- * IN assertions: cur_match is the head of the hash chain for the current
- * string (strstart) and its distance is <= MAX_DIST, and prev_length >=1
- * OUT assertion: the match length is not greater than s->lookahead
- */
-
-#include "deflate.h"
-
-#if (defined(UNALIGNED_OK) && MAX_MATCH == 258)
-
-   /* Only use std3_longest_match for little_endian systems, also avoid using it with
-      non-gcc compilers since the __builtin_ctzl() function might not be optimized. */
-#  if defined(__GNUC__) && defined(HAVE_BUILTIN_CTZL) && ((__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__) \
-        || defined(__LITTLE_ENDIAN__))
-#    define std3_longest_match
-#  elif(defined(_MSC_VER) && defined(_WIN32))
-#    define std3_longest_match
-#  else
-#    define std2_longest_match
-#  endif
-
-#else
-#  define std1_longest_match
-#endif
-
-
-#if defined(_MSC_VER) && !defined(__clang__)
-#include <intrin.h>
-/* This is not a general purpose replacement for __builtin_ctzl. The function expects that value is != 0
- * Because of that assumption trailing_zero is not initialized and the return value of _BitScanForward is not checked
- */
-static __forceinline unsigned long __builtin_ctzl(unsigned long value)
-{
-	unsigned long trailing_zero;
-	_BitScanForward(&trailing_zero, value);
-	return trailing_zero;
-}
-#endif
-
-
-
-#ifdef std1_longest_match
-
-/*
- * Standard longest_match
- *
- */
-ZLIB_INTERNAL unsigned longest_match(deflate_state *const s, IPos cur_match) {
-    const unsigned wmask = s->w_mask;
-    const Pos *prev = s->prev;
-
-    unsigned chain_length;
-    IPos limit;
-    unsigned int len, best_len, nice_match;
-    unsigned char *scan, *match, *strend, scan_end, scan_end1;
-
-    /*
-     * The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple
-     * of 16. It is easy to get rid of this optimization if necessary.
-     */
-    Assert(s->hash_bits >= 8 && MAX_MATCH == 258, "Code too clever");
-
-    /*
-     * Do not waste too much time if we already have a good match
-     */
-    best_len = s->prev_length;
-    chain_length = s->max_chain_length;
-    if (best_len >= s->good_match)
-        chain_length >>= 2;
-
-    /*
-     * Do not looks for matches beyond the end of the input. This is
-     * necessary to make deflate deterministic
-     */
-    nice_match = (unsigned int)s->nice_match > s->lookahead ? s->lookahead : s->nice_match;
-
-    /*
-     * Stop when cur_match becomes <= limit. To simplify the code,
-     * we prevent matches with the string of window index 0
-     */
-    limit = s->strstart > MAX_DIST(s) ? s->strstart - MAX_DIST(s) : 0;
-
-    scan = s->window + s->strstart;
-    strend = s->window + s->strstart + MAX_MATCH;
-    scan_end1 = scan[best_len-1];
-    scan_end = scan[best_len];
-
-    Assert((unsigned long)s->strstart <= s->window_size - MIN_LOOKAHEAD, "need lookahead");
-    do {
-        Assert(cur_match < s->strstart, "no future");
-        match = s->window + cur_match;
-
-        /*
-         * Skip to next match if the match length cannot increase
-         * or if the match length is less than 2. Note that the checks
-         * below for insufficient lookahead only occur occasionally
-         * for performance reasons. Therefore uninitialized memory
-         * will be accessed and conditional jumps will be made that
-         * depend on those values. However the length of the match
-         * is limited to the lookahead, so the output of deflate is not
-         * affected by the uninitialized values.
-         */
-        if (match[best_len] != scan_end ||
-            match[best_len-1] != scan_end1 ||
-            *match != *scan ||
-            *++match != scan[1])
-            continue;
-
-        /*
-         * The check at best_len-1 can be removed because it will
-         * be made again later. (This heuristic is not always a win.)
-         * It is not necessary to compare scan[2] and match[2] since
-         * they are always equal when the other bytes match, given
-         * that the hash keys are equal and that HASH_BITS >= 8.
-         */
-        scan += 2;
-        match++;
-        Assert(*scan == *match, "match[2]?");
-
-        /*
-         * We check for insufficient lookahead only every 8th
-         * comparision; the 256th check will be made at strstart + 258.
-         */
-        do {
-        } while (*++scan == *++match && *++scan == *++match &&
-             *++scan == *++match && *++scan == *++match &&
-             *++scan == *++match && *++scan == *++match &&
-             *++scan == *++match && *++scan == *++match &&
-             scan < strend);
-
-        Assert(scan <= s->window+(unsigned int)(s->window_size-1), "wild scan");
-
-        len = MAX_MATCH - (int)(strend - scan);
-        scan = strend - MAX_MATCH;
-
-        if (len > best_len) {
-            s->match_start = cur_match;
-            best_len = len;
-            if (len >= nice_match)
-                break;
-            scan_end1 = scan[best_len-1];
-            scan_end = scan[best_len];
-        } else {
-            /*
-             * The probability of finding a match later if we here
-             * is pretty low, so for performance it's best to
-             * outright stop here for the lower compression levels
-             */
-            if (s->level < 6)
-                break;
-        }
-    } while ((cur_match = prev[cur_match & wmask]) > limit && --chain_length);
-
-    if ((unsigned int)best_len <= s->lookahead)
-        return best_len;
-    return s->lookahead;
-}
-#endif
-
-#ifdef std2_longest_match
-/*
- * UNALIGNED_OK longest_match
- *
- */
-ZLIB_INTERNAL unsigned longest_match(deflate_state *const s, IPos cur_match) {
-    const unsigned wmask = s->w_mask;
-    const Pos *prev = s->prev;
-
-    uint16_t scan_start, scan_end;
-    unsigned chain_length;
-    IPos limit;
-    unsigned int len, best_len, nice_match;
-    unsigned char *scan, *strend;
-
-    /*
-     * The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple
-     * of 16. It is easy to get rid of this optimization if necessary.
-     */
-    Assert(s->hash_bits >= 8 && MAX_MATCH == 258, "Code too clever");
-
-    /*
-     * Do not waste too much time if we already have a good match
-     */
-    best_len = s->prev_length;
-    chain_length = s->max_chain_length;
-    if (best_len >= s->good_match)
-        chain_length >>= 2;
-
-    /*
-     * Do not looks for matches beyond the end of the input. This is
-     * necessary to make deflate deterministic
-     */
-    nice_match = (unsigned int)s->nice_match > s->lookahead ? s->lookahead : s->nice_match;
-
-    /*
-     * Stop when cur_match becomes <= limit. To simplify the code,
-     * we prevent matches with the string of window index 0
-     */
-    limit = s->strstart > MAX_DIST(s) ? s->strstart - MAX_DIST(s) : 0;
-
-    scan = s->window + s->strstart;
-    strend = s->window + s->strstart + MAX_MATCH - 1;
-    scan_start = *(uint16_t *)scan;
-    scan_end = *(uint16_t *)(scan + best_len-1);
-
-    Assert((unsigned long)s->strstart <= s->window_size - MIN_LOOKAHEAD, "need lookahead");
-    do {
-        unsigned char *match;
-        Assert(cur_match < s->strstart, "no future");
-        match = s->window + cur_match;
-
-        /*
-         * Skip to next match if the match length cannot increase
-         * or if the match length is less than 2. Note that the checks
-         * below for insufficient lookahead only occur occasionally
-         * for performance reasons. Therefore uninitialized memory
-         * will be accessed and conditional jumps will be made that
-         * depend on those values. However the length of the match
-         * is limited to the lookahead, so the output of deflate is not
-         * affected by the uninitialized values.
-         */
-        if (likely((*(uint16_t *)(match + best_len - 1) != scan_end)))
-            continue;
-        if (*(uint16_t *)match != scan_start)
-            continue;
-
-        /* It is not necessary to compare scan[2] and match[2] since
-         * they are always equal when the other bytes match, given that
-         * the hash keys are equal and that HASH_BITS >= 8. Compare 2
-         * bytes at a time at strstart+3, +5, ... up to strstart+257.
-         * We check for insufficient lookahead only every 4th
-         * comparison; the 128th check will be made at strstart+257.
-         * If MAX_MATCH-2 is not a multiple of 8, it is necessary to
-         * put more guard bytes at the end of the window, or to check
-         * more often for insufficient lookahead.
-         */
-        Assert(scan[2] == match[2], "scan[2]?");
-        scan++;
-        match++;
-
-        do {
-        } while (*(uint16_t *)(scan += 2)== *(uint16_t *)(match += 2) &&
-                 *(uint16_t *)(scan += 2)== *(uint16_t *)(match += 2) &&
-                 *(uint16_t *)(scan += 2)== *(uint16_t *)(match += 2) &&
-                 *(uint16_t *)(scan += 2)== *(uint16_t *)(match += 2) &&
-                 scan < strend);
-
-        /*
-         * Here, scan <= window + strstart + 257
-         */
-        Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan");
-        if (*scan == *match)
-            scan++;
-
-        len = (MAX_MATCH -1) - (int)(strend-scan);
-        scan = strend - (MAX_MATCH-1);
-
-        if (len > best_len) {
-            s->match_start = cur_match;
-            best_len = len;
-            if (len >= nice_match)
-                break;
-            scan_end = *(uint16_t *)(scan + best_len - 1);
-        } else {
-            /*
-             * The probability of finding a match later if we here
-             * is pretty low, so for performance it's best to
-             * outright stop here for the lower compression levels
-             */
-            if (s->level < 6)
-                break;
-        }
-    } while (--chain_length && (cur_match = prev[cur_match & wmask]) > limit);
-
-    if ((unsigned)best_len <= s->lookahead)
-        return best_len;
-    return s->lookahead;
-}
-#endif
-
-#ifdef std3_longest_match
-/* longest_match() with minor change to improve performance (in terms of
- * execution time).
- *
- * The pristine longest_match() function is sketched bellow (strip the
- * then-clause of the "#ifdef UNALIGNED_OK"-directive)
- *
- * ------------------------------------------------------------
- * unsigned int longest_match(...) {
- *    ...
- *    do {
- *        match = s->window + cur_match;                //s0
- *        if (*(ushf*)(match+best_len-1) != scan_end || //s1
- *            *(ushf*)match != scan_start) continue;    //s2
- *        ...
- *
- *        do {
- *        } while (*(ushf*)(scan+=2) == *(ushf*)(match+=2) &&
- *                 *(ushf*)(scan+=2) == *(ushf*)(match+=2) &&
- *                 *(ushf*)(scan+=2) == *(ushf*)(match+=2) &&
- *                 *(ushf*)(scan+=2) == *(ushf*)(match+=2) &&
- *                 scan < strend); //s3
- *
- *        ...
- *    } while(cond); //s4
- *
- * -------------------------------------------------------------
- *
- * The change include:
- *
- *  1) The hottest statements of the function is: s0, s1 and s4. Pull them
- *     together to form a new loop. The benefit is two-fold:
- *
- *    o. Ease the compiler to yield good code layout: the conditional-branch
- *       corresponding to s1 and its biased target s4 become very close (likely,
- *       fit in the same cache-line), hence improving instruction-fetching
- *       efficiency.
- *
- *    o. Ease the compiler to promote "s->window" into register. "s->window"
- *       is loop-invariant; it is supposed to be promoted into register and keep
- *       the value throughout the entire loop. However, there are many such
- *       loop-invariant, and x86-family has small register file; "s->window" is
- *       likely to be chosen as register-allocation victim such that its value
- *       is reloaded from memory in every single iteration. By forming a new loop,
- *       "s->window" is loop-invariant of that newly created tight loop. It is
- *       lot easier for compiler to promote this quantity to register and keep
- *       its value throughout the entire small loop.
- *
- * 2) Transfrom s3 such that it examines sizeof(long)-byte-match at a time.
- *    This is done by:
- *        ------------------------------------------------
- *        v1 = load from "scan" by sizeof(long) bytes
- *        v2 = load from "match" by sizeof(lnog) bytes
- *        v3 = v1 xor v2
- *        match-bit = little-endian-machine(yes-for-x86) ?
- *                     count-trailing-zero(v3) :
- *                     count-leading-zero(v3);
- *
- *        match-byte = match-bit/8
- *
- *        "scan" and "match" advance if necessary
- *       -------------------------------------------------
- */
-
-ZLIB_INTERNAL unsigned longest_match(deflate_state *const s, IPos cur_match) {
-    unsigned chain_length = s->max_chain_length;/* max hash chain length */
-    register unsigned char *scan = s->window + s->strstart; /* current string */
-    register unsigned char *match;                       /* matched string */
-    register unsigned int len;                  /* length of current match */
-    unsigned int best_len = s->prev_length;     /* best match length so far */
-    unsigned int nice_match = s->nice_match;    /* stop if match long enough */
-    IPos limit = s->strstart > (IPos)MAX_DIST(s) ?
-        s->strstart - (IPos)MAX_DIST(s) : NIL;
-    /* Stop when cur_match becomes <= limit. To simplify the code,
-     * we prevent matches with the string of window index 0.
-     */
-    Pos *prev = s->prev;
-    unsigned int wmask = s->w_mask;
-
-    register unsigned char *strend = s->window + s->strstart + MAX_MATCH;
-    register uint16_t scan_start = *(uint16_t*)scan;
-    register uint16_t scan_end   = *(uint16_t*)(scan+best_len-1);
-
-    /* The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16.
-     * It is easy to get rid of this optimization if necessary.
-     */
-    Assert(s->hash_bits >= 8 && MAX_MATCH == 258, "Code too clever");
-
-    /* Do not waste too much time if we already have a good match: */
-    if (s->prev_length >= s->good_match) {
-        chain_length >>= 2;
-    }
-    /* Do not look for matches beyond the end of the input. This is necessary
-     * to make deflate deterministic.
-     */
-    if ((unsigned int)nice_match > s->lookahead) nice_match = s->lookahead;
-
-    Assert((unsigned long)s->strstart <= s->window_size-MIN_LOOKAHEAD, "need lookahead");
-
-    do {
-        Assert(cur_match < s->strstart, "no future");
-
-        /* Skip to next match if the match length cannot increase
-         * or if the match length is less than 2.  Note that the checks below
-         * for insufficient lookahead only occur occasionally for performance
-         * reasons.  Therefore uninitialized memory will be accessed, and
-         * conditional jumps will be made that depend on those values.
-         * However the length of the match is limited to the lookahead, so
-         * the output of deflate is not affected by the uninitialized values.
-         */
-        unsigned char *win = s->window;
-        int cont = 1;
-        do {
-            match = win + cur_match;
-            if (likely(*(uint16_t*)(match+best_len-1) != scan_end)) {
-                if ((cur_match = prev[cur_match & wmask]) > limit
-                    && --chain_length != 0) {
-                    continue;
-                } else {
-                    cont = 0;
-                }
-            }
-            break;
-        } while (1);
-
-        if (!cont)
-            break;
-
-        if (*(uint16_t*)match != scan_start)
-            continue;
-
-        /* It is not necessary to compare scan[2] and match[2] since they are
-         * always equal when the other bytes match, given that the hash keys
-         * are equal and that HASH_BITS >= 8. Compare 2 bytes at a time at
-         * strstart+3, +5, ... up to strstart+257. We check for insufficient
-         * lookahead only every 4th comparison; the 128th check will be made
-         * at strstart+257. If MAX_MATCH-2 is not a multiple of 8, it is
-         * necessary to put more guard bytes at the end of the window, or
-         * to check more often for insufficient lookahead.
-         */
-        scan += 2, match+=2;
-        Assert(*scan == *match, "match[2]?");
-        do {
-            unsigned long sv = *(unsigned long*)(void*)scan;
-            unsigned long mv = *(unsigned long*)(void*)match;
-            unsigned long xor = sv ^ mv;
-            if (xor) {
-                int match_byte = __builtin_ctzl(xor) / 8;
-                scan += match_byte;
-                match += match_byte;
-                break;
-            } else {
-                scan += sizeof(unsigned long);
-                match += sizeof(unsigned long);
-            }
-        } while (scan < strend);
-
-        if (scan > strend)
-            scan = strend;
-
-        Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan");
-
-        len = MAX_MATCH - (int)(strend - scan);
-        scan = strend - MAX_MATCH;
-
-        if (len > best_len) {
-            s->match_start = cur_match;
-            best_len = len;
-            if (len >= nice_match)
-                break;
-            scan_end = *(uint16_t*)(scan+best_len-1);
-        } else {
-            /*
-             * The probability of finding a match later if we here
-             * is pretty low, so for performance it's best to
-             * outright stop here for the lower compression levels
-             */
-            if (s->level < 6)
-                break;
-        }
-    } while ((cur_match = prev[cur_match & wmask]) > limit && --chain_length != 0);
-
-    if ((unsigned int)best_len <= s->lookahead)
-        return (unsigned int)best_len;
-    return s->lookahead;
-}
-#endif
diff --git a/contrib/libzlib-ng/match.h b/contrib/libzlib-ng/match.h
deleted file mode 100644
index 70842019849..00000000000
--- a/contrib/libzlib-ng/match.h
+++ /dev/null
@@ -1,6 +0,0 @@
-#ifndef MATCH_H_
-#define MATCH_H_
-
-unsigned int longest_match  (deflate_state *s, IPos cur_match);
-
-#endif /* MATCH_H_ */
diff --git a/contrib/libzlib-ng/test/.gitignore b/contrib/libzlib-ng/test/.gitignore
deleted file mode 100644
index 2c3af0a08cb..00000000000
--- a/contrib/libzlib-ng/test/.gitignore
+++ /dev/null
@@ -1,2 +0,0 @@
-# ignore Makefiles; they're all automatically generated
-Makefile
diff --git a/contrib/libzlib-ng/test/CVE-2002-0059/test.gz b/contrib/libzlib-ng/test/CVE-2002-0059/test.gz
deleted file mode 100644
index c5c3e184b1a90692f1c2dc729eb106476d231378..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 4610
zcmb2|=3oE==C>CV8G$T;1@EN)&o6EfRlAUMpn;K@jYq;DVU#f%2%{-sG#8BKg3(+s
vnhQpA!DucR%>|>mU^Ewu=7P~&Fq#WSbHQjX7-G5L2b<CF3!9}G83Y&rX%qj?

diff --git a/contrib/libzlib-ng/test/CVE-2003-0107.c b/contrib/libzlib-ng/test/CVE-2003-0107.c
deleted file mode 100644
index 306421e9fbd..00000000000
--- a/contrib/libzlib-ng/test/CVE-2003-0107.c
+++ /dev/null
@@ -1,20 +0,0 @@
-// http://www.securityfocus.com/archive/1/312869 --- originally by Richard Kettlewell
-#include <stdlib.h>
-#include <zlib.h>
-#include <errno.h>
-#include <stdio.h>
-
-int main(void) {
-gzFile f;
-int ret;
-
-if(!(f = gzopen("/dev/null", "w"))) {
-perror("/dev/null");
-exit(1);
-}
-ret = gzprintf(f, "%10240s", "");
-printf("gzprintf -> %d\n", ret);
-ret = gzclose(f);
-printf("gzclose -> %d [%d]\n", ret, errno);
-exit(0);
-}
diff --git a/contrib/libzlib-ng/test/CVE-2004-0797/test.gz b/contrib/libzlib-ng/test/CVE-2004-0797/test.gz
deleted file mode 100644
index 62dcf34bddbfe2c2e861c7929c21dc2f731dd000..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 52
ocmb2|=3oE==C>CV85!7kBn%P`G%zxAfEl}iz!@q6kpjs906!lM=l}o!

diff --git a/contrib/libzlib-ng/test/CVE-2005-1849/test.gz b/contrib/libzlib-ng/test/CVE-2005-1849/test.gz
deleted file mode 100644
index b28f278263c0a3154faeb3c3dd7b083a3a593c8d..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 52
kcmb2|=3oE==C@ZA85!7kBn%P`G%zxAz!-252m>Ss01LtkQvd(}

diff --git a/contrib/libzlib-ng/test/CVE-2005-2096/test.gz b/contrib/libzlib-ng/test/CVE-2005-2096/test.gz
deleted file mode 100644
index 11590aeab9ac844087776ab66eb2f5d2c9f6d013..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 52
pcmb2|=3oE==C>CV84oltGP4!m+X<o@cq9xG4m7YqD4;l;0RU#i4Wj@6

diff --git a/contrib/libzlib-ng/test/INDEX b/contrib/libzlib-ng/test/INDEX
deleted file mode 100644
index f167df87e13..00000000000
--- a/contrib/libzlib-ng/test/INDEX
+++ /dev/null
@@ -1,10 +0,0 @@
-Makefile.in: template for Unix Makefile
-
-CVE-2003-0107.c:
-CVE-2002-0059  :
-CVE-2004-0797  :
-CVE-2005-1849  :
-CVE-2005-2096  : test cases for the relevant CVEs
-
-testCVEinputs.sh: script to run tests for CVEs where input data is supplied
-
diff --git a/contrib/libzlib-ng/test/Makefile.in b/contrib/libzlib-ng/test/Makefile.in
deleted file mode 100644
index 1fd8c00de63..00000000000
--- a/contrib/libzlib-ng/test/Makefile.in
+++ /dev/null
@@ -1,77 +0,0 @@
-# Copyright (C) 1995-2013 Jean-loup Gailly and Mark Adler
-# Copyright 2015, Daniel Axtens, IBM Corporation
-# zlib license, see zlib.h
-
-CC=
-CFLAGS=
-EXE=
-SRCDIR=
-SRCTOP=
-INCLUDES=
-TEST_LDFLAGS=-L.. ../libz.a
-
-COMPATTESTS =
-
-all: oldtests cvetests $(COMPATTESTS)
-
-oldtests: #set by ../configure
-
-teststatic:
-	@TMPST=tmpst_$$; \
-	if echo hello world | ../minigzip | ../minigzip -d && ../example $$TMPST ; then \
-	  echo '		*** zlib test OK ***'; \
-	else \
-	  echo '		*** zlib test FAILED ***'; exit 1; \
-	fi; \
-	rm -f $$TMPST
-
-testshared:
-	@LD_LIBRARY_PATH=`pwd`/..:$(LD_LIBRARY_PATH) ; export LD_LIBRARY_PATH; \
-	LD_LIBRARYN32_PATH=`pwd`/..:$(LD_LIBRARYN32_PATH) ; export LD_LIBRARYN32_PATH; \
-	DYLD_LIBRARY_PATH=`pwd`/..:$(DYLD_LIBRARY_PATH) ; export DYLD_LIBRARY_PATH; \
-	SHLIB_PATH=`pwd`/..:$(SHLIB_PATH) ; export SHLIB_PATH; \
-	TMPSH=tmpsh_$$; \
-	if echo hello world | ../minigzipsh | ../minigzipsh -d && ../examplesh $$TMPSH; then \
-	  echo '		*** zlib shared test OK ***'; \
-	else \
-	  echo '		*** zlib shared test FAILED ***'; exit 1; \
-	fi; \
-	rm -f $$TMPSH
-
-test64:
-	@TMP64=tmp64_$$; \
-	if echo hello world | ../minigzip64 | ../minigzip64 -d && ../example64 $$TMP64; then \
-	  echo '		*** zlib 64-bit test OK ***'; \
-	else \
-	  echo '		*** zlib 64-bit test FAILED ***'; exit 1; \
-	fi; \
-	rm -f $$TMP64
-
-cvetests: testCVEinputs
-
-# Tests requiring zlib-ng to be built with --zlib-compat
-compattests: testCVE-2003-0107
-
-testCVEinputs:
-	@$(SRCDIR)/testCVEinputs.sh
-
-testCVE-2003-0107: CVE-2003-0107$(EXE)
-	@if ./CVE-2003-0107$(EXE); then \
-	  echo '                *** zlib not vulnerable to CVE-2003-0107 ***'; \
-	else \
-	  echo '                *** zlib VULNERABLE to CVE-2003-0107 ***'; exit 1; \
-	fi
-
-CVE-2003-0107.o: $(SRCDIR)/CVE-2003-0107.c
-	$(CC) $(CFLAGS) -I.. -I$(SRCTOP) -c -o $@ $(SRCDIR)/CVE-2003-0107.c
-
-CVE-2003-0107$(EXE): CVE-2003-0107.o
-	$(CC) $(CFLAGS) -o $@ CVE-2003-0107.o $(TEST_LDFLAGS)
-
-
-clean:
-	rm -f *.o *.gcda *.gcno *.gcov
-	rm -f CVE-2003-0107$(EXE)
-
-distclean:
-	rm -f Makefile
diff --git a/contrib/libzlib-ng/test/example.c b/contrib/libzlib-ng/test/example.c
deleted file mode 100644
index 43d1a16cbe0..00000000000
--- a/contrib/libzlib-ng/test/example.c
+++ /dev/null
@@ -1,544 +0,0 @@
-/* example.c -- usage example of the zlib compression library
- * Copyright (C) 1995-2006, 2011 Jean-loup Gailly.
- * For conditions of distribution and use, see copyright notice in zlib.h
- */
-
-/* @(#) $Id$ */
-
-#include "zlib.h"
-#include <stdio.h>
-
-#include <string.h>
-#include <stdlib.h>
-#include <inttypes.h>
-
-#define TESTFILE "foo.gz"
-
-#define CHECK_ERR(err, msg) { \
-    if (err != Z_OK) { \
-        fprintf(stderr, "%s error: %d\n", msg, err); \
-        exit(1); \
-    } \
-}
-
-const char hello[] = "hello, hello!";
-/* "hello world" would be more standard, but the repeated "hello"
- * stresses the compression code better, sorry...
- */
-
-const char dictionary[] = "hello";
-unsigned long dictId; /* Adler32 value of the dictionary */
-
-void test_deflate       (unsigned char *compr, size_t comprLen);
-void test_inflate       (unsigned char *compr, size_t comprLen, unsigned char *uncompr, size_t uncomprLen);
-void test_large_deflate (unsigned char *compr, size_t comprLen, unsigned char *uncompr, size_t uncomprLen);
-void test_large_inflate (unsigned char *compr, size_t comprLen, unsigned char *uncompr, size_t uncomprLen);
-void test_flush         (unsigned char *compr, size_t *comprLen);
-void test_sync          (unsigned char *compr, size_t comprLen, unsigned char *uncompr, size_t uncomprLen);
-void test_dict_deflate  (unsigned char *compr, size_t comprLen);
-void test_dict_inflate  (unsigned char *compr, size_t comprLen, unsigned char *uncompr, size_t uncomprLen);
-int  main               (int argc, char *argv[]);
-
-
-static alloc_func zalloc = (alloc_func)0;
-static free_func zfree = (free_func)0;
-
-void test_compress      (unsigned char *compr, size_t comprLen,
-                            unsigned char *uncompr, size_t uncomprLen);
-
-/* ===========================================================================
- * Test compress() and uncompress()
- */
-void test_compress(unsigned char *compr, size_t comprLen, unsigned char *uncompr, size_t uncomprLen)
-{
-    int err;
-    size_t len = strlen(hello)+1;
-
-    err = compress(compr, &comprLen, (const unsigned char*)hello, len);
-    CHECK_ERR(err, "compress");
-
-    strcpy((char*)uncompr, "garbage");
-
-    err = uncompress(uncompr, &uncomprLen, compr, comprLen);
-    CHECK_ERR(err, "uncompress");
-
-    if (strcmp((char*)uncompr, hello)) {
-        fprintf(stderr, "bad uncompress\n");
-        exit(1);
-    } else {
-        printf("uncompress(): %s\n", (char *)uncompr);
-    }
-}
-
-#ifdef WITH_GZFILEOP
-void test_gzio          (const char *fname,
-                            unsigned char *uncompr, unsigned long uncomprLen);
-
-/* ===========================================================================
- * Test read/write of .gz files
- */
-void test_gzio(const char *fname, unsigned char *uncompr, unsigned long uncomprLen)
-{
-#ifdef NO_GZCOMPRESS
-    fprintf(stderr, "NO_GZCOMPRESS -- gz* functions cannot compress\n");
-#else
-    int err;
-    int len = (int)strlen(hello)+1;
-    gzFile file;
-    z_off_t pos;
-
-    file = gzopen(fname, "wb");
-    if (file == NULL) {
-        fprintf(stderr, "gzopen error\n");
-        exit(1);
-    }
-    gzputc(file, 'h');
-    if (gzputs(file, "ello") != 4) {
-        fprintf(stderr, "gzputs err: %s\n", gzerror(file, &err));
-        exit(1);
-    }
-    if (gzprintf(file, ", %s!", "hello") != 8) {
-        fprintf(stderr, "gzprintf err: %s\n", gzerror(file, &err));
-        exit(1);
-    }
-    gzseek(file, 1L, SEEK_CUR); /* add one zero byte */
-    gzclose(file);
-
-    file = gzopen(fname, "rb");
-    if (file == NULL) {
-        fprintf(stderr, "gzopen error\n");
-        exit(1);
-    }
-    strcpy((char*)uncompr, "garbage");
-
-    if (gzread(file, uncompr, (unsigned)uncomprLen) != len) {
-        fprintf(stderr, "gzread err: %s\n", gzerror(file, &err));
-        exit(1);
-    }
-    if (strcmp((char*)uncompr, hello)) {
-        fprintf(stderr, "bad gzread: %s\n", (char*)uncompr);
-        exit(1);
-    } else {
-        printf("gzread(): %s\n", (char*)uncompr);
-    }
-
-    pos = gzseek(file, -8L, SEEK_CUR);
-    if (pos != 6 || gztell(file) != pos) {
-        fprintf(stderr, "gzseek error, pos=%ld, gztell=%ld\n",
-                (long)pos, (long)gztell(file));
-        exit(1);
-    }
-
-    if (gzgetc(file) != ' ') {
-        fprintf(stderr, "gzgetc error\n");
-        exit(1);
-    }
-
-    if (gzungetc(' ', file) != ' ') {
-        fprintf(stderr, "gzungetc error\n");
-        exit(1);
-    }
-
-    gzgets(file, (char*)uncompr, (int)uncomprLen);
-    if (strlen((char*)uncompr) != 7) { /* " hello!" */
-        fprintf(stderr, "gzgets err after gzseek: %s\n", gzerror(file, &err));
-        exit(1);
-    }
-    if (strcmp((char*)uncompr, hello + 6)) {
-        fprintf(stderr, "bad gzgets after gzseek\n");
-        exit(1);
-    } else {
-        printf("gzgets() after gzseek: %s\n", (char*)uncompr);
-    }
-
-    gzclose(file);
-#endif
-}
-
-#endif /* WITH_GZFILEOP */
-
-/* ===========================================================================
- * Test deflate() with small buffers
- */
-void test_deflate(unsigned char *compr, size_t comprLen)
-{
-    z_stream c_stream; /* compression stream */
-    int err;
-    unsigned long len = (unsigned long)strlen(hello)+1;
-
-    c_stream.zalloc = zalloc;
-    c_stream.zfree = zfree;
-    c_stream.opaque = (void *)0;
-
-    err = deflateInit(&c_stream, Z_DEFAULT_COMPRESSION);
-    CHECK_ERR(err, "deflateInit");
-
-    c_stream.next_in  = (const unsigned char *)hello;
-    c_stream.next_out = compr;
-
-    while (c_stream.total_in != len && c_stream.total_out < comprLen) {
-        c_stream.avail_in = c_stream.avail_out = 1; /* force small buffers */
-        err = deflate(&c_stream, Z_NO_FLUSH);
-        CHECK_ERR(err, "deflate");
-    }
-    /* Finish the stream, still forcing small buffers: */
-    for (;;) {
-        c_stream.avail_out = 1;
-        err = deflate(&c_stream, Z_FINISH);
-        if (err == Z_STREAM_END) break;
-        CHECK_ERR(err, "deflate");
-    }
-
-    err = deflateEnd(&c_stream);
-    CHECK_ERR(err, "deflateEnd");
-}
-
-/* ===========================================================================
- * Test inflate() with small buffers
- */
-void test_inflate(unsigned char *compr, size_t comprLen, unsigned char *uncompr, size_t uncomprLen)
-{
-    int err;
-    z_stream d_stream; /* decompression stream */
-
-    strcpy((char*)uncompr, "garbage");
-
-    d_stream.zalloc = zalloc;
-    d_stream.zfree = zfree;
-    d_stream.opaque = (void *)0;
-
-    d_stream.next_in  = compr;
-    d_stream.avail_in = 0;
-    d_stream.next_out = uncompr;
-
-    err = inflateInit(&d_stream);
-    CHECK_ERR(err, "inflateInit");
-
-    while (d_stream.total_out < uncomprLen && d_stream.total_in < comprLen) {
-        d_stream.avail_in = d_stream.avail_out = 1; /* force small buffers */
-        err = inflate(&d_stream, Z_NO_FLUSH);
-        if (err == Z_STREAM_END) break;
-        CHECK_ERR(err, "inflate");
-    }
-
-    err = inflateEnd(&d_stream);
-    CHECK_ERR(err, "inflateEnd");
-
-    if (strcmp((char*)uncompr, hello)) {
-        fprintf(stderr, "bad inflate\n");
-        exit(1);
-    } else {
-        printf("inflate(): %s\n", (char *)uncompr);
-    }
-}
-
-/* ===========================================================================
- * Test deflate() with large buffers and dynamic change of compression level
- */
-void test_large_deflate(unsigned char *compr, size_t comprLen, unsigned char *uncompr, size_t uncomprLen)
-{
-    z_stream c_stream; /* compression stream */
-    int err;
-
-    c_stream.zalloc = zalloc;
-    c_stream.zfree = zfree;
-    c_stream.opaque = (void *)0;
-
-    err = deflateInit(&c_stream, Z_BEST_SPEED);
-    CHECK_ERR(err, "deflateInit");
-
-    c_stream.next_out = compr;
-    c_stream.avail_out = (unsigned int)comprLen;
-
-    /* At this point, uncompr is still mostly zeroes, so it should compress
-     * very well:
-     */
-    c_stream.next_in = uncompr;
-    c_stream.avail_in = (unsigned int)uncomprLen;
-    err = deflate(&c_stream, Z_NO_FLUSH);
-    CHECK_ERR(err, "deflate");
-    if (c_stream.avail_in != 0) {
-        fprintf(stderr, "deflate not greedy\n");
-        exit(1);
-    }
-
-    /* Feed in already compressed data and switch to no compression: */
-    deflateParams(&c_stream, Z_NO_COMPRESSION, Z_DEFAULT_STRATEGY);
-    c_stream.next_in = compr;
-    c_stream.avail_in = (unsigned int)comprLen/2;
-    err = deflate(&c_stream, Z_NO_FLUSH);
-    CHECK_ERR(err, "deflate");
-
-    /* Switch back to compressing mode: */
-    deflateParams(&c_stream, Z_BEST_COMPRESSION, Z_FILTERED);
-    c_stream.next_in = uncompr;
-    c_stream.avail_in = (unsigned int)uncomprLen;
-    err = deflate(&c_stream, Z_NO_FLUSH);
-    CHECK_ERR(err, "deflate");
-
-    err = deflate(&c_stream, Z_FINISH);
-    if (err != Z_STREAM_END) {
-        fprintf(stderr, "deflate should report Z_STREAM_END\n");
-        exit(1);
-    }
-    err = deflateEnd(&c_stream);
-    CHECK_ERR(err, "deflateEnd");
-}
-
-/* ===========================================================================
- * Test inflate() with large buffers
- */
-void test_large_inflate(unsigned char *compr, size_t comprLen, unsigned char *uncompr, size_t uncomprLen)
-{
-    int err;
-    z_stream d_stream; /* decompression stream */
-
-    strcpy((char*)uncompr, "garbage");
-
-    d_stream.zalloc = zalloc;
-    d_stream.zfree = zfree;
-    d_stream.opaque = (void *)0;
-
-    d_stream.next_in  = compr;
-    d_stream.avail_in = (unsigned int)comprLen;
-
-    err = inflateInit(&d_stream);
-    CHECK_ERR(err, "inflateInit");
-
-    for (;;) {
-        d_stream.next_out = uncompr;            /* discard the output */
-        d_stream.avail_out = (unsigned int)uncomprLen;
-        err = inflate(&d_stream, Z_NO_FLUSH);
-        if (err == Z_STREAM_END) break;
-        CHECK_ERR(err, "large inflate");
-    }
-
-    err = inflateEnd(&d_stream);
-    CHECK_ERR(err, "inflateEnd");
-
-    if (d_stream.total_out != 2*uncomprLen + comprLen/2) {
-        fprintf(stderr, "bad large inflate: %zu\n", d_stream.total_out);
-        exit(1);
-    } else {
-        printf("large_inflate(): OK\n");
-    }
-}
-
-/* ===========================================================================
- * Test deflate() with full flush
- */
-void test_flush(unsigned char *compr, size_t *comprLen)
-{
-    z_stream c_stream; /* compression stream */
-    int err;
-    unsigned int len = (unsigned int)strlen(hello)+1;
-
-    c_stream.zalloc = zalloc;
-    c_stream.zfree = zfree;
-    c_stream.opaque = (void *)0;
-
-    err = deflateInit(&c_stream, Z_DEFAULT_COMPRESSION);
-    CHECK_ERR(err, "deflateInit");
-
-    c_stream.next_in  = (const unsigned char *)hello;
-    c_stream.next_out = compr;
-    c_stream.avail_in = 3;
-    c_stream.avail_out = (unsigned int)*comprLen;
-    err = deflate(&c_stream, Z_FULL_FLUSH);
-    CHECK_ERR(err, "deflate");
-
-    compr[3]++; /* force an error in first compressed block */
-    c_stream.avail_in = len - 3;
-
-    err = deflate(&c_stream, Z_FINISH);
-    if (err != Z_STREAM_END) {
-        CHECK_ERR(err, "deflate");
-    }
-    err = deflateEnd(&c_stream);
-    CHECK_ERR(err, "deflateEnd");
-
-    *comprLen = c_stream.total_out;
-}
-
-/* ===========================================================================
- * Test inflateSync()
- */
-void test_sync(unsigned char *compr, size_t comprLen, unsigned char *uncompr, size_t uncomprLen)
-{
-    int err;
-    z_stream d_stream; /* decompression stream */
-
-    strcpy((char*)uncompr, "garbage");
-
-    d_stream.zalloc = zalloc;
-    d_stream.zfree = zfree;
-    d_stream.opaque = (void *)0;
-
-    d_stream.next_in  = compr;
-    d_stream.avail_in = 2; /* just read the zlib header */
-
-    err = inflateInit(&d_stream);
-    CHECK_ERR(err, "inflateInit");
-
-    d_stream.next_out = uncompr;
-    d_stream.avail_out = (unsigned int)uncomprLen;
-
-    err = inflate(&d_stream, Z_NO_FLUSH);
-    CHECK_ERR(err, "inflate");
-
-    d_stream.avail_in = (unsigned int)comprLen-2;   /* read all compressed data */
-    err = inflateSync(&d_stream);           /* but skip the damaged part */
-    CHECK_ERR(err, "inflateSync");
-
-    err = inflate(&d_stream, Z_FINISH);
-    if (err != Z_DATA_ERROR) {
-        fprintf(stderr, "inflate should report DATA_ERROR\n");
-        /* Because of incorrect adler32 */
-        exit(1);
-    }
-    err = inflateEnd(&d_stream);
-    CHECK_ERR(err, "inflateEnd");
-
-    printf("after inflateSync(): hel%s\n", (char *)uncompr);
-}
-
-/* ===========================================================================
- * Test deflate() with preset dictionary
- */
-void test_dict_deflate(unsigned char *compr, size_t comprLen)
-{
-    z_stream c_stream; /* compression stream */
-    int err;
-
-    c_stream.zalloc = zalloc;
-    c_stream.zfree = zfree;
-    c_stream.opaque = (void *)0;
-
-    err = deflateInit(&c_stream, Z_BEST_COMPRESSION);
-    CHECK_ERR(err, "deflateInit");
-
-    err = deflateSetDictionary(&c_stream,
-                (const unsigned char*)dictionary, (int)sizeof(dictionary));
-    CHECK_ERR(err, "deflateSetDictionary");
-
-    dictId = c_stream.adler;
-    c_stream.next_out = compr;
-    c_stream.avail_out = (unsigned int)comprLen;
-
-    c_stream.next_in = (const unsigned char *)hello;
-    c_stream.avail_in = (unsigned int)strlen(hello)+1;
-
-    err = deflate(&c_stream, Z_FINISH);
-    if (err != Z_STREAM_END) {
-        fprintf(stderr, "deflate should report Z_STREAM_END\n");
-        exit(1);
-    }
-    err = deflateEnd(&c_stream);
-    CHECK_ERR(err, "deflateEnd");
-}
-
-/* ===========================================================================
- * Test inflate() with a preset dictionary
- */
-void test_dict_inflate(unsigned char *compr, size_t comprLen, unsigned char *uncompr, size_t uncomprLen)
-{
-    int err;
-    z_stream d_stream; /* decompression stream */
-
-    strcpy((char*)uncompr, "garbage");
-
-    d_stream.zalloc = zalloc;
-    d_stream.zfree = zfree;
-    d_stream.opaque = (void *)0;
-
-    d_stream.next_in  = compr;
-    d_stream.avail_in = (unsigned int)comprLen;
-
-    err = inflateInit(&d_stream);
-    CHECK_ERR(err, "inflateInit");
-
-    d_stream.next_out = uncompr;
-    d_stream.avail_out = (unsigned int)uncomprLen;
-
-    for (;;) {
-        err = inflate(&d_stream, Z_NO_FLUSH);
-        if (err == Z_STREAM_END) break;
-        if (err == Z_NEED_DICT) {
-            if (d_stream.adler != dictId) {
-                fprintf(stderr, "unexpected dictionary");
-                exit(1);
-            }
-            err = inflateSetDictionary(&d_stream, (const unsigned char*)dictionary,
-                                       (int)sizeof(dictionary));
-        }
-        CHECK_ERR(err, "inflate with dict");
-    }
-
-    err = inflateEnd(&d_stream);
-    CHECK_ERR(err, "inflateEnd");
-
-    if (strcmp((char*)uncompr, hello)) {
-        fprintf(stderr, "bad inflate with dict\n");
-        exit(1);
-    } else {
-        printf("inflate with dictionary: %s\n", (char *)uncompr);
-    }
-}
-
-/* ===========================================================================
- * Usage:  example [output.gz  [input.gz]]
- */
-
-int main(int argc, char *argv[])
-{
-    unsigned char *compr, *uncompr;
-    size_t comprLen = 10000*sizeof(int); /* don't overflow on MSDOS */
-    size_t uncomprLen = comprLen;
-    static const char* myVersion = ZLIB_VERSION;
-
-    if (zlibVersion()[0] != myVersion[0]) {
-        fprintf(stderr, "incompatible zlib version\n");
-        exit(1);
-
-    } else if (strcmp(zlibVersion(), ZLIB_VERSION) != 0) {
-        fprintf(stderr, "warning: different zlib version\n");
-    }
-
-    printf("zlib version %s = 0x%04x, compile flags = 0x%lx\n",
-            ZLIB_VERSION, ZLIB_VERNUM, zlibCompileFlags());
-
-    compr    = (unsigned char*)calloc((unsigned int)comprLen, 1);
-    uncompr  = (unsigned char*)calloc((unsigned int)uncomprLen, 1);
-    /* compr and uncompr are cleared to avoid reading uninitialized
-     * data and to ensure that uncompr compresses well.
-     */
-    if (compr == Z_NULL || uncompr == Z_NULL) {
-        printf("out of memory\n");
-        exit(1);
-    }
-
-    test_compress(compr, comprLen, uncompr, uncomprLen);
-
-#ifdef WITH_GZFILEOP
-    test_gzio((argc > 1 ? argv[1] : TESTFILE),
-              uncompr, uncomprLen);
-#endif
-
-    test_deflate(compr, comprLen);
-    test_inflate(compr, comprLen, uncompr, uncomprLen);
-
-    test_large_deflate(compr, comprLen, uncompr, uncomprLen);
-    test_large_inflate(compr, comprLen, uncompr, uncomprLen);
-
-    test_flush(compr, &comprLen);
-    test_sync(compr, comprLen, uncompr, uncomprLen);
-    comprLen = uncomprLen;
-
-    test_dict_deflate(compr, comprLen);
-    test_dict_inflate(compr, comprLen, uncompr, uncomprLen);
-
-    free(compr);
-    free(uncompr);
-
-    return 0;
-}
diff --git a/contrib/libzlib-ng/test/infcover.c b/contrib/libzlib-ng/test/infcover.c
deleted file mode 100644
index 5555a155fc3..00000000000
--- a/contrib/libzlib-ng/test/infcover.c
+++ /dev/null
@@ -1,668 +0,0 @@
-/* infcover.c -- test zlib's inflate routines with full code coverage
- * Copyright (C) 2011 Mark Adler
- * For conditions of distribution and use, see copyright notice in zlib.h
- */
-
-/* to use, do: ./configure --cover && make cover */
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <assert.h>
-#include "zlib.h"
-
-/* get definition of internal structure so we can mess with it (see pull()),
-   and so we can call inflate_trees() (see cover5()) */
-#define ZLIB_INTERNAL
-#include "inftrees.h"
-#include "inflate.h"
-
-/* -- memory tracking routines -- */
-
-/*
-   These memory tracking routines are provided to zlib and track all of zlib's
-   allocations and deallocations, check for LIFO operations, keep a current
-   and high water mark of total bytes requested, optionally set a limit on the
-   total memory that can be allocated, and when done check for memory leaks.
-
-   They are used as follows:
-
-   z_stream strm;
-   mem_setup(&strm)         initializes the memory tracking and sets the
-                            zalloc, zfree, and opaque members of strm to use
-                            memory tracking for all zlib operations on strm
-   mem_limit(&strm, limit)  sets a limit on the total bytes requested -- a
-                            request that exceeds this limit will result in an
-                            allocation failure (returns NULL) -- setting the
-                            limit to zero means no limit, which is the default
-                            after mem_setup()
-   mem_used(&strm, "msg")   prints to stderr "msg" and the total bytes used
-   mem_high(&strm, "msg")   prints to stderr "msg" and the high water mark
-   mem_done(&strm, "msg")   ends memory tracking, releases all allocations
-                            for the tracking as well as leaked zlib blocks, if
-                            any.  If there was anything unusual, such as leaked
-                            blocks, non-FIFO frees, or frees of addresses not
-                            allocated, then "msg" and information about the
-                            problem is printed to stderr.  If everything is
-                            normal, nothing is printed. mem_done resets the
-                            strm members to Z_NULL to use the default memory
-                            allocation routines on the next zlib initialization
-                            using strm.
- */
-
-/* these items are strung together in a linked list, one for each allocation */
-struct mem_item {
-    void *ptr;                  /* pointer to allocated memory */
-    size_t size;                /* requested size of allocation */
-    struct mem_item *next;      /* pointer to next item in list, or NULL */
-};
-
-/* this structure is at the root of the linked list, and tracks statistics */
-struct mem_zone {
-    struct mem_item *first;     /* pointer to first item in list, or NULL */
-    size_t total, highwater;    /* total allocations, and largest total */
-    size_t limit;               /* memory allocation limit, or 0 if no limit */
-    int notlifo, rogue;         /* counts of non-LIFO frees and rogue frees */
-};
-
-/* memory allocation routine to pass to zlib */
-static void *mem_alloc(void *mem, unsigned count, unsigned size)
-{
-    void *ptr;
-    struct mem_item *item;
-    struct mem_zone *zone = mem;
-    size_t len = count * (size_t)size;
-
-    /* induced allocation failure */
-    if (zone == NULL || (zone->limit && zone->total + len > zone->limit))
-        return NULL;
-
-    /* perform allocation using the standard library, fill memory with a
-       non-zero value to make sure that the code isn't depending on zeros */
-    ptr = malloc(len);
-    if (ptr == NULL)
-        return NULL;
-    memset(ptr, 0xa5, len);
-
-    /* create a new item for the list */
-    item = malloc(sizeof(struct mem_item));
-    if (item == NULL) {
-        free(ptr);
-        return NULL;
-    }
-    item->ptr = ptr;
-    item->size = len;
-
-    /* insert item at the beginning of the list */
-    item->next = zone->first;
-    zone->first = item;
-
-    /* update the statistics */
-    zone->total += item->size;
-    if (zone->total > zone->highwater)
-        zone->highwater = zone->total;
-
-    /* return the allocated memory */
-    return ptr;
-}
-
-/* memory free routine to pass to zlib */
-static void mem_free(void *mem, void *ptr)
-{
-    struct mem_item *item, *next;
-    struct mem_zone *zone = mem;
-
-    /* if no zone, just do a free */
-    if (zone == NULL) {
-        free(ptr);
-        return;
-    }
-
-    /* point next to the item that matches ptr, or NULL if not found -- remove
-       the item from the linked list if found */
-    next = zone->first;
-    if (next) {
-        if (next->ptr == ptr)
-            zone->first = next->next;   /* first one is it, remove from list */
-        else {
-            do {                        /* search the linked list */
-                item = next;
-                next = item->next;
-            } while (next != NULL && next->ptr != ptr);
-            if (next) {                 /* if found, remove from linked list */
-                item->next = next->next;
-                zone->notlifo++;        /* not a LIFO free */
-            }
-
-        }
-    }
-
-    /* if found, update the statistics and free the item */
-    if (next) {
-        zone->total -= next->size;
-        free(next);
-    }
-
-    /* if not found, update the rogue count */
-    else
-        zone->rogue++;
-
-    /* in any case, do the requested free with the standard library function */
-    free(ptr);
-}
-
-/* set up a controlled memory allocation space for monitoring, set the stream
-   parameters to the controlled routines, with opaque pointing to the space */
-static void mem_setup(z_stream *strm)
-{
-    struct mem_zone *zone;
-
-    zone = malloc(sizeof(struct mem_zone));
-    assert(zone != NULL);
-    zone->first = NULL;
-    zone->total = 0;
-    zone->highwater = 0;
-    zone->limit = 0;
-    zone->notlifo = 0;
-    zone->rogue = 0;
-    strm->opaque = zone;
-    strm->zalloc = mem_alloc;
-    strm->zfree = mem_free;
-}
-
-/* set a limit on the total memory allocation, or 0 to remove the limit */
-static void mem_limit(z_stream *strm, size_t limit)
-{
-    struct mem_zone *zone = strm->opaque;
-
-    zone->limit = limit;
-}
-
-/* show the current total requested allocations in bytes */
-static void mem_used(z_stream *strm, char *prefix)
-{
-    struct mem_zone *zone = strm->opaque;
-
-    fprintf(stderr, "%s: %zu allocated\n", prefix, zone->total);
-}
-
-/* show the high water allocation in bytes */
-static void mem_high(z_stream *strm, char *prefix)
-{
-    struct mem_zone *zone = strm->opaque;
-
-    fprintf(stderr, "%s: %zu high water mark\n", prefix, zone->highwater);
-}
-
-/* release the memory allocation zone -- if there are any surprises, notify */
-static void mem_done(z_stream *strm, char *prefix)
-{
-    int count = 0;
-    struct mem_item *item, *next;
-    struct mem_zone *zone = strm->opaque;
-
-    /* show high water mark */
-    mem_high(strm, prefix);
-
-    /* free leftover allocations and item structures, if any */
-    item = zone->first;
-    while (item != NULL) {
-        free(item->ptr);
-        next = item->next;
-        free(item);
-        item = next;
-        count++;
-    }
-
-    /* issue alerts about anything unexpected */
-    if (count || zone->total)
-        fprintf(stderr, "** %s: %zu bytes in %d blocks not freed\n",
-                prefix, zone->total, count);
-    if (zone->notlifo)
-        fprintf(stderr, "** %s: %d frees not LIFO\n", prefix, zone->notlifo);
-    if (zone->rogue)
-        fprintf(stderr, "** %s: %d frees not recognized\n",
-                prefix, zone->rogue);
-
-    /* free the zone and delete from the stream */
-    free(zone);
-    strm->opaque = Z_NULL;
-    strm->zalloc = Z_NULL;
-    strm->zfree = Z_NULL;
-}
-
-/* -- inflate test routines -- */
-
-/* Decode a hexadecimal string, set *len to length, in[] to the bytes.  This
-   decodes liberally, in that hex digits can be adjacent, in which case two in
-   a row writes a byte.  Or they can be delimited by any non-hex character,
-   where the delimiters are ignored except when a single hex digit is followed
-   by a delimiter, where that single digit writes a byte.  The returned data is
-   allocated and must eventually be freed.  NULL is returned if out of memory.
-   If the length is not needed, then len can be NULL. */
-static unsigned char *h2b(const char *hex, unsigned *len)
-{
-    unsigned char *in, *re;
-    unsigned next, val;
-
-    in = malloc((strlen(hex) + 1) >> 1);
-    if (in == NULL)
-        return NULL;
-    next = 0;
-    val = 1;
-    do {
-        if (*hex >= '0' && *hex <= '9')
-            val = (val << 4) + *hex - '0';
-        else if (*hex >= 'A' && *hex <= 'F')
-            val = (val << 4) + *hex - 'A' + 10;
-        else if (*hex >= 'a' && *hex <= 'f')
-            val = (val << 4) + *hex - 'a' + 10;
-        else if (val != 1 && val < 32)  /* one digit followed by delimiter */
-            val += 240;                 /* make it look like two digits */
-        if (val > 255) {                /* have two digits */
-            in[next++] = val & 0xff;    /* save the decoded byte */
-            val = 1;                    /* start over */
-        }
-    } while (*hex++);       /* go through the loop with the terminating null */
-    if (len != NULL)
-        *len = next;
-    re = realloc(in, next);
-    return re == NULL ? in : re;
-}
-
-/* generic inflate() run, where hex is the hexadecimal input data, what is the
-   text to include in an error message, step is how much input data to feed
-   inflate() on each call, or zero to feed it all, win is the window bits
-   parameter to inflateInit2(), len is the size of the output buffer, and err
-   is the error code expected from the first inflate() call (the second
-   inflate() call is expected to return Z_STREAM_END).  If win is 47, then
-   header information is collected with inflateGetHeader().  If a zlib stream
-   is looking for a dictionary, then an empty dictionary is provided.
-   inflate() is run until all of the input data is consumed. */
-static void inf(char *hex, char *what, unsigned step, int win, unsigned len, int err)
-{
-    int ret;
-    unsigned have;
-    unsigned char *in, *out;
-    z_stream strm, copy;
-    gz_header head;
-
-    mem_setup(&strm);
-    strm.avail_in = 0;
-    strm.next_in = Z_NULL;
-    ret = inflateInit2(&strm, win);
-    if (ret != Z_OK) {
-        mem_done(&strm, what);
-        return;
-    }
-    out = malloc(len);                          assert(out != NULL);
-    if (win == 47) {
-        head.extra = out;
-        head.extra_max = len;
-        head.name = out;
-        head.name_max = len;
-        head.comment = out;
-        head.comm_max = len;
-        ret = inflateGetHeader(&strm, &head);   assert(ret == Z_OK);
-    }
-    in = h2b(hex, &have);                       assert(in != NULL);
-    if (step == 0 || step > have)
-        step = have;
-    strm.avail_in = step;
-    have -= step;
-    strm.next_in = in;
-    do {
-        strm.avail_out = len;
-        strm.next_out = out;
-        ret = inflate(&strm, Z_NO_FLUSH);       assert(err == 9 || ret == err);
-        if (ret != Z_OK && ret != Z_BUF_ERROR && ret != Z_NEED_DICT)
-            break;
-        if (ret == Z_NEED_DICT) {
-            ret = inflateSetDictionary(&strm, in, 1);
-                                                assert(ret == Z_DATA_ERROR);
-            mem_limit(&strm, 1);
-            ret = inflateSetDictionary(&strm, out, 0);
-                                                assert(ret == Z_MEM_ERROR);
-            mem_limit(&strm, 0);
-            ((struct inflate_state *)strm.state)->mode = DICT;
-            ret = inflateSetDictionary(&strm, out, 0);
-                                                assert(ret == Z_OK);
-            ret = inflate(&strm, Z_NO_FLUSH);   assert(ret == Z_BUF_ERROR);
-        }
-        ret = inflateCopy(&copy, &strm);        assert(ret == Z_OK);
-        ret = inflateEnd(&copy);                assert(ret == Z_OK);
-        err = 9;                        /* don't care next time around */
-        have += strm.avail_in;
-        strm.avail_in = step > have ? have : step;
-        have -= strm.avail_in;
-    } while (strm.avail_in);
-    free(in);
-    free(out);
-    ret = inflateReset2(&strm, -8);             assert(ret == Z_OK);
-    ret = inflateEnd(&strm);                    assert(ret == Z_OK);
-    mem_done(&strm, what);
-}
-
-/* cover all of the lines in inflate.c up to inflate() */
-static void cover_support(void)
-{
-    int ret;
-    z_stream strm;
-
-    mem_setup(&strm);
-    strm.avail_in = 0;
-    strm.next_in = Z_NULL;
-    ret = inflateInit(&strm);                   assert(ret == Z_OK);
-    mem_used(&strm, "inflate init");
-    ret = inflatePrime(&strm, 5, 31);           assert(ret == Z_OK);
-    ret = inflatePrime(&strm, -1, 0);           assert(ret == Z_OK);
-    ret = inflateSetDictionary(&strm, Z_NULL, 0);
-                                                assert(ret == Z_STREAM_ERROR);
-    ret = inflateEnd(&strm);                    assert(ret == Z_OK);
-    mem_done(&strm, "prime");
-
-    inf("63 0", "force window allocation", 0, -15, 1, Z_OK);
-    inf("63 18 5", "force window replacement", 0, -8, 259, Z_OK);
-    inf("63 18 68 30 d0 0 0", "force split window update", 4, -8, 259, Z_OK);
-    inf("3 0", "use fixed blocks", 0, -15, 1, Z_STREAM_END);
-    inf("", "bad window size", 0, 1, 0, Z_STREAM_ERROR);
-
-    mem_setup(&strm);
-    strm.avail_in = 0;
-    strm.next_in = Z_NULL;
-    ret = inflateInit_(&strm, ZLIB_VERSION + 1, (int)sizeof(z_stream));
-                                                assert(ret == Z_VERSION_ERROR);
-    mem_done(&strm, "wrong version");
-
-    strm.avail_in = 0;
-    strm.next_in = Z_NULL;
-    ret = inflateInit(&strm);                   assert(ret == Z_OK);
-    ret = inflateEnd(&strm);                    assert(ret == Z_OK);
-    fputs("inflate built-in memory routines\n", stderr);
-}
-
-/* cover all inflate() header and trailer cases and code after inflate() */
-static void cover_wrap(void)
-{
-    int ret;
-    z_stream strm, copy;
-    unsigned char dict[257];
-
-    ret = inflate(Z_NULL, 0);                   assert(ret == Z_STREAM_ERROR);
-    ret = inflateEnd(Z_NULL);                   assert(ret == Z_STREAM_ERROR);
-    ret = inflateCopy(Z_NULL, Z_NULL);          assert(ret == Z_STREAM_ERROR);
-    fputs("inflate bad parameters\n", stderr);
-
-    inf("1f 8b 0 0", "bad gzip method", 0, 31, 0, Z_DATA_ERROR);
-    inf("1f 8b 8 80", "bad gzip flags", 0, 31, 0, Z_DATA_ERROR);
-    inf("77 85", "bad zlib method", 0, 15, 0, Z_DATA_ERROR);
-    inf("8 99", "set window size from header", 0, 0, 0, Z_OK);
-    inf("78 9c", "bad zlib window size", 0, 8, 0, Z_DATA_ERROR);
-    inf("78 9c 63 0 0 0 1 0 1", "check adler32", 0, 15, 1, Z_STREAM_END);
-    inf("1f 8b 8 1e 0 0 0 0 0 0 1 0 0 0 0 0 0", "bad header crc", 0, 47, 1,
-        Z_DATA_ERROR);
-    inf("1f 8b 8 2 0 0 0 0 0 0 1d 26 3 0 0 0 0 0 0 0 0 0", "check gzip length",
-        0, 47, 0, Z_STREAM_END);
-    inf("78 90", "bad zlib header check", 0, 47, 0, Z_DATA_ERROR);
-    inf("8 b8 0 0 0 1", "need dictionary", 0, 8, 0, Z_NEED_DICT);
-    inf("78 9c 63 0", "compute adler32", 0, 15, 1, Z_OK);
-
-    mem_setup(&strm);
-    strm.avail_in = 0;
-    strm.next_in = Z_NULL;
-    ret = inflateInit2(&strm, -8);
-    strm.avail_in = 2;
-    strm.next_in = (void *)"\x63";
-    strm.avail_out = 1;
-    strm.next_out = (void *)&ret;
-    mem_limit(&strm, 1);
-    ret = inflate(&strm, Z_NO_FLUSH);           assert(ret == Z_MEM_ERROR);
-    ret = inflate(&strm, Z_NO_FLUSH);           assert(ret == Z_MEM_ERROR);
-    mem_limit(&strm, 0);
-    memset(dict, 0, 257);
-    ret = inflateSetDictionary(&strm, dict, 257);
-                                                assert(ret == Z_OK);
-    mem_limit(&strm, (sizeof(struct inflate_state) << 1) + 256);
-    ret = inflatePrime(&strm, 16, 0);           assert(ret == Z_OK);
-    strm.avail_in = 2;
-    strm.next_in = (void *)"\x80";
-    ret = inflateSync(&strm);                   assert(ret == Z_DATA_ERROR);
-    ret = inflate(&strm, Z_NO_FLUSH);           assert(ret == Z_STREAM_ERROR);
-    strm.avail_in = 4;
-    strm.next_in = (void *)"\0\0\xff\xff";
-    ret = inflateSync(&strm);                   assert(ret == Z_OK);
-    (void)inflateSyncPoint(&strm);
-    ret = inflateCopy(&copy, &strm);            assert(ret == Z_MEM_ERROR);
-    mem_limit(&strm, 0);
-    ret = inflateUndermine(&strm, 1);           assert(ret == Z_DATA_ERROR);
-    (void)inflateMark(&strm);
-    ret = inflateEnd(&strm);                    assert(ret == Z_OK);
-    mem_done(&strm, "miscellaneous, force memory errors");
-}
-
-/* input and output functions for inflateBack() */
-static unsigned pull(void *desc, const unsigned char **buf)
-{
-    static unsigned int next = 0;
-    static unsigned char dat[] = {0x63, 0, 2, 0};
-    struct inflate_state *state;
-
-    if (desc == Z_NULL) {
-        next = 0;
-        return 0;   /* no input (already provided at next_in) */
-    }
-    state = (void *)((z_stream *)desc)->state;
-    if (state != Z_NULL)
-        state->mode = SYNC;     /* force an otherwise impossible situation */
-    return next < sizeof(dat) ? (*buf = dat + next++, 1) : 0;
-}
-
-static int push(void *desc, unsigned char *buf, unsigned len)
-{
-    buf += len;
-    return desc != Z_NULL;      /* force error if desc not null */
-}
-
-/* cover inflateBack() up to common deflate data cases and after those */
-static void cover_back(void)
-{
-    int ret;
-    z_stream strm;
-    unsigned char win[32768];
-
-    ret = inflateBackInit_(Z_NULL, 0, win, 0, 0);
-                                                assert(ret == Z_VERSION_ERROR);
-    ret = inflateBackInit(Z_NULL, 0, win);      assert(ret == Z_STREAM_ERROR);
-    ret = inflateBack(Z_NULL, Z_NULL, Z_NULL, Z_NULL, Z_NULL);
-                                                assert(ret == Z_STREAM_ERROR);
-    ret = inflateBackEnd(Z_NULL);               assert(ret == Z_STREAM_ERROR);
-    fputs("inflateBack bad parameters\n", stderr);
-
-    mem_setup(&strm);
-    ret = inflateBackInit(&strm, 15, win);      assert(ret == Z_OK);
-    strm.avail_in = 2;
-    strm.next_in = (void *)"\x03";
-    ret = inflateBack(&strm, pull, Z_NULL, push, Z_NULL);
-                                                assert(ret == Z_STREAM_END);
-        /* force output error */
-    strm.avail_in = 3;
-    strm.next_in = (void *)"\x63\x00";
-    ret = inflateBack(&strm, pull, Z_NULL, push, &strm);
-                                                assert(ret == Z_BUF_ERROR);
-        /* force mode error by mucking with state */
-    ret = inflateBack(&strm, pull, &strm, push, Z_NULL);
-                                                assert(ret == Z_STREAM_ERROR);
-    ret = inflateBackEnd(&strm);                assert(ret == Z_OK);
-    mem_done(&strm, "inflateBack bad state");
-
-    ret = inflateBackInit(&strm, 15, win);      assert(ret == Z_OK);
-    ret = inflateBackEnd(&strm);                assert(ret == Z_OK);
-    fputs("inflateBack built-in memory routines\n", stderr);
-}
-
-/* do a raw inflate of data in hexadecimal with both inflate and inflateBack */
-static int try(char *hex, char *id, int err)
-{
-    int ret;
-    unsigned len, size;
-    unsigned char *in, *out, *win;
-    char *prefix;
-    z_stream strm;
-
-    /* convert to hex */
-    in = h2b(hex, &len);
-    assert(in != NULL);
-
-    /* allocate work areas */
-    size = len << 3;
-    out = malloc(size);
-    assert(out != NULL);
-    win = malloc(32768);
-    assert(win != NULL);
-    prefix = malloc(strlen(id) + 6);
-    assert(prefix != NULL);
-
-    /* first with inflate */
-    strcpy(prefix, id);
-    strcat(prefix, "-late");
-    mem_setup(&strm);
-    strm.avail_in = 0;
-    strm.next_in = Z_NULL;
-    ret = inflateInit2(&strm, err < 0 ? 47 : -15);
-    assert(ret == Z_OK);
-    strm.avail_in = len;
-    strm.next_in = in;
-    do {
-        strm.avail_out = size;
-        strm.next_out = out;
-        ret = inflate(&strm, Z_TREES);
-        assert(ret != Z_STREAM_ERROR && ret != Z_MEM_ERROR);
-        if (ret == Z_DATA_ERROR || ret == Z_NEED_DICT)
-            break;
-    } while (strm.avail_in || strm.avail_out == 0);
-    if (err) {
-        assert(ret == Z_DATA_ERROR);
-        assert(strcmp(id, strm.msg) == 0);
-    }
-    inflateEnd(&strm);
-    mem_done(&strm, prefix);
-
-    /* then with inflateBack */
-    if (err >= 0) {
-        strcpy(prefix, id);
-        strcat(prefix, "-back");
-        mem_setup(&strm);
-        ret = inflateBackInit(&strm, 15, win);
-        assert(ret == Z_OK);
-        strm.avail_in = len;
-        strm.next_in = in;
-        ret = inflateBack(&strm, pull, Z_NULL, push, Z_NULL);
-        assert(ret != Z_STREAM_ERROR);
-        if (err) {
-            assert(ret == Z_DATA_ERROR);
-            assert(strcmp(id, strm.msg) == 0);
-        }
-        inflateBackEnd(&strm);
-        mem_done(&strm, prefix);
-    }
-
-    /* clean up */
-    free(prefix);
-    free(win);
-    free(out);
-    free(in);
-    return ret;
-}
-
-/* cover deflate data cases in both inflate() and inflateBack() */
-static void cover_inflate(void)
-{
-    try("0 0 0 0 0", "invalid stored block lengths", 1);
-    try("3 0", "fixed", 0);
-    try("6", "invalid block type", 1);
-    try("1 1 0 fe ff 0", "stored", 0);
-    try("fc 0 0", "too many length or distance symbols", 1);
-    try("4 0 fe ff", "invalid code lengths set", 1);
-    try("4 0 24 49 0", "invalid bit length repeat", 1);
-    try("4 0 24 e9 ff ff", "invalid bit length repeat", 1);
-    try("4 0 24 e9 ff 6d", "invalid code -- missing end-of-block", 1);
-    try("4 80 49 92 24 49 92 24 71 ff ff 93 11 0",
-        "invalid literal/lengths set", 1);
-    try("4 80 49 92 24 49 92 24 f b4 ff ff c3 84", "invalid distances set", 1);
-    try("4 c0 81 8 0 0 0 0 20 7f eb b 0 0", "invalid literal/length code", 1);
-    try("2 7e ff ff", "invalid distance code", 1);
-    try("c c0 81 0 0 0 0 0 90 ff 6b 4 0", "invalid distance too far back", 1);
-
-    /* also trailer mismatch just in inflate() */
-    try("1f 8b 8 0 0 0 0 0 0 0 3 0 0 0 0 1", "incorrect data check", -1);
-    try("1f 8b 8 0 0 0 0 0 0 0 3 0 0 0 0 0 0 0 0 1",
-        "incorrect length check", -1);
-    try("5 c0 21 d 0 0 0 80 b0 fe 6d 2f 91 6c", "pull 17", 0);
-    try("5 e0 81 91 24 cb b2 2c 49 e2 f 2e 8b 9a 47 56 9f fb fe ec d2 ff 1f",
-        "long code", 0);
-    try("ed c0 1 1 0 0 0 40 20 ff 57 1b 42 2c 4f", "length extra", 0);
-    try("ed cf c1 b1 2c 47 10 c4 30 fa 6f 35 1d 1 82 59 3d fb be 2e 2a fc f c",
-        "long distance and extra", 0);
-    try("ed c0 81 0 0 0 0 80 a0 fd a9 17 a9 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 6", "window end", 0);
-    inf("2 8 20 80 0 3 0", "inflate_fast TYPE return", 0, -15, 258,
-        Z_STREAM_END);
-    inf("63 18 5 40 c 0", "window wrap", 3, -8, 300, Z_OK);
-}
-
-/* cover remaining lines in inftrees.c */
-static void cover_trees(void)
-{
-    int ret;
-    unsigned bits;
-    uint16_t lens[16], work[16];
-    code *next, table[ENOUGH_DISTS];
-
-    /* we need to call inflate_table() directly in order to manifest not-
-       enough errors, since zlib insures that enough is always enough */
-    for (bits = 0; bits < 15; bits++)
-        lens[bits] = (uint16_t)(bits + 1);
-    lens[15] = 15;
-    next = table;
-    bits = 15;
-    ret = inflate_table(DISTS, lens, 16, &next, &bits, work);
-                                                assert(ret == 1);
-    next = table;
-    bits = 1;
-    ret = inflate_table(DISTS, lens, 16, &next, &bits, work);
-                                                assert(ret == 1);
-    fputs("inflate_table not enough errors\n", stderr);
-}
-
-/* cover remaining inffast.c decoding and window copying */
-static void cover_fast(void)
-{
-    inf("e5 e0 81 ad 6d cb b2 2c c9 01 1e 59 63 ae 7d ee fb 4d fd b5 35 41 68"
-        " ff 7f 0f 0 0 0", "fast length extra bits", 0, -8, 258, Z_DATA_ERROR);
-    inf("25 fd 81 b5 6d 59 b6 6a 49 ea af 35 6 34 eb 8c b9 f6 b9 1e ef 67 49"
-        " 50 fe ff ff 3f 0 0", "fast distance extra bits", 0, -8, 258,
-        Z_DATA_ERROR);
-    inf("3 7e 0 0 0 0 0", "fast invalid distance code", 0, -8, 258,
-        Z_DATA_ERROR);
-    inf("1b 7 0 0 0 0 0", "fast invalid literal/length code", 0, -8, 258,
-        Z_DATA_ERROR);
-    inf("d c7 1 ae eb 38 c 4 41 a0 87 72 de df fb 1f b8 36 b1 38 5d ff ff 0",
-        "fast 2nd level codes and too far back", 0, -8, 258, Z_DATA_ERROR);
-    inf("63 18 5 8c 10 8 0 0 0 0", "very common case", 0, -8, 259, Z_OK);
-    inf("63 60 60 18 c9 0 8 18 18 18 26 c0 28 0 29 0 0 0",
-        "contiguous and wrap around window", 6, -8, 259, Z_OK);
-    inf("63 0 3 0 0 0 0 0", "copy direct from output", 0, -8, 259,
-        Z_STREAM_END);
-}
-
-int main(void)
-{
-    fprintf(stderr, "%s\n", zlibVersion());
-    cover_support();
-    cover_wrap();
-    cover_back();
-    cover_inflate();
-    cover_trees();
-    cover_fast();
-    return 0;
-}
diff --git a/contrib/libzlib-ng/test/minigzip.c b/contrib/libzlib-ng/test/minigzip.c
deleted file mode 100644
index 9c71fd1b8d5..00000000000
--- a/contrib/libzlib-ng/test/minigzip.c
+++ /dev/null
@@ -1,530 +0,0 @@
-/* minigzip.c -- simulate gzip using the zlib compression library
- * Copyright (C) 1995-2006, 2010, 2011 Jean-loup Gailly.
- * For conditions of distribution and use, see copyright notice in zlib.h
- */
-
-/*
- * minigzip is a minimal implementation of the gzip utility. This is
- * only an example of using zlib and isn't meant to replace the
- * full-featured gzip. No attempt is made to deal with file systems
- * limiting names to 14 or 8+3 characters, etc... Error checking is
- * very limited. So use minigzip only for testing; use gzip for the
- * real thing.
- */
-
-/* @(#) $Id$ */
-
-#include "zlib.h"
-#include <stdio.h>
-
-#include <string.h>
-#include <stdlib.h>
-
-#ifdef USE_MMAP
-#  include <sys/types.h>
-#  include <sys/mman.h>
-#  include <sys/stat.h>
-#endif
-
-#if defined(WIN32) || defined(__CYGWIN__)
-#  include <fcntl.h>
-#  include <io.h>
-#  define SET_BINARY_MODE(file) setmode(fileno(file), O_BINARY)
-#else
-#  define SET_BINARY_MODE(file)
-#endif
-
-#if defined(_MSC_VER) && _MSC_VER < 1900
-#  define snprintf _snprintf
-#endif
-
-#if !defined(Z_HAVE_UNISTD_H) && !defined(_LARGEFILE64_SOURCE)
-#ifndef WIN32 /* unlink already in stdio.h for WIN32 */
-  extern int unlink (const char *);
-#endif
-#endif
-
-#ifndef GZ_SUFFIX
-#  define GZ_SUFFIX ".gz"
-#endif
-#define SUFFIX_LEN (sizeof(GZ_SUFFIX)-1)
-
-#define BUFLEN      16384        /* read buffer size */
-#define BUFLENW     (BUFLEN * 3) /* write buffer size */
-#define MAX_NAME_LEN 1024
-
-#ifndef WITH_GZFILEOP
-/* without WITH_GZFILEOP, create simplified gz* functions using deflate and inflate */
-
-#if defined(Z_HAVE_UNISTD_H) || defined(Z_LARGE)
-#  include <unistd.h>       /* for unlink() */
-#endif
-
-void *myalloc (void *, unsigned, unsigned);
-void myfree (void *, void *);
-
-void *myalloc(void *q, unsigned n, unsigned m)
-{
-    (void)q;
-    return calloc(n, m);
-}
-
-void myfree(void *q, void *p)
-{
-    (void)q;
-    free(p);
-}
-
-typedef struct gzFile_s {
-    FILE *file;
-    int write;
-    int err;
-    const char *msg;
-    z_stream strm;
-    unsigned char *buf;
-} *gzFile;
-
-gzFile gzopen (const char *, const char *);
-gzFile gzdopen (int, const char *);
-gzFile gz_open (const char *, int, const char *);
-
-gzFile gzopen(const char *path, const char *mode)
-{
-    return gz_open(path, -1, mode);
-}
-
-gzFile gzdopen(int fd, const char *mode)
-{
-    return gz_open(NULL, fd, mode);
-}
-
-gzFile gz_open(const char *path, int fd, const char *mode)
-{
-    gzFile gz;
-    int ret;
-    int level = Z_DEFAULT_COMPRESSION;
-    const char *plevel = mode;
-
-    gz = malloc(sizeof(struct gzFile_s));
-    if (gz == NULL)
-        return NULL;
-    gz->write = strchr(mode, 'w') != NULL;
-    gz->strm.zalloc = myalloc;
-    gz->strm.zfree = myfree;
-    gz->strm.opaque = Z_NULL;
-    gz->buf = malloc(gz->write ? BUFLENW : BUFLEN);
-
-    if (gz->buf == NULL) {
-        free(gz);
-        return NULL;
-    }
-
-    while (*plevel) {
-        if (*plevel >= '0' && *plevel <= '9') {
-           level = *plevel - '0';
-           break;
-        }
-        plevel++;
-    }
-    if (gz->write)
-        ret = deflateInit2(&(gz->strm), level, 8, 15 + 16, 8, 0);
-    else {
-        gz->strm.next_in = 0;
-        gz->strm.avail_in = Z_NULL;
-        ret = inflateInit2(&(gz->strm), 15 + 16);
-    }
-    if (ret != Z_OK) {
-        free(gz);
-        return NULL;
-    }
-    gz->file = path == NULL ? fdopen(fd, gz->write ? "wb" : "rb") :
-                              fopen(path, gz->write ? "wb" : "rb");
-    if (gz->file == NULL) {
-        gz->write ? deflateEnd(&(gz->strm)) : inflateEnd(&(gz->strm));
-        free(gz);
-        return NULL;
-    }
-    gz->err = 0;
-    gz->msg = "";
-    return gz;
-}
-
-int gzwrite (gzFile, const void *, unsigned);
-
-int gzwrite(gzFile gz, const void *buf, unsigned len)
-{
-    z_stream *strm;
-
-    if (gz == NULL || !gz->write)
-        return 0;
-    strm = &(gz->strm);
-    strm->next_in = (void *)buf;
-    strm->avail_in = len;
-    do {
-        strm->next_out = gz->buf;
-        strm->avail_out = BUFLENW;
-        (void)deflate(strm, Z_NO_FLUSH);
-        fwrite(gz->buf, 1, BUFLENW - strm->avail_out, gz->file);
-    } while (strm->avail_out == 0);
-    return len;
-}
-
-int gzread (gzFile, void *, unsigned);
-
-int gzread(gzFile gz, void *buf, unsigned len)
-{
-    z_stream *strm;
-
-    if (gz == NULL || gz->write || gz->err)
-        return 0;
-    strm = &(gz->strm);
-    strm->next_out = buf;
-    strm->avail_out = len;
-    do {
-        if (strm->avail_in == 0)
-        {
-            strm->next_in = gz->buf;
-            strm->avail_in = (uint32_t)fread(gz->buf, 1, BUFLEN, gz->file);
-        }
-        if (strm->avail_in > 0)
-        {
-            int ret = inflate(strm, Z_NO_FLUSH);
-            if (ret == Z_DATA_ERROR) {
-                gz->err = ret;
-                gz->msg = strm->msg;
-                return 0;
-            }
-            else if (ret == Z_STREAM_END)
-                inflateReset(strm);
-        }
-        else
-            break;
-    } while (strm->avail_out);
-    return len - strm->avail_out;
-}
-
-int gzclose (gzFile);
-
-int gzclose(gzFile gz)
-{
-    z_stream *strm;
-
-    if (gz == NULL)
-        return Z_STREAM_ERROR;
-    strm = &(gz->strm);
-    if (gz->write) {
-        strm->next_in = Z_NULL;
-        strm->avail_in = 0;
-        do {
-            strm->next_out = gz->buf;
-            strm->avail_out = BUFLENW;
-            (void)deflate(strm, Z_FINISH);
-            fwrite(gz->buf, 1, BUFLENW - strm->avail_out, gz->file);
-        } while (strm->avail_out == 0);
-        deflateEnd(strm);
-    }
-    else
-        inflateEnd(strm);
-    free(gz->buf);
-    fclose(gz->file);
-    free(gz);
-    return Z_OK;
-}
-
-const char *gzerror (gzFile, int *);
-
-const char *gzerror(gzFile gz, int *err)
-{
-    *err = gz->err;
-    return gz->msg;
-}
-
-#endif 
-
-char *prog;
-
-void error            (const char *msg);
-void gz_compress      (FILE   *in, gzFile out);
-#ifdef USE_MMAP
-int  gz_compress_mmap (FILE   *in, gzFile out);
-#endif
-void gz_uncompress    (gzFile in, FILE   *out);
-void file_compress    (char  *file, char *mode);
-void file_uncompress  (char  *file);
-int  main             (int argc, char *argv[]);
-
-/* ===========================================================================
- * Display error message and exit
- */
-void error(const char *msg)
-{
-    fprintf(stderr, "%s: %s\n", prog, msg);
-    exit(1);
-}
-
-/* ===========================================================================
- * Compress input to output then close both files.
- */
-
-void gz_compress(FILE   *in, gzFile out)
-{
-    char buf[BUFLEN];
-    int len;
-    int err;
-
-#ifdef USE_MMAP
-    /* Try first compressing with mmap. If mmap fails (minigzip used in a
-     * pipe), use the normal fread loop.
-     */
-    if (gz_compress_mmap(in, out) == Z_OK) return;
-#endif
-    for (;;) {
-        len = (int)fread(buf, 1, sizeof(buf), in);
-        if (ferror(in)) {
-            perror("fread");
-            exit(1);
-        }
-        if (len == 0) break;
-
-        if (gzwrite(out, buf, (unsigned)len) != len) error(gzerror(out, &err));
-    }
-    fclose(in);
-    if (gzclose(out) != Z_OK) error("failed gzclose");
-}
-
-#ifdef USE_MMAP /* MMAP version, Miguel Albrecht <malbrech@eso.org> */
-
-/* Try compressing the input file at once using mmap. Return Z_OK if
- * if success, Z_ERRNO otherwise.
- */
-int gz_compress_mmap(FILE   *in, gzFile out)
-{
-    int len;
-    int err;
-    int ifd = fileno(in);
-    caddr_t buf;    /* mmap'ed buffer for the entire input file */
-    off_t buf_len;  /* length of the input file */
-    struct stat sb;
-
-    /* Determine the size of the file, needed for mmap: */
-    if (fstat(ifd, &sb) < 0) return Z_ERRNO;
-    buf_len = sb.st_size;
-    if (buf_len <= 0) return Z_ERRNO;
-
-    /* Now do the actual mmap: */
-    buf = mmap((caddr_t) 0, buf_len, PROT_READ, MAP_SHARED, ifd, (off_t)0);
-    if (buf == (caddr_t)(-1)) return Z_ERRNO;
-
-    /* Compress the whole file at once: */
-    len = gzwrite(out, (char *)buf, (unsigned)buf_len);
-
-    if (len != (int)buf_len) error(gzerror(out, &err));
-
-    munmap(buf, buf_len);
-    fclose(in);
-    if (gzclose(out) != Z_OK) error("failed gzclose");
-    return Z_OK;
-}
-#endif /* USE_MMAP */
-
-/* ===========================================================================
- * Uncompress input to output then close both files.
- */
-void gz_uncompress(gzFile in, FILE   *out)
-{
-    char buf[BUFLENW];
-    int len;
-    int err;
-
-    for (;;) {
-        len = gzread(in, buf, sizeof(buf));
-        if (len < 0) error (gzerror(in, &err));
-        if (len == 0) break;
-
-        if ((int)fwrite(buf, 1, (unsigned)len, out) != len) {
-            error("failed fwrite");
-        }
-    }
-    if (fclose(out)) error("failed fclose");
-
-    if (gzclose(in) != Z_OK) error("failed gzclose");
-}
-
-
-/* ===========================================================================
- * Compress the given file: create a corresponding .gz file and remove the
- * original.
- */
-void file_compress(char  *file, char  *mode)
-{
-    char outfile[MAX_NAME_LEN];
-    FILE  *in;
-    gzFile out;
-
-    if (strlen(file) + strlen(GZ_SUFFIX) >= sizeof(outfile)) {
-        fprintf(stderr, "%s: filename too long\n", prog);
-        exit(1);
-    }
-
-    snprintf(outfile, sizeof(outfile), "%s%s", file, GZ_SUFFIX);
-
-    in = fopen(file, "rb");
-    if (in == NULL) {
-        perror(file);
-        exit(1);
-    }
-    out = gzopen(outfile, mode);
-    if (out == NULL) {
-        fprintf(stderr, "%s: can't gzopen %s\n", prog, outfile);
-        exit(1);
-    }
-    gz_compress(in, out);
-
-    unlink(file);
-}
-
-
-/* ===========================================================================
- * Uncompress the given file and remove the original.
- */
-void file_uncompress(char  *file)
-{
-    char buf[MAX_NAME_LEN];
-    char *infile, *outfile;
-    FILE  *out;
-    gzFile in;
-    size_t len = strlen(file);
-
-    if (len + strlen(GZ_SUFFIX) >= sizeof(buf)) {
-        fprintf(stderr, "%s: filename too long\n", prog);
-        exit(1);
-    }
-
-    snprintf(buf, sizeof(buf), "%s", file);
-
-    if (len > SUFFIX_LEN && strcmp(file+len-SUFFIX_LEN, GZ_SUFFIX) == 0) {
-        infile = file;
-        outfile = buf;
-        outfile[len-3] = '\0';
-    } else {
-        outfile = file;
-        infile = buf;
-        snprintf(buf + len, sizeof(buf) - len, "%s", GZ_SUFFIX);
-    }
-    in = gzopen(infile, "rb");
-    if (in == NULL) {
-        fprintf(stderr, "%s: can't gzopen %s\n", prog, infile);
-        exit(1);
-    }
-    out = fopen(outfile, "wb");
-    if (out == NULL) {
-        perror(file);
-        exit(1);
-    }
-
-    gz_uncompress(in, out);
-
-    unlink(infile);
-}
-
-
-/* ===========================================================================
- * Usage:  minigzip [-c] [-d] [-f] [-h] [-r] [-1 to -9] [files...]
- *   -c : write to standard output
- *   -d : decompress
- *   -f : compress with Z_FILTERED
- *   -h : compress with Z_HUFFMAN_ONLY
- *   -r : compress with Z_RLE
- *   -1 to -9 : compression level
- */
-
-int main(int argc, char *argv[])
-{
-    int copyout = 0;
-    int uncompr = 0;
-    gzFile file;
-    char *bname, outmode[20];
-
-    snprintf(outmode, sizeof(outmode), "%s", "wb6 ");
-
-    prog = argv[0];
-    bname = strrchr(argv[0], '/');
-    if (bname)
-      bname++;
-    else
-      bname = argv[0];
-    argc--, argv++;
-
-    if (!strcmp(bname, "gunzip"))
-      uncompr = 1;
-    else if (!strcmp(bname, "zcat"))
-      copyout = uncompr = 1;
-
-    while (argc > 0) {
-      if (strcmp(*argv, "-c") == 0)
-        copyout = 1;
-      else if (strcmp(*argv, "-d") == 0)
-        uncompr = 1;
-      else if (strcmp(*argv, "-f") == 0)
-        outmode[3] = 'f';
-      else if (strcmp(*argv, "-h") == 0)
-        outmode[3] = 'h';
-      else if (strcmp(*argv, "-r") == 0)
-        outmode[3] = 'R';
-      else if ((*argv)[0] == '-' && (*argv)[1] >= '1' && (*argv)[1] <= '9' &&
-               (*argv)[2] == 0)
-        outmode[2] = (*argv)[1];
-      else
-        break;
-      argc--, argv++;
-    }
-    if (outmode[3] == ' ')
-        outmode[3] = 0;
-    if (argc == 0) {
-        SET_BINARY_MODE(stdin);
-        SET_BINARY_MODE(stdout);
-        if (uncompr) {
-            file = gzdopen(fileno(stdin), "rb");
-            if (file == NULL) error("can't gzdopen stdin");
-            gz_uncompress(file, stdout);
-        } else {
-            file = gzdopen(fileno(stdout), outmode);
-            if (file == NULL) error("can't gzdopen stdout");
-            gz_compress(stdin, file);
-        }
-    } else {
-        if (copyout) {
-            SET_BINARY_MODE(stdout);
-        }
-        do {
-            if (uncompr) {
-                if (copyout) {
-                    file = gzopen(*argv, "rb");
-                    if (file == NULL)
-                        fprintf(stderr, "%s: can't gzopen %s\n", prog, *argv);
-                    else
-                        gz_uncompress(file, stdout);
-                } else {
-                    file_uncompress(*argv);
-                }
-            } else {
-                if (copyout) {
-                    FILE * in = fopen(*argv, "rb");
-
-                    if (in == NULL) {
-                        perror(*argv);
-                    } else {
-                        file = gzdopen(fileno(stdout), outmode);
-                        if (file == NULL) error("can't gzdopen stdout");
-
-                        gz_compress(in, file);
-                    }
-
-                } else {
-                    file_compress(*argv, outmode);
-                }
-            }
-        } while (argv++, --argc);
-    }
-    return 0;
-}
diff --git a/contrib/libzlib-ng/test/testCVEinputs.sh b/contrib/libzlib-ng/test/testCVEinputs.sh
deleted file mode 100755
index 046856e7884..00000000000
--- a/contrib/libzlib-ng/test/testCVEinputs.sh
+++ /dev/null
@@ -1,22 +0,0 @@
-#!/bin/bash
-TESTDIR="$(dirname "$0")"
-
-CVEs="CVE-2002-0059 CVE-2004-0797 CVE-2005-1849 CVE-2005-2096"
-
-for CVE in $CVEs; do
-    fail=0
-    for testcase in ${TESTDIR}/${CVE}/*.gz; do
-	../minigzip -d < "$testcase"
-	# we expect that a 1 error code is OK
-	# for a vulnerable failure we'd expect 134 or similar
-	if [ $? -ne 1 ]; then
-	    fail=1
-	fi
-    done
-    if [ $fail -eq 0 ]; then
-	echo "		--- zlib not vulnerable to $CVE ---";
-    else
-	echo "          --- zlib VULNERABLE to $CVE ---"; exit 1;
-    fi
-done
-
diff --git a/contrib/libzlib-ng/treebuild.xml b/contrib/libzlib-ng/treebuild.xml
deleted file mode 100644
index 38d29d75efc..00000000000
--- a/contrib/libzlib-ng/treebuild.xml
+++ /dev/null
@@ -1,116 +0,0 @@
-<?xml version="1.0" ?>
-<package name="zlib" version="1.2.8">
-    <library name="zlib" dlversion="1.2.8" dlname="z">
-	<property name="description"> zip compression library </property>
-	<property name="include-target-dir" value="$(@PACKAGE/install-includedir)" />
-
-	<!-- fixme: not implemented yet -->
-	<property name="compiler/c/inline" value="yes" />
-
-	<include-file name="zlib.h" scope="public" mode="644" />
-	<include-file name="zconf.h" scope="public" mode="644" />
-
-	<source name="adler32.c">
-	    <depend name="zlib.h" />
-	    <depend name="zconf.h" />
-	</source>
-	<source name="compress.c">
-	    <depend name="zlib.h" />
-	    <depend name="zconf.h" />
-	</source>
-	<source name="crc32.c">
-	    <depend name="zlib.h" />
-	    <depend name="zconf.h" />
-	    <depend name="crc32.h" />
-	</source>
-	<source name="gzclose.c">
-	    <depend name="zlib.h" />
-	    <depend name="zconf.h" />
-	    <depend name="gzguts.h" />
-	</source>
-	<source name="gzlib.c">
-	    <depend name="zlib.h" />
-	    <depend name="zconf.h" />
-	    <depend name="gzguts.h" />
-	</source>
-	<source name="gzread.c">
-	    <depend name="zlib.h" />
-	    <depend name="zconf.h" />
-	    <depend name="gzguts.h" />
-	</source>
-	<source name="gzwrite.c">
-	    <depend name="zlib.h" />
-	    <depend name="zconf.h" />
-	    <depend name="gzguts.h" />
-	</source>
-	<source name="uncompr.c">
-	    <depend name="zlib.h" />
-	    <depend name="zconf.h" />
-	</source>
-	<source name="deflate.c">
-	    <depend name="zlib.h" />
-	    <depend name="zconf.h" />
-	    <depend name="zutil.h" />
-	    <depend name="deflate.h" />
-	</source>
-	<source name="trees.c">
-	    <depend name="zlib.h" />
-	    <depend name="zconf.h" />
-	    <depend name="zutil.h" />
-	    <depend name="deflate.h" />
-	    <depend name="trees.h" />
-	</source>
-	<source name="zutil.c">
-	    <depend name="zlib.h" />
-	    <depend name="zconf.h" />
-	    <depend name="zutil.h" />
-	</source>
-	<source name="inflate.c">
-	    <depend name="zlib.h" />
-	    <depend name="zconf.h" />
-	    <depend name="zutil.h" />
-	    <depend name="inftrees.h" />
-	    <depend name="inflate.h" />
-	    <depend name="inffast.h" />
-	</source>
-	<source name="infback.c">
-	    <depend name="zlib.h" />
-	    <depend name="zconf.h" />
-	    <depend name="zutil.h" />
-	    <depend name="inftrees.h" />
-	    <depend name="inflate.h" />
-	    <depend name="inffast.h" />
-	</source>
-	<source name="inftrees.c">
-	    <depend name="zlib.h" />
-	    <depend name="zconf.h" />
-	    <depend name="zutil.h" />
-	    <depend name="inftrees.h" />
-	</source>
-	<source name="inffast.c">
-	    <depend name="zlib.h" />
-	    <depend name="zconf.h" />
-	    <depend name="zutil.h" />
-	    <depend name="inftrees.h" />
-	    <depend name="inflate.h" />
-	    <depend name="inffast.h" />
-	</source>
-    </library>
-</package>
-
-<!--
-CFLAGS=-O
-#CFLAGS=-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7
-#CFLAGS=-g -DDEBUG
-#CFLAGS=-O3 -Wall -Wwrite-strings -Wpointer-arith -Wconversion \
-#           -Wstrict-prototypes -Wmissing-prototypes
-
-# OBJA =
-# to use the asm code: make OBJA=match.o
-#
-match.o: match.S
-	$(CPP) match.S > _match.s
-	$(CC) -c _match.s
-	mv _match.o match.o
-	rm -f _match.s
--->
diff --git a/contrib/libzlib-ng/trees.c b/contrib/libzlib-ng/trees.c
deleted file mode 100644
index ee756fc5a25..00000000000
--- a/contrib/libzlib-ng/trees.c
+++ /dev/null
@@ -1,1119 +0,0 @@
-/* trees.c -- output deflated data using Huffman coding
- * Copyright (C) 1995-2012 Jean-loup Gailly
- * detect_data_type() function provided freely by Cosmin Truta, 2006
- * For conditions of distribution and use, see copyright notice in zlib.h
- */
-
-/*
- *  ALGORITHM
- *
- *      The "deflation" process uses several Huffman trees. The more
- *      common source values are represented by shorter bit sequences.
- *
- *      Each code tree is stored in a compressed form which is itself
- * a Huffman encoding of the lengths of all the code strings (in
- * ascending order by source values).  The actual code strings are
- * reconstructed from the lengths in the inflate process, as described
- * in the deflate specification.
- *
- *  REFERENCES
- *
- *      Deutsch, L.P.,"'Deflate' Compressed Data Format Specification".
- *      Available in ftp.uu.net:/pub/archiving/zip/doc/deflate-1.1.doc
- *
- *      Storer, James A.
- *          Data Compression:  Methods and Theory, pp. 49-50.
- *          Computer Science Press, 1988.  ISBN 0-7167-8156-5.
- *
- *      Sedgewick, R.
- *          Algorithms, p290.
- *          Addison-Wesley, 1983. ISBN 0-201-06672-6.
- */
-
-/* @(#) $Id$ */
-
-/* #define GEN_TREES_H */
-
-#include "deflate.h"
-
-#ifdef DEBUG
-#  include <ctype.h>
-#endif
-
-/* ===========================================================================
- * Constants
- */
-
-#define MAX_BL_BITS 7
-/* Bit length codes must not exceed MAX_BL_BITS bits */
-
-#define REP_3_6      16
-/* repeat previous bit length 3-6 times (2 bits of repeat count) */
-
-#define REPZ_3_10    17
-/* repeat a zero length 3-10 times  (3 bits of repeat count) */
-
-#define REPZ_11_138  18
-/* repeat a zero length 11-138 times  (7 bits of repeat count) */
-
-local const int extra_lbits[LENGTH_CODES] /* extra bits for each length code */
-    = {0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0};
-
-local const int extra_dbits[D_CODES] /* extra bits for each distance code */
-    = {0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13};
-
-local const int extra_blbits[BL_CODES] /* extra bits for each bit length code */
-    = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,3,7};
-
-local const unsigned char bl_order[BL_CODES]
-    = {16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15};
-/* The lengths of the bit length codes are sent in order of decreasing
- * probability, to avoid transmitting the lengths for unused bit length codes.
- */
-
-/* ===========================================================================
- * Local data. These are initialized only once.
- */
-
-#define DIST_CODE_LEN  512 /* see definition of array dist_code below */
-
-#if defined(GEN_TREES_H)
-/* non ANSI compilers may not accept trees.h */
-
-ZLIB_INTERNAL ct_data static_ltree[L_CODES+2];
-/* The static literal tree. Since the bit lengths are imposed, there is no
- * need for the L_CODES extra codes used during heap construction. However
- * The codes 286 and 287 are needed to build a canonical tree (see _tr_init
- * below).
- */
-
-local ct_data static_dtree[D_CODES];
-/* The static distance tree. (Actually a trivial tree since all codes use
- * 5 bits.)
- */
-
-uch _dist_code[DIST_CODE_LEN];
-/* Distance codes. The first 256 values correspond to the distances
- * 3 .. 258, the last 256 values correspond to the top 8 bits of
- * the 15 bit distances.
- */
-
-uch _length_code[MAX_MATCH-MIN_MATCH+1];
-/* length code for each normalized match length (0 == MIN_MATCH) */
-
-local int base_length[LENGTH_CODES];
-/* First normalized length for each code (0 = MIN_MATCH) */
-
-local int base_dist[D_CODES];
-/* First normalized distance for each code (0 = distance of 1) */
-
-#else
-#  include "trees.h"
-#endif /* GEN_TREES_H */
-
-struct static_tree_desc_s {
-    const ct_data *static_tree; /* static tree or NULL */
-    const int     *extra_bits;  /* extra bits for each code or NULL */
-    int            extra_base;  /* base index for extra_bits */
-    int            elems;       /* max number of elements in the tree */
-    unsigned int   max_length;  /* max bit length for the codes */
-};
-
-local const static_tree_desc  static_l_desc =
-{static_ltree, extra_lbits, LITERALS+1, L_CODES, MAX_BITS};
-
-local const static_tree_desc  static_d_desc =
-{static_dtree, extra_dbits, 0,          D_CODES, MAX_BITS};
-
-local const static_tree_desc  static_bl_desc =
-{(const ct_data *)0, extra_blbits, 0,   BL_CODES, MAX_BL_BITS};
-
-/* ===========================================================================
- * Local (static) routines in this file.
- */
-
-local void tr_static_init (void);
-local void init_block     (deflate_state *s);
-local void pqdownheap     (deflate_state *s, ct_data *tree, int k);
-local void gen_bitlen     (deflate_state *s, tree_desc *desc);
-local void gen_codes      (ct_data *tree, int max_code, uint16_t *bl_count);
-local void build_tree     (deflate_state *s, tree_desc *desc);
-local void scan_tree      (deflate_state *s, ct_data *tree, int max_code);
-local void send_tree      (deflate_state *s, ct_data *tree, int max_code);
-local int  build_bl_tree  (deflate_state *s);
-local void send_all_trees (deflate_state *s, int lcodes, int dcodes, int blcodes);
-local void compress_block (deflate_state *s, const ct_data *ltree, const ct_data *dtree);
-local int  detect_data_type (deflate_state *s);
-local unsigned bi_reverse (unsigned value, int length);
-local void bi_flush       (deflate_state *s);
-local void copy_block     (deflate_state *s, char *buf, unsigned len, int header);
-
-#ifdef GEN_TREES_H
-local void gen_trees_header(void);
-#endif
-
-/* ===========================================================================
- * Initialize the various 'constant' tables.
- */
-local void tr_static_init(void) {
-#if defined(GEN_TREES_H)
-    static int static_init_done = 0;
-    int n;        /* iterates over tree elements */
-    int bits;     /* bit counter */
-    int length;   /* length value */
-    int code;     /* code value */
-    int dist;     /* distance index */
-    uint16_t bl_count[MAX_BITS+1];
-    /* number of codes at each bit length for an optimal tree */
-
-    if (static_init_done)
-        return;
-
-    /* For some embedded targets, global variables are not initialized: */
-#ifdef NO_INIT_GLOBAL_POINTERS
-    static_l_desc.static_tree = static_ltree;
-    static_l_desc.extra_bits = extra_lbits;
-    static_d_desc.static_tree = static_dtree;
-    static_d_desc.extra_bits = extra_dbits;
-    static_bl_desc.extra_bits = extra_blbits;
-#endif
-
-    /* Initialize the mapping length (0..255) -> length code (0..28) */
-    length = 0;
-    for (code = 0; code < LENGTH_CODES-1; code++) {
-        base_length[code] = length;
-        for (n = 0; n < (1 << extra_lbits[code]); n++) {
-            _length_code[length++] = (unsigned char)code;
-        }
-    }
-    Assert(length == 256, "tr_static_init: length != 256");
-    /* Note that the length 255 (match length 258) can be represented
-     * in two different ways: code 284 + 5 bits or code 285, so we
-     * overwrite length_code[255] to use the best encoding:
-     */
-    _length_code[length-1] = (unsigned char)code;
-
-    /* Initialize the mapping dist (0..32K) -> dist code (0..29) */
-    dist = 0;
-    for (code = 0 ; code < 16; code++) {
-        base_dist[code] = dist;
-        for (n = 0; n < (1 << extra_dbits[code]); n++) {
-            _dist_code[dist++] = (unsigned char)code;
-        }
-    }
-    Assert(dist == 256, "tr_static_init: dist != 256");
-    dist >>= 7; /* from now on, all distances are divided by 128 */
-    for ( ; code < D_CODES; code++) {
-        base_dist[code] = dist << 7;
-        for (n = 0; n < (1 << (extra_dbits[code]-7)); n++) {
-            _dist_code[256 + dist++] = (unsigned char)code;
-        }
-    }
-    Assert(dist == 256, "tr_static_init: 256+dist != 512");
-
-    /* Construct the codes of the static literal tree */
-    for (bits = 0; bits <= MAX_BITS; bits++)
-        bl_count[bits] = 0;
-    n = 0;
-    while (n <= 143) static_ltree[n++].Len = 8, bl_count[8]++;
-    while (n <= 255) static_ltree[n++].Len = 9, bl_count[9]++;
-    while (n <= 279) static_ltree[n++].Len = 7, bl_count[7]++;
-    while (n <= 287) static_ltree[n++].Len = 8, bl_count[8]++;
-    /* Codes 286 and 287 do not exist, but we must include them in the
-     * tree construction to get a canonical Huffman tree (longest code
-     * all ones)
-     */
-    gen_codes((ct_data *)static_ltree, L_CODES+1, bl_count);
-
-    /* The static distance tree is trivial: */
-    for (n = 0; n < D_CODES; n++) {
-        static_dtree[n].Len = 5;
-        static_dtree[n].Code = bi_reverse((unsigned)n, 5);
-    }
-    static_init_done = 1;
-
-#  ifdef GEN_TREES_H
-    gen_trees_header();
-#  endif
-#endif /* defined(GEN_TREES_H) */
-}
-
-/* ===========================================================================
- * Genererate the file trees.h describing the static trees.
- */
-#ifdef GEN_TREES_H
-#  ifndef DEBUG
-#    include <stdio.h>
-#  endif
-
-#  define SEPARATOR(i, last, width) \
-      ((i) == (last)? "\n};\n\n" :    \
-       ((i) % (width) == (width)-1 ? ",\n" : ", "))
-
-void gen_trees_header() {
-    FILE *header = fopen("trees.h", "w");
-    int i;
-
-    Assert(header != NULL, "Can't open trees.h");
-    fprintf(header, "/* header created automatically with -DGEN_TREES_H */\n\n");
-
-    fprintf(header, "ZLIB_INTERNAL const ct_data static_ltree[L_CODES+2] = {\n");
-    for (i = 0; i < L_CODES+2; i++) {
-        fprintf(header, "{{%3u},{%3u}}%s", static_ltree[i].Code, static_ltree[i].Len, SEPARATOR(i, L_CODES+1, 5));
-    }
-
-    fprintf(header, "local const ct_data static_dtree[D_CODES] = {\n");
-    for (i = 0; i < D_CODES; i++) {
-        fprintf(header, "{{%2u},{%2u}}%s", static_dtree[i].Code, static_dtree[i].Len, SEPARATOR(i, D_CODES-1, 5));
-    }
-
-    fprintf(header, "const unsigned char ZLIB_INTERNAL _dist_code[DIST_CODE_LEN] = {\n");
-    for (i = 0; i < DIST_CODE_LEN; i++) {
-        fprintf(header, "%2u%s", _dist_code[i], SEPARATOR(i, DIST_CODE_LEN-1, 20));
-    }
-
-    fprintf(header, "const unsigned char ZLIB_INTERNAL _length_code[MAX_MATCH-MIN_MATCH+1]= {\n");
-    for (i = 0; i < MAX_MATCH-MIN_MATCH+1; i++) {
-        fprintf(header, "%2u%s", _length_code[i], SEPARATOR(i, MAX_MATCH-MIN_MATCH, 20));
-    }
-
-    fprintf(header, "local const int base_length[LENGTH_CODES] = {\n");
-    for (i = 0; i < LENGTH_CODES; i++) {
-        fprintf(header, "%d%s", base_length[i], SEPARATOR(i, LENGTH_CODES-1, 20));
-    }
-
-    fprintf(header, "local const int base_dist[D_CODES] = {\n");
-    for (i = 0; i < D_CODES; i++) {
-        fprintf(header, "%5d%s", base_dist[i], SEPARATOR(i, D_CODES-1, 10));
-    }
-
-    fclose(header);
-}
-#endif /* GEN_TREES_H */
-
-/* ===========================================================================
- * Initialize the tree data structures for a new zlib stream.
- */
-void ZLIB_INTERNAL _tr_init(deflate_state *s) {
-    tr_static_init();
-
-    s->l_desc.dyn_tree = s->dyn_ltree;
-    s->l_desc.stat_desc = &static_l_desc;
-
-    s->d_desc.dyn_tree = s->dyn_dtree;
-    s->d_desc.stat_desc = &static_d_desc;
-
-    s->bl_desc.dyn_tree = s->bl_tree;
-    s->bl_desc.stat_desc = &static_bl_desc;
-
-    s->bi_buf = 0;
-    s->bi_valid = 0;
-#ifdef DEBUG
-    s->compressed_len = 0L;
-    s->bits_sent = 0L;
-#endif
-
-    /* Initialize the first block of the first file: */
-    init_block(s);
-}
-
-/* ===========================================================================
- * Initialize a new block.
- */
-local void init_block(deflate_state *s) {
-    int n; /* iterates over tree elements */
-
-    /* Initialize the trees. */
-    for (n = 0; n < L_CODES;  n++)
-        s->dyn_ltree[n].Freq = 0;
-    for (n = 0; n < D_CODES;  n++)
-        s->dyn_dtree[n].Freq = 0;
-    for (n = 0; n < BL_CODES; n++)
-        s->bl_tree[n].Freq = 0;
-
-    s->dyn_ltree[END_BLOCK].Freq = 1;
-    s->opt_len = s->static_len = 0L;
-    s->last_lit = s->matches = 0;
-}
-
-#define SMALLEST 1
-/* Index within the heap array of least frequent node in the Huffman tree */
-
-
-/* ===========================================================================
- * Remove the smallest element from the heap and recreate the heap with
- * one less element. Updates heap and heap_len.
- */
-#define pqremove(s, tree, top) \
-{\
-    top = s->heap[SMALLEST]; \
-    s->heap[SMALLEST] = s->heap[s->heap_len--]; \
-    pqdownheap(s, tree, SMALLEST); \
-}
-
-/* ===========================================================================
- * Compares to subtrees, using the tree depth as tie breaker when
- * the subtrees have equal frequency. This minimizes the worst case length.
- */
-#define smaller(tree, n, m, depth) \
-    (tree[n].Freq < tree[m].Freq || \
-    (tree[n].Freq == tree[m].Freq && depth[n] <= depth[m]))
-
-/* ===========================================================================
- * Restore the heap property by moving down the tree starting at node k,
- * exchanging a node with the smallest of its two sons if necessary, stopping
- * when the heap property is re-established (each father smaller than its
- * two sons).
- */
-local void pqdownheap(deflate_state *s, ct_data *tree, int k) {
-    /* tree: the tree to restore */
-    /* k: node to move down */
-    int v = s->heap[k];
-    int j = k << 1;  /* left son of k */
-    while (j <= s->heap_len) {
-        /* Set j to the smallest of the two sons: */
-        if (j < s->heap_len && smaller(tree, s->heap[j+1], s->heap[j], s->depth)) {
-            j++;
-        }
-        /* Exit if v is smaller than both sons */
-        if (smaller(tree, v, s->heap[j], s->depth))
-            break;
-
-        /* Exchange v with the smallest son */
-        s->heap[k] = s->heap[j];
-        k = j;
-
-        /* And continue down the tree, setting j to the left son of k */
-        j <<= 1;
-    }
-    s->heap[k] = v;
-}
-
-/* ===========================================================================
- * Compute the optimal bit lengths for a tree and update the total bit length
- * for the current block.
- * IN assertion: the fields freq and dad are set, heap[heap_max] and
- *    above are the tree nodes sorted by increasing frequency.
- * OUT assertions: the field len is set to the optimal bit length, the
- *     array bl_count contains the frequencies for each bit length.
- *     The length opt_len is updated; static_len is also updated if stree is
- *     not null.
- */
-local void gen_bitlen(deflate_state *s, tree_desc *desc) {
-    /* desc: the tree descriptor */
-    ct_data *tree           = desc->dyn_tree;
-    int max_code            = desc->max_code;
-    const ct_data *stree    = desc->stat_desc->static_tree;
-    const int *extra        = desc->stat_desc->extra_bits;
-    int base                = desc->stat_desc->extra_base;
-    unsigned int max_length = desc->stat_desc->max_length;
-    int h;              /* heap index */
-    int n, m;           /* iterate over the tree elements */
-    unsigned int bits;  /* bit length */
-    int xbits;          /* extra bits */
-    uint16_t f;         /* frequency */
-    int overflow = 0;   /* number of elements with bit length too large */
-
-    for (bits = 0; bits <= MAX_BITS; bits++)
-        s->bl_count[bits] = 0;
-
-    /* In a first pass, compute the optimal bit lengths (which may
-     * overflow in the case of the bit length tree).
-     */
-    tree[s->heap[s->heap_max]].Len = 0; /* root of the heap */
-
-    for (h = s->heap_max+1; h < HEAP_SIZE; h++) {
-        n = s->heap[h];
-        bits = tree[tree[n].Dad].Len + 1;
-        if (bits > max_length)
-            bits = max_length, overflow++;
-        tree[n].Len = (uint16_t)bits;
-        /* We overwrite tree[n].Dad which is no longer needed */
-
-        if (n > max_code) /* not a leaf node */
-            continue;
-
-        s->bl_count[bits]++;
-        xbits = 0;
-        if (n >= base)
-            xbits = extra[n-base];
-        f = tree[n].Freq;
-        s->opt_len += (unsigned long)f * (bits + xbits);
-        if (stree)
-            s->static_len += (unsigned long)f * (stree[n].Len + xbits);
-    }
-    if (overflow == 0)
-        return;
-
-    Trace((stderr, "\nbit length overflow\n"));
-    /* This happens for example on obj2 and pic of the Calgary corpus */
-
-    /* Find the first bit length which could increase: */
-    do {
-        bits = max_length-1;
-        while (s->bl_count[bits] == 0)
-            bits--;
-        s->bl_count[bits]--;      /* move one leaf down the tree */
-        s->bl_count[bits+1] += 2; /* move one overflow item as its brother */
-        s->bl_count[max_length]--;
-        /* The brother of the overflow item also moves one step up,
-         * but this does not affect bl_count[max_length]
-         */
-        overflow -= 2;
-    } while (overflow > 0);
-
-    /* Now recompute all bit lengths, scanning in increasing frequency.
-     * h is still equal to HEAP_SIZE. (It is simpler to reconstruct all
-     * lengths instead of fixing only the wrong ones. This idea is taken
-     * from 'ar' written by Haruhiko Okumura.)
-     */
-    for (bits = max_length; bits != 0; bits--) {
-        n = s->bl_count[bits];
-        while (n != 0) {
-            m = s->heap[--h];
-            if (m > max_code)
-                continue;
-            if (tree[m].Len != bits) {
-                Trace((stderr, "code %d bits %d->%u\n", m, tree[m].Len, bits));
-                s->opt_len += (long)((bits - tree[m].Len) * tree[m].Freq);
-                tree[m].Len = (uint16_t)bits;
-            }
-            n--;
-        }
-    }
-}
-
-/* ===========================================================================
- * Generate the codes for a given tree and bit counts (which need not be
- * optimal).
- * IN assertion: the array bl_count contains the bit length statistics for
- * the given tree and the field len is set for all tree elements.
- * OUT assertion: the field code is set for all tree elements of non
- *     zero code length.
- */
-local void gen_codes(ct_data *tree, int max_code, uint16_t *bl_count) {
-    /* tree: the tree to decorate */
-    /* max_code: largest code with non zero frequency */
-    /* bl_count: number of codes at each bit length */
-    uint16_t next_code[MAX_BITS+1];  /* next code value for each bit length */
-    uint16_t code = 0;               /* running code value */
-    int bits;                        /* bit index */
-    int n;                           /* code index */
-
-    /* The distribution counts are first used to generate the code values
-     * without bit reversal.
-     */
-    for (bits = 1; bits <= MAX_BITS; bits++) {
-        next_code[bits] = code = (code + bl_count[bits-1]) << 1;
-    }
-    /* Check that the bit counts in bl_count are consistent. The last code
-     * must be all ones.
-     */
-    Assert(code + bl_count[MAX_BITS]-1 == (1 << MAX_BITS)-1, "inconsistent bit counts");
-    Tracev((stderr, "\ngen_codes: max_code %d ", max_code));
-
-    for (n = 0;  n <= max_code; n++) {
-        int len = tree[n].Len;
-        if (len == 0)
-            continue;
-        /* Now reverse the bits */
-        tree[n].Code = bi_reverse(next_code[len]++, len);
-
-        Tracecv(tree != static_ltree, (stderr, "\nn %3d %c l %2d c %4x (%x) ",
-             n, (isgraph(n) ? n : ' '), len, tree[n].Code, next_code[len]-1));
-    }
-}
-
-/* ===========================================================================
- * Construct one Huffman tree and assigns the code bit strings and lengths.
- * Update the total bit length for the current block.
- * IN assertion: the field freq is set for all tree elements.
- * OUT assertions: the fields len and code are set to the optimal bit length
- *     and corresponding code. The length opt_len is updated; static_len is
- *     also updated if stree is not null. The field max_code is set.
- */
-local void build_tree(deflate_state *s, tree_desc *desc) {
-    /* desc: the tree descriptor */
-    ct_data *tree         = desc->dyn_tree;
-    const ct_data *stree  = desc->stat_desc->static_tree;
-    int elems             = desc->stat_desc->elems;
-    int n, m;          /* iterate over heap elements */
-    int max_code = -1; /* largest code with non zero frequency */
-    int node;          /* new node being created */
-
-    /* Construct the initial heap, with least frequent element in
-     * heap[SMALLEST]. The sons of heap[n] are heap[2*n] and heap[2*n+1].
-     * heap[0] is not used.
-     */
-    s->heap_len = 0, s->heap_max = HEAP_SIZE;
-
-    for (n = 0; n < elems; n++) {
-        if (tree[n].Freq != 0) {
-            s->heap[++(s->heap_len)] = max_code = n;
-            s->depth[n] = 0;
-        } else {
-            tree[n].Len = 0;
-        }
-    }
-
-    /* The pkzip format requires that at least one distance code exists,
-     * and that at least one bit should be sent even if there is only one
-     * possible code. So to avoid special checks later on we force at least
-     * two codes of non zero frequency.
-     */
-    while (s->heap_len < 2) {
-        node = s->heap[++(s->heap_len)] = (max_code < 2 ? ++max_code : 0);
-        tree[node].Freq = 1;
-        s->depth[node] = 0;
-        s->opt_len--;
-        if (stree)
-            s->static_len -= stree[node].Len;
-        /* node is 0 or 1 so it does not have extra bits */
-    }
-    desc->max_code = max_code;
-
-    /* The elements heap[heap_len/2+1 .. heap_len] are leaves of the tree,
-     * establish sub-heaps of increasing lengths:
-     */
-    for (n = s->heap_len/2; n >= 1; n--)
-        pqdownheap(s, tree, n);
-
-    /* Construct the Huffman tree by repeatedly combining the least two
-     * frequent nodes.
-     */
-    node = elems;              /* next internal node of the tree */
-    do {
-        pqremove(s, tree, n);  /* n = node of least frequency */
-        m = s->heap[SMALLEST]; /* m = node of next least frequency */
-
-        s->heap[--(s->heap_max)] = n; /* keep the nodes sorted by frequency */
-        s->heap[--(s->heap_max)] = m;
-
-        /* Create a new node father of n and m */
-        tree[node].Freq = tree[n].Freq + tree[m].Freq;
-        s->depth[node] = (unsigned char)((s->depth[n] >= s->depth[m] ?
-                                          s->depth[n] : s->depth[m]) + 1);
-        tree[n].Dad = tree[m].Dad = (uint16_t)node;
-#ifdef DUMP_BL_TREE
-        if (tree == s->bl_tree) {
-            fprintf(stderr, "\nnode %d(%d), sons %d(%d) %d(%d)",
-                    node, tree[node].Freq, n, tree[n].Freq, m, tree[m].Freq);
-        }
-#endif
-        /* and insert the new node in the heap */
-        s->heap[SMALLEST] = node++;
-        pqdownheap(s, tree, SMALLEST);
-    } while (s->heap_len >= 2);
-
-    s->heap[--(s->heap_max)] = s->heap[SMALLEST];
-
-    /* At this point, the fields freq and dad are set. We can now
-     * generate the bit lengths.
-     */
-    gen_bitlen(s, (tree_desc *)desc);
-
-    /* The field len is now set, we can generate the bit codes */
-    gen_codes((ct_data *)tree, max_code, s->bl_count);
-}
-
-/* ===========================================================================
- * Scan a literal or distance tree to determine the frequencies of the codes
- * in the bit length tree.
- */
-local void scan_tree(deflate_state *s, ct_data *tree, int max_code) {
-    /* tree: the tree to be scanned */
-    /* max_code: and its largest code of non zero frequency */
-    int n;                     /* iterates over all tree elements */
-    int prevlen = -1;          /* last emitted length */
-    int curlen;                /* length of current code */
-    int nextlen = tree[0].Len; /* length of next code */
-    int count = 0;             /* repeat count of the current code */
-    int max_count = 7;         /* max repeat count */
-    int min_count = 4;         /* min repeat count */
-
-    if (nextlen == 0)
-         max_count = 138, min_count = 3;
-
-    tree[max_code+1].Len = (uint16_t)0xffff; /* guard */
-
-    for (n = 0; n <= max_code; n++) {
-        curlen = nextlen;
-        nextlen = tree[n+1].Len;
-        if (++count < max_count && curlen == nextlen) {
-            continue;
-        } else if (count < min_count) {
-            s->bl_tree[curlen].Freq += count;
-        } else if (curlen != 0) {
-            if (curlen != prevlen)
-                s->bl_tree[curlen].Freq++;
-            s->bl_tree[REP_3_6].Freq++;
-        } else if (count <= 10) {
-            s->bl_tree[REPZ_3_10].Freq++;
-        } else {
-            s->bl_tree[REPZ_11_138].Freq++;
-        }
-        count = 0;
-        prevlen = curlen;
-        if (nextlen == 0) {
-            max_count = 138, min_count = 3;
-        } else if (curlen == nextlen) {
-            max_count = 6, min_count = 3;
-        } else {
-            max_count = 7, min_count = 4;
-        }
-    }
-}
-
-/* ===========================================================================
- * Send a literal or distance tree in compressed form, using the codes in
- * bl_tree.
- */
-local void send_tree(deflate_state *s, ct_data *tree, int max_code) {
-    /* tree: the tree to be scanned */
-    /* max_code and its largest code of non zero frequency */
-    int n;                     /* iterates over all tree elements */
-    int prevlen = -1;          /* last emitted length */
-    int curlen;                /* length of current code */
-    int nextlen = tree[0].Len; /* length of next code */
-    int count = 0;             /* repeat count of the current code */
-    int max_count = 7;         /* max repeat count */
-    int min_count = 4;         /* min repeat count */
-
-    /* tree[max_code+1].Len = -1; */  /* guard already set */
-    if (nextlen == 0)
-        max_count = 138, min_count = 3;
-
-    for (n = 0; n <= max_code; n++) {
-        curlen = nextlen;
-        nextlen = tree[n+1].Len;
-        if (++count < max_count && curlen == nextlen) {
-            continue;
-        } else if (count < min_count) {
-            do {
-                send_code(s, curlen, s->bl_tree);
-            } while (--count != 0);
-
-        } else if (curlen != 0) {
-            if (curlen != prevlen) {
-                send_code(s, curlen, s->bl_tree);
-                count--;
-            }
-            Assert(count >= 3 && count <= 6, " 3_6?");
-            send_code(s, REP_3_6, s->bl_tree);
-            send_bits(s, count-3, 2);
-
-        } else if (count <= 10) {
-            send_code(s, REPZ_3_10, s->bl_tree);
-            send_bits(s, count-3, 3);
-
-        } else {
-            send_code(s, REPZ_11_138, s->bl_tree);
-            send_bits(s, count-11, 7);
-        }
-        count = 0;
-        prevlen = curlen;
-        if (nextlen == 0) {
-            max_count = 138, min_count = 3;
-        } else if (curlen == nextlen) {
-            max_count = 6, min_count = 3;
-        } else {
-            max_count = 7, min_count = 4;
-        }
-    }
-}
-
-/* ===========================================================================
- * Construct the Huffman tree for the bit lengths and return the index in
- * bl_order of the last bit length code to send.
- */
-local int build_bl_tree(deflate_state *s) {
-    int max_blindex;  /* index of last bit length code of non zero freq */
-
-    /* Determine the bit length frequencies for literal and distance trees */
-    scan_tree(s, (ct_data *)s->dyn_ltree, s->l_desc.max_code);
-    scan_tree(s, (ct_data *)s->dyn_dtree, s->d_desc.max_code);
-
-    /* Build the bit length tree: */
-    build_tree(s, (tree_desc *)(&(s->bl_desc)));
-    /* opt_len now includes the length of the tree representations, except
-     * the lengths of the bit lengths codes and the 5+5+4 bits for the counts.
-     */
-
-    /* Determine the number of bit length codes to send. The pkzip format
-     * requires that at least 4 bit length codes be sent. (appnote.txt says
-     * 3 but the actual value used is 4.)
-     */
-    for (max_blindex = BL_CODES-1; max_blindex >= 3; max_blindex--) {
-        if (s->bl_tree[bl_order[max_blindex]].Len != 0)
-            break;
-    }
-    /* Update opt_len to include the bit length tree and counts */
-    s->opt_len += 3*(max_blindex+1) + 5+5+4;
-    Tracev((stderr, "\ndyn trees: dyn %lu, stat %lu", s->opt_len, s->static_len));
-
-    return max_blindex;
-}
-
-/* ===========================================================================
- * Send the header for a block using dynamic Huffman trees: the counts, the
- * lengths of the bit length codes, the literal tree and the distance tree.
- * IN assertion: lcodes >= 257, dcodes >= 1, blcodes >= 4.
- */
-local void send_all_trees(deflate_state *s, int lcodes, int dcodes, int blcodes) {
-    int rank;                    /* index in bl_order */
-
-    Assert(lcodes >= 257 && dcodes >= 1 && blcodes >= 4, "not enough codes");
-    Assert(lcodes <= L_CODES && dcodes <= D_CODES && blcodes <= BL_CODES, "too many codes");
-    Tracev((stderr, "\nbl counts: "));
-    send_bits(s, lcodes-257, 5); /* not +255 as stated in appnote.txt */
-    send_bits(s, dcodes-1,   5);
-    send_bits(s, blcodes-4,  4); /* not -3 as stated in appnote.txt */
-    for (rank = 0; rank < blcodes; rank++) {
-        Tracev((stderr, "\nbl code %2u ", bl_order[rank]));
-        send_bits(s, s->bl_tree[bl_order[rank]].Len, 3);
-    }
-    Tracev((stderr, "\nbl tree: sent %lu", s->bits_sent));
-
-    send_tree(s, (ct_data *)s->dyn_ltree, lcodes-1); /* literal tree */
-    Tracev((stderr, "\nlit tree: sent %lu", s->bits_sent));
-
-    send_tree(s, (ct_data *)s->dyn_dtree, dcodes-1); /* distance tree */
-    Tracev((stderr, "\ndist tree: sent %lu", s->bits_sent));
-}
-
-/* ===========================================================================
- * Send a stored block
- */
-void ZLIB_INTERNAL _tr_stored_block(deflate_state *s, char *buf, unsigned long stored_len, int last) {
-    /* buf: input block */
-    /* stored_len: length of input block */
-    /* last: one if this is the last block for a file */
-    send_bits(s, (STORED_BLOCK << 1)+last, 3);    /* send block type */
-#ifdef DEBUG
-    s->compressed_len = (s->compressed_len + 3 + 7) & (unsigned long)~7L;
-    s->compressed_len += (stored_len + 4) << 3;
-#endif
-    copy_block(s, buf, (unsigned)stored_len, 1); /* with header */
-}
-
-/* ===========================================================================
- * Flush the bits in the bit buffer to pending output (leaves at most 7 bits)
- */
-void ZLIB_INTERNAL _tr_flush_bits(deflate_state *s) {
-    bi_flush(s);
-}
-
-/* ===========================================================================
- * Send one empty static block to give enough lookahead for inflate.
- * This takes 10 bits, of which 7 may remain in the bit buffer.
- */
-void ZLIB_INTERNAL _tr_align(deflate_state *s) {
-    send_bits(s, STATIC_TREES << 1, 3);
-    send_code(s, END_BLOCK, static_ltree);
-#ifdef DEBUG
-    s->compressed_len += 10L; /* 3 for block type, 7 for EOB */
-#endif
-    bi_flush(s);
-}
-
-/* ===========================================================================
- * Determine the best encoding for the current block: dynamic trees, static
- * trees or store, and output the encoded block to the zip file.
- */
-void ZLIB_INTERNAL _tr_flush_block(deflate_state *s, char *buf, unsigned long stored_len, int last) {
-    /* buf: input block, or NULL if too old */
-    /* stored_len: length of input block */
-    /* last: one if this is the last block for a file */
-    unsigned long opt_lenb, static_lenb; /* opt_len and static_len in bytes */
-    int max_blindex = 0;  /* index of last bit length code of non zero freq */
-
-    /* Build the Huffman trees unless a stored block is forced */
-    if (s->level > 0) {
-        /* Check if the file is binary or text */
-        if (s->strm->data_type == Z_UNKNOWN)
-            s->strm->data_type = detect_data_type(s);
-
-        /* Construct the literal and distance trees */
-        build_tree(s, (tree_desc *)(&(s->l_desc)));
-        Tracev((stderr, "\nlit data: dyn %lu, stat %lu", s->opt_len, s->static_len));
-
-        build_tree(s, (tree_desc *)(&(s->d_desc)));
-        Tracev((stderr, "\ndist data: dyn %lu, stat %lu", s->opt_len, s->static_len));
-        /* At this point, opt_len and static_len are the total bit lengths of
-         * the compressed block data, excluding the tree representations.
-         */
-
-        /* Build the bit length tree for the above two trees, and get the index
-         * in bl_order of the last bit length code to send.
-         */
-        max_blindex = build_bl_tree(s);
-
-        /* Determine the best encoding. Compute the block lengths in bytes. */
-        opt_lenb = (s->opt_len+3+7) >> 3;
-        static_lenb = (s->static_len+3+7) >> 3;
-
-        Tracev((stderr, "\nopt %lu(%lu) stat %lu(%lu) stored %lu lit %u ",
-                opt_lenb, s->opt_len, static_lenb, s->static_len, stored_len, s->last_lit));
-
-        if (static_lenb <= opt_lenb)
-            opt_lenb = static_lenb;
-
-    } else {
-        Assert(buf != NULL, "lost buf");
-        opt_lenb = static_lenb = stored_len + 5; /* force a stored block */
-    }
-
-#ifdef FORCE_STORED
-    if (buf != NULL) { /* force stored block */
-#else
-    if (stored_len+4 <= opt_lenb && buf != NULL) {
-                       /* 4: two words for the lengths */
-#endif
-        /* The test buf != NULL is only necessary if LIT_BUFSIZE > WSIZE.
-         * Otherwise we can't have processed more than WSIZE input bytes since
-         * the last block flush, because compression would have been
-         * successful. If LIT_BUFSIZE <= WSIZE, it is never too late to
-         * transform a block into a stored block.
-         */
-        _tr_stored_block(s, buf, stored_len, last);
-
-#ifdef FORCE_STATIC
-    } else if (static_lenb >= 0) { /* force static trees */
-#else
-    } else if (s->strategy == Z_FIXED || static_lenb == opt_lenb) {
-#endif
-        send_bits(s, (STATIC_TREES << 1)+last, 3);
-        compress_block(s, (const ct_data *)static_ltree, (const ct_data *)static_dtree);
-#ifdef DEBUG
-        s->compressed_len += 3 + s->static_len;
-#endif
-    } else {
-        send_bits(s, (DYN_TREES << 1)+last, 3);
-        send_all_trees(s, s->l_desc.max_code+1, s->d_desc.max_code+1, max_blindex+1);
-        compress_block(s, (const ct_data *)s->dyn_ltree, (const ct_data *)s->dyn_dtree);
-#ifdef DEBUG
-        s->compressed_len += 3 + s->opt_len;
-#endif
-    }
-    Assert(s->compressed_len == s->bits_sent, "bad compressed size");
-    /* The above check is made mod 2^32, for files larger than 512 MB
-     * and unsigned long implemented on 32 bits.
-     */
-    init_block(s);
-
-    if (last) {
-        bi_windup(s);
-#ifdef DEBUG
-        s->compressed_len += 7;  /* align on byte boundary */
-#endif
-    }
-    Tracev((stderr, "\ncomprlen %lu(%lu) ", s->compressed_len>>3, s->compressed_len-7*last));
-}
-
-/* ===========================================================================
- * Save the match info and tally the frequency counts. Return true if
- * the current block must be flushed.
- */
-int ZLIB_INTERNAL _tr_tally(deflate_state *s, unsigned dist, unsigned lc) {
-    /* dist: distance of matched string */
-    /* lc: match length-MIN_MATCH or unmatched char (if dist==0) */
-    s->d_buf[s->last_lit] = (uint16_t)dist;
-    s->l_buf[s->last_lit++] = (unsigned char)lc;
-    if (dist == 0) {
-        /* lc is the unmatched char */
-        s->dyn_ltree[lc].Freq++;
-    } else {
-        s->matches++;
-        /* Here, lc is the match length - MIN_MATCH */
-        dist--;             /* dist = match distance - 1 */
-        Assert((uint16_t)dist < (uint16_t)MAX_DIST(s) &&
-               (uint16_t)lc <= (uint16_t)(MAX_MATCH-MIN_MATCH) &&
-               (uint16_t)d_code(dist) < (uint16_t)D_CODES,  "_tr_tally: bad match");
-
-        s->dyn_ltree[_length_code[lc]+LITERALS+1].Freq++;
-        s->dyn_dtree[d_code(dist)].Freq++;
-    }
-
-#ifdef TRUNCATE_BLOCK
-    /* Try to guess if it is profitable to stop the current block here */
-    if ((s->last_lit & 0x1fff) == 0 && s->level > 2) {
-        /* Compute an upper bound for the compressed length */
-        unsigned long out_length = (unsigned long)s->last_lit*8L;
-        unsigned long in_length = (unsigned long)((long)s->strstart - s->block_start);
-        int dcode;
-        for (dcode = 0; dcode < D_CODES; dcode++) {
-            out_length += (unsigned long)s->dyn_dtree[dcode].Freq * (5L+extra_dbits[dcode]);
-        }
-        out_length >>= 3;
-        Tracev((stderr, "\nlast_lit %u, in %ld, out ~%ld(%ld%%) ",
-               s->last_lit, in_length, out_length, 100L - out_length*100L/in_length));
-        if (s->matches < s->last_lit/2 && out_length < in_length/2)
-            return 1;
-    }
-#endif
-    return (s->last_lit == s->lit_bufsize-1);
-    /* We avoid equality with lit_bufsize because of wraparound at 64K
-     * on 16 bit machines and because stored blocks are restricted to
-     * 64K-1 bytes.
-     */
-}
-
-/* ===========================================================================
- * Send the block data compressed using the given Huffman trees
- */
-local void compress_block(deflate_state *s, const ct_data *ltree, const ct_data *dtree) {
-    /* ltree: literal tree */
-    /* dtree: distance tree */
-    unsigned dist;      /* distance of matched string */
-    int lc;             /* match length or unmatched char (if dist == 0) */
-    unsigned lx = 0;    /* running index in l_buf */
-    unsigned code;      /* the code to send */
-    int extra;          /* number of extra bits to send */
-
-    if (s->last_lit != 0) {
-        do {
-            dist = s->d_buf[lx];
-            lc = s->l_buf[lx++];
-            if (dist == 0) {
-                send_code(s, lc, ltree); /* send a literal byte */
-                Tracecv(isgraph(lc), (stderr, " '%c' ", lc));
-            } else {
-                /* Here, lc is the match length - MIN_MATCH */
-                code = _length_code[lc];
-                send_code(s, code+LITERALS+1, ltree); /* send the length code */
-                extra = extra_lbits[code];
-                if (extra != 0) {
-                    lc -= base_length[code];
-                    send_bits(s, lc, extra);       /* send the extra length bits */
-                }
-                dist--; /* dist is now the match distance - 1 */
-                code = d_code(dist);
-                Assert(code < D_CODES, "bad d_code");
-
-                send_code(s, code, dtree);       /* send the distance code */
-                extra = extra_dbits[code];
-                if (extra != 0) {
-                    dist -= base_dist[code];
-                    send_bits(s, dist, extra);   /* send the extra distance bits */
-                }
-            } /* literal or match pair ? */
-
-            /* Check that the overlay between pending_buf and d_buf+l_buf is ok: */
-            Assert((unsigned int)(s->pending) < s->lit_bufsize + 2*lx, "pendingBuf overflow");
-        } while (lx < s->last_lit);
-    }
-
-    send_code(s, END_BLOCK, ltree);
-}
-
-/* ===========================================================================
- * Check if the data type is TEXT or BINARY, using the following algorithm:
- * - TEXT if the two conditions below are satisfied:
- *    a) There are no non-portable control characters belonging to the
- *       "black list" (0..6, 14..25, 28..31).
- *    b) There is at least one printable character belonging to the
- *       "white list" (9 {TAB}, 10 {LF}, 13 {CR}, 32..255).
- * - BINARY otherwise.
- * - The following partially-portable control characters form a
- *   "gray list" that is ignored in this detection algorithm:
- *   (7 {BEL}, 8 {BS}, 11 {VT}, 12 {FF}, 26 {SUB}, 27 {ESC}).
- * IN assertion: the fields Freq of dyn_ltree are set.
- */
-local int detect_data_type(deflate_state *s) {
-    /* black_mask is the bit mask of black-listed bytes
-     * set bits 0..6, 14..25, and 28..31
-     * 0xf3ffc07f = binary 11110011111111111100000001111111
-     */
-    unsigned long black_mask = 0xf3ffc07fUL;
-    int n;
-
-    /* Check for non-textual ("black-listed") bytes. */
-    for (n = 0; n <= 31; n++, black_mask >>= 1)
-        if ((black_mask & 1) && (s->dyn_ltree[n].Freq != 0))
-            return Z_BINARY;
-
-    /* Check for textual ("white-listed") bytes. */
-    if (s->dyn_ltree[9].Freq != 0 || s->dyn_ltree[10].Freq != 0 || s->dyn_ltree[13].Freq != 0)
-        return Z_TEXT;
-    for (n = 32; n < LITERALS; n++)
-        if (s->dyn_ltree[n].Freq != 0)
-            return Z_TEXT;
-
-    /* There are no "black-listed" or "white-listed" bytes:
-     * this stream either is empty or has tolerated ("gray-listed") bytes only.
-     */
-    return Z_BINARY;
-}
-
-/* ===========================================================================
- * Reverse the first len bits of a code, using straightforward code (a faster
- * method would use a table)
- * IN assertion: 1 <= len <= 15
- */
-local unsigned bi_reverse(unsigned code, int len) {
-    /* code: the value to invert */
-    /* len: its bit length */
-    register unsigned res = 0;
-    do {
-        res |= code & 1;
-        code >>= 1, res <<= 1;
-    } while (--len > 0);
-    return res >> 1;
-}
-
-/* ===========================================================================
- * Flush the bit buffer, keeping at most 7 bits in it.
- */
-local void bi_flush(deflate_state *s) {
-    if (s->bi_valid == 16) {
-        put_short(s, s->bi_buf);
-        s->bi_buf = 0;
-        s->bi_valid = 0;
-    } else if (s->bi_valid >= 8) {
-        put_byte(s, (unsigned char)s->bi_buf);
-        s->bi_buf >>= 8;
-        s->bi_valid -= 8;
-    }
-}
-
-/* ===========================================================================
- * Flush the bit buffer and align the output on a byte boundary
- */
-ZLIB_INTERNAL void bi_windup(deflate_state *s) {
-    if (s->bi_valid > 8) {
-        put_short(s, s->bi_buf);
-    } else if (s->bi_valid > 0) {
-        put_byte(s, (unsigned char)s->bi_buf);
-    }
-    s->bi_buf = 0;
-    s->bi_valid = 0;
-#ifdef DEBUG
-    s->bits_sent = (s->bits_sent+7) & ~7;
-#endif
-}
-
-/* ===========================================================================
- * Copy a stored block, storing first the length and its
- * one's complement if requested.
- */
-local void copy_block(deflate_state *s, char *buf, unsigned len, int header) {
-    /* buf: the input data */
-    /* len: its length */
-    /* header: true if block header must be written */
-    bi_windup(s);        /* align on byte boundary */
-
-    if (header) {
-        put_short(s, (uint16_t)len);
-        put_short(s, (uint16_t)~len);
-#ifdef DEBUG
-        s->bits_sent += 2*16;
-#endif
-    }
-#ifdef DEBUG
-    s->bits_sent += (unsigned long)len << 3;
-#endif
-    while (len--) {
-        put_byte(s, *buf++);
-    }
-}
-
diff --git a/contrib/libzlib-ng/trees.h b/contrib/libzlib-ng/trees.h
deleted file mode 100644
index debfbdd8584..00000000000
--- a/contrib/libzlib-ng/trees.h
+++ /dev/null
@@ -1,132 +0,0 @@
-#ifndef TREES_H_
-#define TREES_H_
-
-/* header created automatically with -DGEN_TREES_H */
-
-ZLIB_INTERNAL const ct_data static_ltree[L_CODES+2] = {
-{{ 12},{  8}}, {{140},{  8}}, {{ 76},{  8}}, {{204},{  8}}, {{ 44},{  8}},
-{{172},{  8}}, {{108},{  8}}, {{236},{  8}}, {{ 28},{  8}}, {{156},{  8}},
-{{ 92},{  8}}, {{220},{  8}}, {{ 60},{  8}}, {{188},{  8}}, {{124},{  8}},
-{{252},{  8}}, {{  2},{  8}}, {{130},{  8}}, {{ 66},{  8}}, {{194},{  8}},
-{{ 34},{  8}}, {{162},{  8}}, {{ 98},{  8}}, {{226},{  8}}, {{ 18},{  8}},
-{{146},{  8}}, {{ 82},{  8}}, {{210},{  8}}, {{ 50},{  8}}, {{178},{  8}},
-{{114},{  8}}, {{242},{  8}}, {{ 10},{  8}}, {{138},{  8}}, {{ 74},{  8}},
-{{202},{  8}}, {{ 42},{  8}}, {{170},{  8}}, {{106},{  8}}, {{234},{  8}},
-{{ 26},{  8}}, {{154},{  8}}, {{ 90},{  8}}, {{218},{  8}}, {{ 58},{  8}},
-{{186},{  8}}, {{122},{  8}}, {{250},{  8}}, {{  6},{  8}}, {{134},{  8}},
-{{ 70},{  8}}, {{198},{  8}}, {{ 38},{  8}}, {{166},{  8}}, {{102},{  8}},
-{{230},{  8}}, {{ 22},{  8}}, {{150},{  8}}, {{ 86},{  8}}, {{214},{  8}},
-{{ 54},{  8}}, {{182},{  8}}, {{118},{  8}}, {{246},{  8}}, {{ 14},{  8}},
-{{142},{  8}}, {{ 78},{  8}}, {{206},{  8}}, {{ 46},{  8}}, {{174},{  8}},
-{{110},{  8}}, {{238},{  8}}, {{ 30},{  8}}, {{158},{  8}}, {{ 94},{  8}},
-{{222},{  8}}, {{ 62},{  8}}, {{190},{  8}}, {{126},{  8}}, {{254},{  8}},
-{{  1},{  8}}, {{129},{  8}}, {{ 65},{  8}}, {{193},{  8}}, {{ 33},{  8}},
-{{161},{  8}}, {{ 97},{  8}}, {{225},{  8}}, {{ 17},{  8}}, {{145},{  8}},
-{{ 81},{  8}}, {{209},{  8}}, {{ 49},{  8}}, {{177},{  8}}, {{113},{  8}},
-{{241},{  8}}, {{  9},{  8}}, {{137},{  8}}, {{ 73},{  8}}, {{201},{  8}},
-{{ 41},{  8}}, {{169},{  8}}, {{105},{  8}}, {{233},{  8}}, {{ 25},{  8}},
-{{153},{  8}}, {{ 89},{  8}}, {{217},{  8}}, {{ 57},{  8}}, {{185},{  8}},
-{{121},{  8}}, {{249},{  8}}, {{  5},{  8}}, {{133},{  8}}, {{ 69},{  8}},
-{{197},{  8}}, {{ 37},{  8}}, {{165},{  8}}, {{101},{  8}}, {{229},{  8}},
-{{ 21},{  8}}, {{149},{  8}}, {{ 85},{  8}}, {{213},{  8}}, {{ 53},{  8}},
-{{181},{  8}}, {{117},{  8}}, {{245},{  8}}, {{ 13},{  8}}, {{141},{  8}},
-{{ 77},{  8}}, {{205},{  8}}, {{ 45},{  8}}, {{173},{  8}}, {{109},{  8}},
-{{237},{  8}}, {{ 29},{  8}}, {{157},{  8}}, {{ 93},{  8}}, {{221},{  8}},
-{{ 61},{  8}}, {{189},{  8}}, {{125},{  8}}, {{253},{  8}}, {{ 19},{  9}},
-{{275},{  9}}, {{147},{  9}}, {{403},{  9}}, {{ 83},{  9}}, {{339},{  9}},
-{{211},{  9}}, {{467},{  9}}, {{ 51},{  9}}, {{307},{  9}}, {{179},{  9}},
-{{435},{  9}}, {{115},{  9}}, {{371},{  9}}, {{243},{  9}}, {{499},{  9}},
-{{ 11},{  9}}, {{267},{  9}}, {{139},{  9}}, {{395},{  9}}, {{ 75},{  9}},
-{{331},{  9}}, {{203},{  9}}, {{459},{  9}}, {{ 43},{  9}}, {{299},{  9}},
-{{171},{  9}}, {{427},{  9}}, {{107},{  9}}, {{363},{  9}}, {{235},{  9}},
-{{491},{  9}}, {{ 27},{  9}}, {{283},{  9}}, {{155},{  9}}, {{411},{  9}},
-{{ 91},{  9}}, {{347},{  9}}, {{219},{  9}}, {{475},{  9}}, {{ 59},{  9}},
-{{315},{  9}}, {{187},{  9}}, {{443},{  9}}, {{123},{  9}}, {{379},{  9}},
-{{251},{  9}}, {{507},{  9}}, {{  7},{  9}}, {{263},{  9}}, {{135},{  9}},
-{{391},{  9}}, {{ 71},{  9}}, {{327},{  9}}, {{199},{  9}}, {{455},{  9}},
-{{ 39},{  9}}, {{295},{  9}}, {{167},{  9}}, {{423},{  9}}, {{103},{  9}},
-{{359},{  9}}, {{231},{  9}}, {{487},{  9}}, {{ 23},{  9}}, {{279},{  9}},
-{{151},{  9}}, {{407},{  9}}, {{ 87},{  9}}, {{343},{  9}}, {{215},{  9}},
-{{471},{  9}}, {{ 55},{  9}}, {{311},{  9}}, {{183},{  9}}, {{439},{  9}},
-{{119},{  9}}, {{375},{  9}}, {{247},{  9}}, {{503},{  9}}, {{ 15},{  9}},
-{{271},{  9}}, {{143},{  9}}, {{399},{  9}}, {{ 79},{  9}}, {{335},{  9}},
-{{207},{  9}}, {{463},{  9}}, {{ 47},{  9}}, {{303},{  9}}, {{175},{  9}},
-{{431},{  9}}, {{111},{  9}}, {{367},{  9}}, {{239},{  9}}, {{495},{  9}},
-{{ 31},{  9}}, {{287},{  9}}, {{159},{  9}}, {{415},{  9}}, {{ 95},{  9}},
-{{351},{  9}}, {{223},{  9}}, {{479},{  9}}, {{ 63},{  9}}, {{319},{  9}},
-{{191},{  9}}, {{447},{  9}}, {{127},{  9}}, {{383},{  9}}, {{255},{  9}},
-{{511},{  9}}, {{  0},{  7}}, {{ 64},{  7}}, {{ 32},{  7}}, {{ 96},{  7}},
-{{ 16},{  7}}, {{ 80},{  7}}, {{ 48},{  7}}, {{112},{  7}}, {{  8},{  7}},
-{{ 72},{  7}}, {{ 40},{  7}}, {{104},{  7}}, {{ 24},{  7}}, {{ 88},{  7}},
-{{ 56},{  7}}, {{120},{  7}}, {{  4},{  7}}, {{ 68},{  7}}, {{ 36},{  7}},
-{{100},{  7}}, {{ 20},{  7}}, {{ 84},{  7}}, {{ 52},{  7}}, {{116},{  7}},
-{{  3},{  8}}, {{131},{  8}}, {{ 67},{  8}}, {{195},{  8}}, {{ 35},{  8}},
-{{163},{  8}}, {{ 99},{  8}}, {{227},{  8}}
-};
-
-local const ct_data static_dtree[D_CODES] = {
-{{ 0},{ 5}}, {{16},{ 5}}, {{ 8},{ 5}}, {{24},{ 5}}, {{ 4},{ 5}},
-{{20},{ 5}}, {{12},{ 5}}, {{28},{ 5}}, {{ 2},{ 5}}, {{18},{ 5}},
-{{10},{ 5}}, {{26},{ 5}}, {{ 6},{ 5}}, {{22},{ 5}}, {{14},{ 5}},
-{{30},{ 5}}, {{ 1},{ 5}}, {{17},{ 5}}, {{ 9},{ 5}}, {{25},{ 5}},
-{{ 5},{ 5}}, {{21},{ 5}}, {{13},{ 5}}, {{29},{ 5}}, {{ 3},{ 5}},
-{{19},{ 5}}, {{11},{ 5}}, {{27},{ 5}}, {{ 7},{ 5}}, {{23},{ 5}}
-};
-
-const unsigned char ZLIB_INTERNAL _dist_code[DIST_CODE_LEN] = {
- 0,  1,  2,  3,  4,  4,  5,  5,  6,  6,  6,  6,  7,  7,  7,  7,  8,  8,  8,  8,
- 8,  8,  8,  8,  9,  9,  9,  9,  9,  9,  9,  9, 10, 10, 10, 10, 10, 10, 10, 10,
-10, 10, 10, 10, 10, 10, 10, 10, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
-11, 11, 11, 11, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
-12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 13, 13, 13, 13,
-13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
-13, 13, 13, 13, 13, 13, 13, 13, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
-14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
-14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
-14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 15, 15, 15, 15, 15, 15, 15, 15,
-15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
-15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
-15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,  0,  0, 16, 17,
-18, 18, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 22, 22, 22, 22, 22, 22, 22, 22,
-23, 23, 23, 23, 23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
-24, 24, 24, 24, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
-26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
-26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 27, 27, 27, 27, 27, 27, 27, 27,
-27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
-27, 27, 27, 27, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
-28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
-28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
-28, 28, 28, 28, 28, 28, 28, 28, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
-29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
-29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
-29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29
-};
-
-const unsigned char ZLIB_INTERNAL _length_code[MAX_MATCH-MIN_MATCH+1]= {
- 0,  1,  2,  3,  4,  5,  6,  7,  8,  8,  9,  9, 10, 10, 11, 11, 12, 12, 12, 12,
-13, 13, 13, 13, 14, 14, 14, 14, 15, 15, 15, 15, 16, 16, 16, 16, 16, 16, 16, 16,
-17, 17, 17, 17, 17, 17, 17, 17, 18, 18, 18, 18, 18, 18, 18, 18, 19, 19, 19, 19,
-19, 19, 19, 19, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20,
-21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 22, 22, 22, 22,
-22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 23, 23, 23, 23, 23, 23, 23, 23,
-23, 23, 23, 23, 23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
-24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
-25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
-25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 26, 26, 26, 26, 26, 26, 26, 26,
-26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
-26, 26, 26, 26, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
-27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 28
-};
-
-local const int base_length[LENGTH_CODES] = {
-0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 12, 14, 16, 20, 24, 28, 32, 40, 48, 56,
-64, 80, 96, 112, 128, 160, 192, 224, 0
-};
-
-local const int base_dist[D_CODES] = {
-    0,     1,     2,     3,     4,     6,     8,    12,    16,    24,
-   32,    48,    64,    96,   128,   192,   256,   384,   512,   768,
- 1024,  1536,  2048,  3072,  4096,  6144,  8192, 12288, 16384, 24576
-};
-
-#endif /* TREES_H_ */
diff --git a/contrib/libzlib-ng/uncompr.c b/contrib/libzlib-ng/uncompr.c
deleted file mode 100644
index c2af140db1e..00000000000
--- a/contrib/libzlib-ng/uncompr.c
+++ /dev/null
@@ -1,75 +0,0 @@
-/* uncompr.c -- decompress a memory buffer
- * Copyright (C) 1995-2003, 2010, 2014 Jean-loup Gailly, Mark Adler.
- * For conditions of distribution and use, see copyright notice in zlib.h
- */
-
-/* @(#) $Id$ */
-
-#define ZLIB_INTERNAL
-#include "zlib.h"
-
-/* ===========================================================================
-     Decompresses the source buffer into the destination buffer.  sourceLen is
-   the byte length of the source buffer. Upon entry, destLen is the total
-   size of the destination buffer, which must be large enough to hold the
-   entire uncompressed data. (The size of the uncompressed data must have
-   been saved previously by the compressor and transmitted to the decompressor
-   by some mechanism outside the scope of this compression library.)
-   Upon exit, destLen is the actual size of the compressed buffer.
-
-     uncompress returns Z_OK if success, Z_MEM_ERROR if there was not
-   enough memory, Z_BUF_ERROR if there was not enough room in the output
-   buffer, or Z_DATA_ERROR if the input data was corrupted, including if the
-   input data is an incomplete zlib stream.
-*/
-int ZEXPORT uncompress(unsigned char *dest, size_t *destLen, const unsigned char *source, size_t sourceLen) {
-    z_stream stream;
-    int err;
-    const unsigned int max = (unsigned int)0 - 1;
-    size_t left;
-    unsigned char buf[1];    /* for detection of incomplete stream when *destLen == 0 */
-
-    if (*destLen) {
-        left = *destLen;
-        *destLen = 0;
-    }
-    else {
-        left = 1;
-        dest = buf;
-    }
-
-    stream.next_in = (const unsigned char *)source;
-    stream.avail_in = 0;
-    stream.zalloc = (alloc_func)0;
-    stream.zfree = (free_func)0;
-    stream.opaque = NULL;
-
-    err = inflateInit(&stream);
-    if (err != Z_OK) return err;
-
-    stream.next_out = dest;
-    stream.avail_out = 0;
-
-    do {
-        if (stream.avail_out == 0) {
-            stream.avail_out = left > (unsigned long)max ? max : (unsigned int)left;
-            left -= stream.avail_out;
-        }
-        if (stream.avail_in == 0) {
-            stream.avail_in = sourceLen > (unsigned long)max ? max : (unsigned int)sourceLen;
-            sourceLen -= stream.avail_in;
-        }
-        err = inflate(&stream, Z_NO_FLUSH);
-    } while (err == Z_OK);
-
-    if (dest != buf)
-        *destLen = stream.total_out;
-    else if (stream.total_out && err == Z_BUF_ERROR)
-        left = 1;
-
-    inflateEnd(&stream);
-    return err == Z_STREAM_END ? Z_OK :
-           err == Z_NEED_DICT ? Z_DATA_ERROR  :
-           err == Z_BUF_ERROR && left + stream.avail_out ? Z_DATA_ERROR :
-           err;
-}
diff --git a/contrib/libzlib-ng/win32/DLL_FAQ.txt b/contrib/libzlib-ng/win32/DLL_FAQ.txt
deleted file mode 100644
index 12c009018c3..00000000000
--- a/contrib/libzlib-ng/win32/DLL_FAQ.txt
+++ /dev/null
@@ -1,397 +0,0 @@
-
-            Frequently Asked Questions about ZLIB1.DLL
-
-
-This document describes the design, the rationale, and the usage
-of the official DLL build of zlib, named ZLIB1.DLL.  If you have
-general questions about zlib, you should see the file "FAQ" found
-in the zlib distribution, or at the following location:
-  http://www.gzip.org/zlib/zlib_faq.html
-
-
- 1. What is ZLIB1.DLL, and how can I get it?
-
-  - ZLIB1.DLL is the official build of zlib as a DLL.
-    (Please remark the character '1' in the name.)
-
-    Pointers to a precompiled ZLIB1.DLL can be found in the zlib
-    web site at:
-      http://www.zlib.net/
-
-    Applications that link to ZLIB1.DLL can rely on the following
-    specification:
-
-    * The exported symbols are exclusively defined in the source
-      files "zlib.h" and "zlib.def", found in an official zlib
-      source distribution.
-    * The symbols are exported by name, not by ordinal.
-    * The exported names are undecorated.
-    * The calling convention of functions is "C" (CDECL).
-    * The ZLIB1.DLL binary is linked to MSVCRT.DLL.
-
-    The archive in which ZLIB1.DLL is bundled contains compiled
-    test programs that must run with a valid build of ZLIB1.DLL.
-    It is recommended to download the prebuilt DLL from the zlib
-    web site, instead of building it yourself, to avoid potential
-    incompatibilities that could be introduced by your compiler
-    and build settings.  If you do build the DLL yourself, please
-    make sure that it complies with all the above requirements,
-    and it runs with the precompiled test programs, bundled with
-    the original ZLIB1.DLL distribution.
-
-    If, for any reason, you need to build an incompatible DLL,
-    please use a different file name.
-
-
- 2. Why did you change the name of the DLL to ZLIB1.DLL?
-    What happened to the old ZLIB.DLL?
-
-  - The old ZLIB.DLL, built from zlib-1.1.4 or earlier, required
-    compilation settings that were incompatible to those used by
-    a static build.  The DLL settings were supposed to be enabled
-    by defining the macro ZLIB_DLL, before including "zlib.h".
-    Incorrect handling of this macro was silently accepted at
-    build time, resulting in two major problems:
-
-    * ZLIB_DLL was missing from the old makefile.  When building
-      the DLL, not all people added it to the build options.  In
-      consequence, incompatible incarnations of ZLIB.DLL started
-      to circulate around the net.
-
-    * When switching from using the static library to using the
-      DLL, applications had to define the ZLIB_DLL macro and
-      to recompile all the sources that contained calls to zlib
-      functions.  Failure to do so resulted in creating binaries
-      that were unable to run with the official ZLIB.DLL build.
-
-    The only possible solution that we could foresee was to make
-    a binary-incompatible change in the DLL interface, in order to
-    remove the dependency on the ZLIB_DLL macro, and to release
-    the new DLL under a different name.
-
-    We chose the name ZLIB1.DLL, where '1' indicates the major
-    zlib version number.  We hope that we will not have to break
-    the binary compatibility again, at least not as long as the
-    zlib-1.x series will last.
-
-    There is still a ZLIB_DLL macro, that can trigger a more
-    efficient build and use of the DLL, but compatibility no
-    longer dependents on it.
-
-
- 3. Can I build ZLIB.DLL from the new zlib sources, and replace
-    an old ZLIB.DLL, that was built from zlib-1.1.4 or earlier?
-
-  - In principle, you can do it by assigning calling convention
-    keywords to the macros ZEXPORT and ZEXPORTVA.  In practice,
-    it depends on what you mean by "an old ZLIB.DLL", because the
-    old DLL exists in several mutually-incompatible versions.
-    You have to find out first what kind of calling convention is
-    being used in your particular ZLIB.DLL build, and to use the
-    same one in the new build.  If you don't know what this is all
-    about, you might be better off if you would just leave the old
-    DLL intact.
-
-
- 4. Can I compile my application using the new zlib interface, and
-    link it to an old ZLIB.DLL, that was built from zlib-1.1.4 or
-    earlier?
-
-  - The official answer is "no"; the real answer depends again on
-    what kind of ZLIB.DLL you have.  Even if you are lucky, this
-    course of action is unreliable.
-
-    If you rebuild your application and you intend to use a newer
-    version of zlib (post- 1.1.4), it is strongly recommended to
-    link it to the new ZLIB1.DLL.
-
-
- 5. Why are the zlib symbols exported by name, and not by ordinal?
-
-  - Although exporting symbols by ordinal is a little faster, it
-    is risky.  Any single glitch in the maintenance or use of the
-    DEF file that contains the ordinals can result in incompatible
-    builds and frustrating crashes.  Simply put, the benefits of
-    exporting symbols by ordinal do not justify the risks.
-
-    Technically, it should be possible to maintain ordinals in
-    the DEF file, and still export the symbols by name.  Ordinals
-    exist in every DLL, and even if the dynamic linking performed
-    at the DLL startup is searching for names, ordinals serve as
-    hints, for a faster name lookup.  However, if the DEF file
-    contains ordinals, the Microsoft linker automatically builds
-    an implib that will cause the executables linked to it to use
-    those ordinals, and not the names.  It is interesting to
-    notice that the GNU linker for Win32 does not suffer from this
-    problem.
-
-    It is possible to avoid the DEF file if the exported symbols
-    are accompanied by a "__declspec(dllexport)" attribute in the
-    source files.  You can do this in zlib by predefining the
-    ZLIB_DLL macro.
-
-
- 6. I see that the ZLIB1.DLL functions use the "C" (CDECL) calling
-    convention.  Why not use the STDCALL convention?
-    STDCALL is the standard convention in Win32, and I need it in
-    my Visual Basic project!
-
-    (For readability, we use CDECL to refer to the convention
-     triggered by the "__cdecl" keyword, STDCALL to refer to
-     the convention triggered by "__stdcall", and FASTCALL to
-     refer to the convention triggered by "__fastcall".)
-
-  - Most of the native Windows API functions (without varargs) use
-    indeed the WINAPI convention (which translates to STDCALL in
-    Win32), but the standard C functions use CDECL.  If a user
-    application is intrinsically tied to the Windows API (e.g.
-    it calls native Windows API functions such as CreateFile()),
-    sometimes it makes sense to decorate its own functions with
-    WINAPI.  But if ANSI C or POSIX portability is a goal (e.g.
-    it calls standard C functions such as fopen()), it is not a
-    sound decision to request the inclusion of <windows.h>, or to
-    use non-ANSI constructs, for the sole purpose to make the user
-    functions STDCALL-able.
-
-    The functionality offered by zlib is not in the category of
-    "Windows functionality", but is more like "C functionality".
-
-    Technically, STDCALL is not bad; in fact, it is slightly
-    faster than CDECL, and it works with variable-argument
-    functions, just like CDECL.  It is unfortunate that, in spite
-    of using STDCALL in the Windows API, it is not the default
-    convention used by the C compilers that run under Windows.
-    The roots of the problem reside deep inside the unsafety of
-    the K&R-style function prototypes, where the argument types
-    are not specified; but that is another story for another day.
-
-    The remaining fact is that CDECL is the default convention.
-    Even if an explicit convention is hard-coded into the function
-    prototypes inside C headers, problems may appear.  The
-    necessity to expose the convention in users' callbacks is one
-    of these problems.
-
-    The calling convention issues are also important when using
-    zlib in other programming languages.  Some of them, like Ada
-    (GNAT) and Fortran (GNU G77), have C bindings implemented
-    initially on Unix, and relying on the C calling convention.
-    On the other hand, the pre- .NET versions of Microsoft Visual
-    Basic require STDCALL, while Borland Delphi prefers, although
-    it does not require, FASTCALL.
-
-    In fairness to all possible uses of zlib outside the C
-    programming language, we choose the default "C" convention.
-    Anyone interested in different bindings or conventions is
-    encouraged to maintain specialized projects.  The "contrib/"
-    directory from the zlib distribution already holds a couple
-    of foreign bindings, such as Ada, C++, and Delphi.
-
-
- 7. I need a DLL for my Visual Basic project.  What can I do?
-
-  - Define the ZLIB_WINAPI macro before including "zlib.h", when
-    building both the DLL and the user application (except that
-    you don't need to define anything when using the DLL in Visual
-    Basic).  The ZLIB_WINAPI macro will switch on the WINAPI
-    (STDCALL) convention.  The name of this DLL must be different
-    than the official ZLIB1.DLL.
-
-    Gilles Vollant has contributed a build named ZLIBWAPI.DLL,
-    with the ZLIB_WINAPI macro turned on, and with the minizip
-    functionality built in.  For more information, please read
-    the notes inside "contrib/vstudio/readme.txt", found in the
-    zlib distribution.
-
-
- 8. I need to use zlib in my Microsoft .NET project.  What can I
-    do?
-
-  - Henrik Ravn has contributed a .NET wrapper around zlib.  Look
-    into contrib/dotzlib/, inside the zlib distribution.
-
-
- 9. If my application uses ZLIB1.DLL, should I link it to
-    MSVCRT.DLL?  Why?
-
-  - It is not required, but it is recommended to link your
-    application to MSVCRT.DLL, if it uses ZLIB1.DLL.
-
-    The executables (.EXE, .DLL, etc.) that are involved in the
-    same process and are using the C run-time library (i.e. they
-    are calling standard C functions), must link to the same
-    library.  There are several libraries in the Win32 system:
-    CRTDLL.DLL, MSVCRT.DLL, the static C libraries, etc.
-    Since ZLIB1.DLL is linked to MSVCRT.DLL, the executables that
-    depend on it should also be linked to MSVCRT.DLL.
-
-
-10. Why are you saying that ZLIB1.DLL and my application should
-    be linked to the same C run-time (CRT) library?  I linked my
-    application and my DLLs to different C libraries (e.g. my
-    application to a static library, and my DLLs to MSVCRT.DLL),
-    and everything works fine.
-
-  - If a user library invokes only pure Win32 API (accessible via
-    <windows.h> and the related headers), its DLL build will work
-    in any context.  But if this library invokes standard C API,
-    things get more complicated.
-
-    There is a single Win32 library in a Win32 system.  Every
-    function in this library resides in a single DLL module, that
-    is safe to call from anywhere.  On the other hand, there are
-    multiple versions of the C library, and each of them has its
-    own separate internal state.  Standalone executables and user
-    DLLs that call standard C functions must link to a C run-time
-    (CRT) library, be it static or shared (DLL).  Intermixing
-    occurs when an executable (not necessarily standalone) and a
-    DLL are linked to different CRTs, and both are running in the
-    same process.
-
-    Intermixing multiple CRTs is possible, as long as their
-    internal states are kept intact.  The Microsoft Knowledge Base
-    articles KB94248 "HOWTO: Use the C Run-Time" and KB140584
-    "HOWTO: Link with the Correct C Run-Time (CRT) Library"
-    mention the potential problems raised by intermixing.
-
-    If intermixing works for you, it's because your application
-    and DLLs are avoiding the corruption of each of the CRTs'
-    internal states, maybe by careful design, or maybe by fortune.
-
-    Also note that linking ZLIB1.DLL to non-Microsoft CRTs, such
-    as those provided by Borland, raises similar problems.
-
-
-11. Why are you linking ZLIB1.DLL to MSVCRT.DLL?
-
-  - MSVCRT.DLL exists on every Windows 95 with a new service pack
-    installed, or with Microsoft Internet Explorer 4 or later, and
-    on all other Windows 4.x or later (Windows 98, Windows NT 4,
-    or later).  It is freely distributable; if not present in the
-    system, it can be downloaded from Microsoft or from other
-    software provider for free.
-
-    The fact that MSVCRT.DLL does not exist on a virgin Windows 95
-    is not so problematic.  Windows 95 is scarcely found nowadays,
-    Microsoft ended its support a long time ago, and many recent
-    applications from various vendors, including Microsoft, do not
-    even run on it.  Furthermore, no serious user should run
-    Windows 95 without a proper update installed.
-
-
-12. Why are you not linking ZLIB1.DLL to
-    <<my favorite C run-time library>> ?
-
-  - We considered and abandoned the following alternatives:
-
-    * Linking ZLIB1.DLL to a static C library (LIBC.LIB, or
-      LIBCMT.LIB) is not a good option.  People are using the DLL
-      mainly to save disk space.  If you are linking your program
-      to a static C library, you may as well consider linking zlib
-      in statically, too.
-
-    * Linking ZLIB1.DLL to CRTDLL.DLL looks appealing, because
-      CRTDLL.DLL is present on every Win32 installation.
-      Unfortunately, it has a series of problems: it does not
-      work properly with Microsoft's C++ libraries, it does not
-      provide support for 64-bit file offsets, (and so on...),
-      and Microsoft discontinued its support a long time ago.
-
-    * Linking ZLIB1.DLL to MSVCR70.DLL or MSVCR71.DLL, supplied
-      with the Microsoft .NET platform, and Visual C++ 7.0/7.1,
-      raises problems related to the status of ZLIB1.DLL as a
-      system component.  According to the Microsoft Knowledge Base
-      article KB326922 "INFO: Redistribution of the Shared C
-      Runtime Component in Visual C++ .NET", MSVCR70.DLL and
-      MSVCR71.DLL are not supposed to function as system DLLs,
-      because they may clash with MSVCRT.DLL.  Instead, the
-      application's installer is supposed to put these DLLs
-      (if needed) in the application's private directory.
-      If ZLIB1.DLL depends on a non-system runtime, it cannot
-      function as a redistributable system component.
-
-    * Linking ZLIB1.DLL to non-Microsoft runtimes, such as
-      Borland's, or Cygwin's, raises problems related to the
-      reliable presence of these runtimes on Win32 systems.
-      It's easier to let the DLL build of zlib up to the people
-      who distribute these runtimes, and who may proceed as
-      explained in the answer to Question 14.
-
-
-13. If ZLIB1.DLL cannot be linked to MSVCR70.DLL or MSVCR71.DLL,
-    how can I build/use ZLIB1.DLL in Microsoft Visual C++ 7.0
-    (Visual Studio .NET) or newer?
-
-  - Due to the problems explained in the Microsoft Knowledge Base
-    article KB326922 (see the previous answer), the C runtime that
-    comes with the VC7 environment is no longer considered a
-    system component.  That is, it should not be assumed that this
-    runtime exists, or may be installed in a system directory.
-    Since ZLIB1.DLL is supposed to be a system component, it may
-    not depend on a non-system component.
-
-    In order to link ZLIB1.DLL and your application to MSVCRT.DLL
-    in VC7, you need the library of Visual C++ 6.0 or older.  If
-    you don't have this library at hand, it's probably best not to
-    use ZLIB1.DLL.
-
-    We are hoping that, in the future, Microsoft will provide a
-    way to build applications linked to a proper system runtime,
-    from the Visual C++ environment.  Until then, you have a
-    couple of alternatives, such as linking zlib in statically.
-    If your application requires dynamic linking, you may proceed
-    as explained in the answer to Question 14.
-
-
-14. I need to link my own DLL build to a CRT different than
-    MSVCRT.DLL.  What can I do?
-
-  - Feel free to rebuild the DLL from the zlib sources, and link
-    it the way you want.  You should, however, clearly state that
-    your build is unofficial.  You should give it a different file
-    name, and/or install it in a private directory that can be
-    accessed by your application only, and is not visible to the
-    others (i.e. it's neither in the PATH, nor in the SYSTEM or
-    SYSTEM32 directories).  Otherwise, your build may clash with
-    applications that link to the official build.
-
-    For example, in Cygwin, zlib is linked to the Cygwin runtime
-    CYGWIN1.DLL, and it is distributed under the name CYGZ.DLL.
-
-
-15. May I include additional pieces of code that I find useful,
-    link them in ZLIB1.DLL, and export them?
-
-  - No.  A legitimate build of ZLIB1.DLL must not include code
-    that does not originate from the official zlib source code.
-    But you can make your own private DLL build, under a different
-    file name, as suggested in the previous answer.
-
-    For example, zlib is a part of the VCL library, distributed
-    with Borland Delphi and C++ Builder.  The DLL build of VCL
-    is a redistributable file, named VCLxx.DLL.
-
-
-16. May I remove some functionality out of ZLIB1.DLL, by enabling
-    macros like NO_GZCOMPRESS or NO_GZIP at compile time?
-
-  - No.  A legitimate build of ZLIB1.DLL must provide the complete
-    zlib functionality, as implemented in the official zlib source
-    code.  But you can make your own private DLL build, under a
-    different file name, as suggested in the previous answer.
-
-
-17. I made my own ZLIB1.DLL build.  Can I test it for compliance?
-
-  - We prefer that you download the official DLL from the zlib
-    web site.  If you need something peculiar from this DLL, you
-    can send your suggestion to the zlib mailing list.
-
-    However, in case you do rebuild the DLL yourself, you can run
-    it with the test programs found in the DLL distribution.
-    Running these test programs is not a guarantee of compliance,
-    but a failure can imply a detected problem.
-
-**
-
-This document is written and maintained by
-Cosmin Truta <cosmint@cs.ubbcluj.ro>
diff --git a/contrib/libzlib-ng/win32/Makefile.msc b/contrib/libzlib-ng/win32/Makefile.msc
deleted file mode 100644
index b6375ccb4f8..00000000000
--- a/contrib/libzlib-ng/win32/Makefile.msc
+++ /dev/null
@@ -1,154 +0,0 @@
-# Makefile for zlib using Microsoft (Visual) C
-# zlib is copyright (C) 1995-2006 Jean-loup Gailly and Mark Adler
-#
-# Usage:
-#   nmake -f win32/Makefile.msc                          (standard build)
-#   nmake -f win32/Makefile.msc LOC=-DFOO                (nonstandard build)
-
-# The toplevel directory of the source tree.
-#
-TOP = .
-
-# optional build flags
-LOC =
-
-# variables
-STATICLIB = zlib.lib
-SHAREDLIB = zlib1.dll
-IMPLIB    = zdll.lib
-
-CC = cl
-LD = link
-AR = lib
-RC = rc
-CP = copy /y
-CFLAGS  = -nologo -MD -W3 -O2 -Oy- -Zi -Fd"zlib" $(LOC)
-WFLAGS  = -D_CRT_SECURE_NO_DEPRECATE -D_CRT_NONSTDC_NO_DEPRECATE -DX86_PCLMULQDQ_CRC -DX86_SSE2_FILL_WINDOW -DX86_CPUID -DX86_SSE4_2_CRC_HASH -DUNALIGNED_OK -DUNROLL_LESS -DX86_QUICK_STRATEGY
-LDFLAGS = -nologo -debug -incremental:no -opt:ref -manifest
-ARFLAGS = -nologo
-RCFLAGS = /dWIN32 /r
-DEFFILE = zlib.def
-WITH_GZFILEOP =
-
-OBJS = adler32.obj compress.obj crc32.obj deflate.obj deflate_fast.obj deflate_quick.obj deflate_slow.obj \
-       infback.obj inflate.obj inftrees.obj inffast.obj match.obj trees.obj uncompr.obj zutil.obj x86.obj fill_window_sse.obj insert_string_sse.obj crc_folding.obj
-!if "$(WITH_GZFILEOP)" != ""
-WFLAGS = $(WFLAGS) -DWITH_GZFILEOP
-OBJS = $(OBJS) gzclose.obj gzlib.obj gzread.obj gzwrite.obj
-DEFFILE = zlibcompat.def
-!endif
-
-# targets
-all: $(STATICLIB) $(SHAREDLIB) $(IMPLIB) \
-     example.exe minigzip.exe example_d.exe minigzip_d.exe
-
-$(STATICLIB): $(OBJS)
-	$(AR) $(ARFLAGS) -out:$@ $(OBJS)
-
-$(IMPLIB): $(SHAREDLIB)
-
-$(SHAREDLIB): $(TOP)/win32/zlib.def $(OBJS) zlib1.res
-	$(LD) $(LDFLAGS) -def:$(TOP)/win32/$(DEFFILE) -dll -implib:$(IMPLIB) \
-	  -out:$@ -base:0x5A4C0000 $(OBJS) zlib1.res
-	if exist $@.manifest \
-	  mt -nologo -manifest $@.manifest -outputresource:$@;2
-
-example.exe: example.obj $(STATICLIB)
-	$(LD) $(LDFLAGS) example.obj $(STATICLIB)
-	if exist $@.manifest \
-	  mt -nologo -manifest $@.manifest -outputresource:$@;1
-
-minigzip.exe: minigzip.obj $(STATICLIB)
-	$(LD) $(LDFLAGS) minigzip.obj $(STATICLIB)
-	if exist $@.manifest \
-	  mt -nologo -manifest $@.manifest -outputresource:$@;1
-
-example_d.exe: example.obj $(IMPLIB)
-	$(LD) $(LDFLAGS) -out:$@ example.obj $(IMPLIB)
-	if exist $@.manifest \
-	  mt -nologo -manifest $@.manifest -outputresource:$@;1
-
-minigzip_d.exe: minigzip.obj $(IMPLIB)
-	$(LD) $(LDFLAGS) -out:$@ minigzip.obj $(IMPLIB)
-	if exist $@.manifest \
-	  mt -nologo -manifest $@.manifest -outputresource:$@;1
-
-{$(TOP)}.c.obj:
-	$(CC) -c $(WFLAGS) $(CFLAGS) $<
-
-{$(TOP)/arch/x86}.c.obj:
-	$(CC) -c -I$(TOP) $(WFLAGS) $(CFLAGS) $<
-
-{$(TOP)/test}.c.obj:
-	$(CC) -c -I$(TOP) $(WFLAGS) $(CFLAGS) $<
-
-$(TOP)/zconf.h: $(TOP)/zconf.h.in
-	$(CP) $(TOP)\zconf.h.in $(TOP)\zconf.h
-
-adler32.obj: $(TOP)/adler32.c $(TOP)/zlib.h $(TOP)/zconf.h
-
-compress.obj: $(TOP)/compress.c $(TOP)/zlib.h $(TOP)/zconf.h
-
-crc32.obj: $(TOP)/crc32.c $(TOP)/zlib.h $(TOP)/zconf.h $(TOP)/crc32.h
-
-deflate.obj: $(TOP)/deflate.c $(TOP)/deflate.h $(TOP)/zutil.h $(TOP)/zlib.h $(TOP)/zconf.h
-
-gzclose.obj: $(TOP)/gzclose.c $(TOP)/zlib.h $(TOP)/zconf.h $(TOP)/gzguts.h
-
-gzlib.obj: $(TOP)/gzlib.c $(TOP)/zlib.h $(TOP)/zconf.h $(TOP)/gzguts.h
-
-gzread.obj: $(TOP)/gzread.c $(TOP)/zlib.h $(TOP)/zconf.h $(TOP)/gzguts.h
-
-gzwrite.obj: $(TOP)/gzwrite.c $(TOP)/zlib.h $(TOP)/zconf.h $(TOP)/gzguts.h
-
-infback.obj: $(TOP)/infback.c $(TOP)/zutil.h $(TOP)/zlib.h $(TOP)/zconf.h $(TOP)/inftrees.h $(TOP)/inflate.h \
-             $(TOP)/inffast.h $(TOP)/inffixed.h
-
-inffast.obj: $(TOP)/inffast.c $(TOP)/zutil.h $(TOP)/zlib.h $(TOP)/zconf.h $(TOP)/inftrees.h $(TOP)/inflate.h \
-             $(TOP)/inffast.h
-
-inflate.obj: $(TOP)/inflate.c $(TOP)/zutil.h $(TOP)/zlib.h $(TOP)/zconf.h $(TOP)/inftrees.h $(TOP)/inflate.h \
-             $(TOP)/inffast.h $(TOP)/inffixed.h
-
-inftrees.obj: $(TOP)/inftrees.c $(TOP)/zutil.h $(TOP)/zlib.h $(TOP)/zconf.h $(TOP)/inftrees.h
-
-match.obj: $(TOP)/match.c $(TOP)/deflate.h
-
-trees.obj: $(TOP)/trees.c $(TOP)/zutil.h $(TOP)/zlib.h $(TOP)/zconf.h $(TOP)/deflate.h $(TOP)/trees.h
-
-uncompr.obj: $(TOP)/uncompr.c $(TOP)/zlib.h $(TOP)/zconf.h
-
-zutil.obj: $(TOP)/zutil.c $(TOP)/zutil.h $(TOP)/zlib.h $(TOP)/zconf.h
-
-example.obj: $(TOP)/test/example.c $(TOP)/zlib.h $(TOP)/zconf.h
-
-minigzip.obj: $(TOP)/test/minigzip.c $(TOP)/zlib.h $(TOP)/zconf.h
-
-zlib1.res: $(TOP)/win32/zlib1.rc
-	$(RC) $(RCFLAGS) /fo$@ $(TOP)/win32/zlib1.rc
-
-# testing
-test: example.exe minigzip.exe
-	example
-	echo hello world | minigzip | minigzip -d
-
-testdll: example_d.exe minigzip_d.exe
-	example_d
-	echo hello world | minigzip_d | minigzip_d -d
-
-
-# cleanup
-clean:
-	-del $(STATICLIB)
-	-del $(SHAREDLIB)
-	-del $(IMPLIB)
-	-del *.obj
-	-del *.res
-	-del *.exp
-	-del *.exe
-	-del *.pdb
-	-del *.manifest
-	-del foo.gz
-
-distclean: clean
-	-del zconf.h
diff --git a/contrib/libzlib-ng/win32/README-WIN32.txt b/contrib/libzlib-ng/win32/README-WIN32.txt
deleted file mode 100644
index 3d77d521e83..00000000000
--- a/contrib/libzlib-ng/win32/README-WIN32.txt
+++ /dev/null
@@ -1,103 +0,0 @@
-ZLIB DATA COMPRESSION LIBRARY
-
-zlib 1.2.8 is a general purpose data compression library.  All the code is
-thread safe.  The data format used by the zlib library is described by RFCs
-(Request for Comments) 1950 to 1952 in the files
-http://www.ietf.org/rfc/rfc1950.txt (zlib format), rfc1951.txt (deflate format)
-and rfc1952.txt (gzip format).
-
-All functions of the compression library are documented in the file zlib.h
-(volunteer to write man pages welcome, contact zlib@gzip.org).  Two compiled
-examples are distributed in this package, example and minigzip.  The example_d
-and minigzip_d flavors validate that the zlib1.dll file is working correctly.
-
-Questions about zlib should be sent to <zlib@gzip.org>.  The zlib home page
-is http://zlib.net/ .  Before reporting a problem, please check this site to
-verify that you have the latest version of zlib; otherwise get the latest
-version and check whether the problem still exists or not.
-
-PLEASE read DLL_FAQ.txt, and the the zlib FAQ http://zlib.net/zlib_faq.html
-before asking for help.
-
-
-Manifest:
-
-The package zlib-1.2.8-win32-x86.zip will contain the following files:
-
-  README-WIN32.txt This document
-  ChangeLog        Changes since previous zlib packages
-  DLL_FAQ.txt      Frequently asked questions about zlib1.dll
-  zlib.3.pdf       Documentation of this library in Adobe Acrobat format
-
-  example.exe      A statically-bound example (using zlib.lib, not the dll)
-  example.pdb      Symbolic information for debugging example.exe
-
-  example_d.exe    A zlib1.dll bound example (using zdll.lib)
-  example_d.pdb    Symbolic information for debugging example_d.exe
-
-  minigzip.exe     A statically-bound test program (using zlib.lib, not the dll)
-  minigzip.pdb     Symbolic information for debugging minigzip.exe
-
-  minigzip_d.exe   A zlib1.dll bound test program (using zdll.lib)
-  minigzip_d.pdb   Symbolic information for debugging minigzip_d.exe
-
-  zlib.h           Install these files into the compilers' INCLUDE path to
-  zconf.h          compile programs which use zlib.lib or zdll.lib
-
-  zdll.lib         Install these files into the compilers' LIB path if linking
-  zdll.exp         a compiled program to the zlib1.dll binary
-
-  zlib.lib         Install these files into the compilers' LIB path to link zlib
-  zlib.pdb         into compiled programs, without zlib1.dll runtime dependency
-                   (zlib.pdb provides debugging info to the compile time linker)
-
-  zlib1.dll        Install this binary shared library into the system PATH, or
-                   the program's runtime directory (where the .exe resides)
-  zlib1.pdb        Install in the same directory as zlib1.dll, in order to debug
-                   an application crash using WinDbg or similar tools.
-
-All .pdb files above are entirely optional, but are very useful to a developer
-attempting to diagnose program misbehavior or a crash.  Many additional
-important files for developers can be found in the zlib127.zip source package
-available from http://zlib.net/ - review that package's README file for details.
-
-
-Acknowledgments:
-
-The deflate format used by zlib was defined by Phil Katz.  The deflate and
-zlib specifications were written by L.  Peter Deutsch.  Thanks to all the
-people who reported problems and suggested various improvements in zlib; they
-are too numerous to cite here.
-
-
-Copyright notice:
-
-  (C) 1995-2012 Jean-loup Gailly and Mark Adler
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-
-  Jean-loup Gailly        Mark Adler
-  jloup@gzip.org          madler@alumni.caltech.edu
-
-If you use the zlib library in a product, we would appreciate *not* receiving
-lengthy legal documents to sign.  The sources are provided for free but without
-warranty of any kind.  The library has been entirely written by Jean-loup
-Gailly and Mark Adler; it does not include third-party code.
-
-If you redistribute modified sources, we would appreciate that you include in
-the file ChangeLog history information documenting your changes.  Please read
-the FAQ for more information on the distribution of modified source versions.
diff --git a/contrib/libzlib-ng/win32/VisualC.txt b/contrib/libzlib-ng/win32/VisualC.txt
deleted file mode 100644
index 579a5fc9e0f..00000000000
--- a/contrib/libzlib-ng/win32/VisualC.txt
+++ /dev/null
@@ -1,3 +0,0 @@
-
-To build zlib using the Microsoft Visual C++ environment,
-use the appropriate project from the projects/ directory.
diff --git a/contrib/libzlib-ng/win32/zlib.def b/contrib/libzlib-ng/win32/zlib.def
deleted file mode 100644
index 1d0c8947a5b..00000000000
--- a/contrib/libzlib-ng/win32/zlib.def
+++ /dev/null
@@ -1,55 +0,0 @@
-; zlib data compression library
-EXPORTS
-; basic functions
-    zlibVersion
-    deflate
-    deflateEnd
-    inflate
-    inflateEnd
-; advanced functions
-    deflateSetDictionary
-    deflateCopy
-    deflateReset
-    deflateParams
-    deflateTune
-    deflateBound
-    deflatePending
-    deflatePrime
-    deflateSetHeader
-    inflateSetDictionary
-    inflateGetDictionary
-    inflateSync
-    inflateCopy
-    inflateReset
-    inflateReset2
-    inflatePrime
-    inflateMark
-    inflateGetHeader
-    inflateBack
-    inflateBackEnd
-    zlibCompileFlags
-; utility functions
-    compress
-    compress2
-    compressBound
-    uncompress
-; large file functions
-    adler32_combine64
-    crc32_combine64
-; checksum functions
-    adler32
-    crc32
-    adler32_combine
-    crc32_combine
-; various hacks, don't look :)
-    deflateInit_
-    deflateInit2_
-    inflateInit_
-    inflateInit2_
-    inflateBackInit_
-    zError
-    inflateSyncPoint
-    get_crc_table
-    inflateUndermine
-    inflateResetKeep
-    deflateResetKeep
diff --git a/contrib/libzlib-ng/win32/zlib1.rc b/contrib/libzlib-ng/win32/zlib1.rc
deleted file mode 100644
index 5c0feed1b44..00000000000
--- a/contrib/libzlib-ng/win32/zlib1.rc
+++ /dev/null
@@ -1,40 +0,0 @@
-#include <winver.h>
-#include "../zlib.h"
-
-#ifdef GCC_WINDRES
-VS_VERSION_INFO		VERSIONINFO
-#else
-VS_VERSION_INFO		VERSIONINFO	MOVEABLE IMPURE LOADONCALL DISCARDABLE
-#endif
-  FILEVERSION		ZLIB_VER_MAJOR,ZLIB_VER_MINOR,ZLIB_VER_REVISION,0
-  PRODUCTVERSION	ZLIB_VER_MAJOR,ZLIB_VER_MINOR,ZLIB_VER_REVISION,0
-  FILEFLAGSMASK		VS_FFI_FILEFLAGSMASK
-#ifdef _DEBUG
-  FILEFLAGS		1
-#else
-  FILEFLAGS		0
-#endif
-  FILEOS		VOS__WINDOWS32
-  FILETYPE		VFT_DLL
-  FILESUBTYPE		0	// not used
-BEGIN
-  BLOCK "StringFileInfo"
-  BEGIN
-    BLOCK "040904E4"
-    //language ID = U.S. English, char set = Windows, Multilingual
-    BEGIN
-      VALUE "FileDescription",	"zlib data compression library\0"
-      VALUE "FileVersion",	ZLIB_VERSION "\0"
-      VALUE "InternalName",	"zlib1.dll\0"
-      VALUE "LegalCopyright",	"(C) 1995-2013 Jean-loup Gailly & Mark Adler\0"
-      VALUE "OriginalFilename",	"zlib1.dll\0"
-      VALUE "ProductName",	"zlib\0"
-      VALUE "ProductVersion",	ZLIB_VERSION "\0"
-      VALUE "Comments",		"For more information visit http://www.zlib.net/\0"
-    END
-  END
-  BLOCK "VarFileInfo"
-  BEGIN
-    VALUE "Translation", 0x0409, 1252
-  END
-END
diff --git a/contrib/libzlib-ng/win32/zlibcompat.def b/contrib/libzlib-ng/win32/zlibcompat.def
deleted file mode 100644
index face655183a..00000000000
--- a/contrib/libzlib-ng/win32/zlibcompat.def
+++ /dev/null
@@ -1,86 +0,0 @@
-; zlib data compression library
-EXPORTS
-; basic functions
-    zlibVersion
-    deflate
-    deflateEnd
-    inflate
-    inflateEnd
-; advanced functions
-    deflateSetDictionary
-    deflateCopy
-    deflateReset
-    deflateParams
-    deflateTune
-    deflateBound
-    deflatePending
-    deflatePrime
-    deflateSetHeader
-    inflateSetDictionary
-    inflateGetDictionary
-    inflateSync
-    inflateCopy
-    inflateReset
-    inflateReset2
-    inflatePrime
-    inflateMark
-    inflateGetHeader
-    inflateBack
-    inflateBackEnd
-    zlibCompileFlags
-; utility functions
-    compress
-    compress2
-    compressBound
-    uncompress
-    gzopen
-    gzdopen
-    gzbuffer
-    gzsetparams
-    gzread
-    gzwrite
-    gzprintf
-    gzvprintf
-    gzputs
-    gzgets
-    gzputc
-    gzgetc
-    gzungetc
-    gzflush
-    gzseek
-    gzrewind
-    gztell
-    gzoffset
-    gzeof
-    gzdirect
-    gzclose
-    gzclose_r
-    gzclose_w
-    gzerror
-    gzclearerr
-; large file functions
-    gzopen64
-    gzseek64
-    gztell64
-    gzoffset64
-    adler32_combine64
-    crc32_combine64
-; checksum functions
-    adler32
-    crc32
-    adler32_combine
-    crc32_combine
-; various hacks, don't look :)
-    deflateInit_
-    deflateInit2_
-    inflateInit_
-    inflateInit2_
-    inflateBackInit_
-    gzgetc_
-    zError
-    inflateSyncPoint
-    get_crc_table
-    inflateUndermine
-    inflateResetKeep
-    deflateResetKeep
-    gzopen_w
diff --git a/contrib/libzlib-ng/zconf.h.in b/contrib/libzlib-ng/zconf.h.in
deleted file mode 100644
index 7cacf1b79ed..00000000000
--- a/contrib/libzlib-ng/zconf.h.in
+++ /dev/null
@@ -1,176 +0,0 @@
-/* zconf.h -- configuration of the zlib compression library
- * Copyright (C) 1995-2013 Jean-loup Gailly.
- * For conditions of distribution and use, see copyright notice in zlib.h
- */
-
-/* @(#) $Id$ */
-
-#ifndef ZCONF_H
-#define ZCONF_H
-
-#if defined(_WINDOWS) && !defined(WINDOWS)
-#  define WINDOWS
-#endif
-#if defined(_WIN32) || defined(__WIN32__)
-#  ifndef WIN32
-#    define WIN32
-#  endif
-#endif
-
-#ifdef __STDC_VERSION__
-#  if __STDC_VERSION__ >= 199901L
-#    ifndef STDC99
-#      define STDC99
-#    endif
-#  endif
-#endif
-
-/* Maximum value for memLevel in deflateInit2 */
-#ifndef MAX_MEM_LEVEL
-#  define MAX_MEM_LEVEL 9
-#endif
-
-/* Maximum value for windowBits in deflateInit2 and inflateInit2.
- * WARNING: reducing MAX_WBITS makes minigzip unable to extract .gz files
- * created by gzip. (Files created by minigzip can still be extracted by
- * gzip.)
- */
-#ifndef MAX_WBITS
-#  define MAX_WBITS   15 /* 32K LZ77 window */
-#endif
-
-/* The memory requirements for deflate are (in bytes):
-            (1 << (windowBits+2)) +  (1 << (memLevel+9))
- that is: 128K for windowBits=15  +  128K for memLevel = 8  (default values)
- plus a few kilobytes for small objects. For example, if you want to reduce
- the default memory requirements from 256K to 128K, compile with
-     make CFLAGS="-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7"
- Of course this will generally degrade compression (there's no free lunch).
-
-   The memory requirements for inflate are (in bytes) 1 << windowBits
- that is, 32K for windowBits=15 (default value) plus a few kilobytes
- for small objects.
-*/
-
-                        /* Type declarations */
-
-
-#if defined(WINDOWS) || defined(WIN32)
-   /* If building or using zlib as a DLL, define ZLIB_DLL.
-    * This is not mandatory, but it offers a little performance increase.
-    */
-#  ifdef ZLIB_DLL
-#    if defined(WIN32) && (!defined(__BORLANDC__) || (__BORLANDC__ >= 0x500))
-#      ifdef ZLIB_INTERNAL
-#        define ZEXTERN extern __declspec(dllexport)
-#      else
-#        define ZEXTERN extern __declspec(dllimport)
-#      endif
-#    endif
-#  endif  /* ZLIB_DLL */
-   /* If building or using zlib with the WINAPI/WINAPIV calling convention,
-    * define ZLIB_WINAPI.
-    * Caution: the standard ZLIB1.DLL is NOT compiled using ZLIB_WINAPI.
-    */
-#  ifdef ZLIB_WINAPI
-#    include <windows.h>
-     /* No need for _export, use ZLIB.DEF instead. */
-     /* For complete Windows compatibility, use WINAPI, not __stdcall. */
-#    define ZEXPORT WINAPI
-#    define ZEXPORTVA WINAPIV
-#  endif
-#endif
-
-#ifndef ZEXTERN
-#  define ZEXTERN extern
-#endif
-#ifndef ZEXPORT
-#  define ZEXPORT
-#endif
-#ifndef ZEXPORTVA
-#  define ZEXPORTVA
-#endif
-
-/* Fallback for something that includes us. */
-typedef unsigned char Byte;
-typedef Byte Bytef;
-
-typedef unsigned int   uInt;  /* 16 bits or more */
-typedef unsigned long  uLong; /* 32 bits or more */
-
-typedef char  charf;
-typedef int   intf;
-typedef uInt  uIntf;
-typedef uLong uLongf;
-
-typedef void const *voidpc;
-typedef void       *voidpf;
-typedef void       *voidp;
-
-#ifdef HAVE_UNISTD_H    /* may be set to #if 1 by ./configure */
-#  define Z_HAVE_UNISTD_H
-#endif
-
-#ifdef HAVE_STDARG_H    /* may be set to #if 1 by ./configure */
-#  define Z_HAVE_STDARG_H
-#endif
-
-#include <sys/types.h>      /* for off_t */
-#include <stdarg.h>         /* for va_list */
-
-#ifdef WIN32
-#  include <stddef.h>         /* for wchar_t */
-#endif
-
-/* a little trick to accommodate both "#define _LARGEFILE64_SOURCE" and
- * "#define _LARGEFILE64_SOURCE 1" as requesting 64-bit operations, (even
- * though the former does not conform to the LFS document), but considering
- * both "#undef _LARGEFILE64_SOURCE" and "#define _LARGEFILE64_SOURCE 0" as
- * equivalently requesting no 64-bit operations
- */
-#if defined(_LARGEFILE64_SOURCE) && -_LARGEFILE64_SOURCE - -1 == 1
-#  undef _LARGEFILE64_SOURCE
-#endif
-
-#if defined(Z_HAVE_UNISTD_H) || defined(_LARGEFILE64_SOURCE)
-#  include <unistd.h>         /* for SEEK_*, off_t, and _LFS64_LARGEFILE */
-#  ifndef z_off_t
-#    define z_off_t off_t
-#  endif
-#endif
-
-#if defined(_LFS64_LARGEFILE) && _LFS64_LARGEFILE-0
-#  define Z_LFS64
-#endif
-
-#if defined(_LARGEFILE64_SOURCE) && defined(Z_LFS64)
-#  define Z_LARGE64
-#endif
-
-#if defined(_FILE_OFFSET_BITS) && _FILE_OFFSET_BITS-0 == 64 && defined(Z_LFS64)
-#  define Z_WANT64
-#endif
-
-#if !defined(SEEK_SET) && defined(WITH_GZFILEOP)
-#  define SEEK_SET        0       /* Seek from beginning of file.  */
-#  define SEEK_CUR        1       /* Seek from current position.  */
-#  define SEEK_END        2       /* Set file pointer to EOF plus "offset" */
-#endif
-
-#ifndef z_off_t
-#  define z_off_t long
-#endif
-
-#if !defined(WIN32) && defined(Z_LARGE64)
-#  define z_off64_t off64_t
-#else
-#  if defined(__MSYS__)
-#    define z_off64_t _off64_t
-#  elif defined(WIN32) && !defined(__GNUC__)
-#    define z_off64_t __int64
-#  else
-#    define z_off64_t z_off_t
-#  endif
-#endif
-
-#endif /* ZCONF_H */
diff --git a/contrib/libzlib-ng/zlib.3 b/contrib/libzlib-ng/zlib.3
deleted file mode 100644
index 1cc38059d78..00000000000
--- a/contrib/libzlib-ng/zlib.3
+++ /dev/null
@@ -1,169 +0,0 @@
-.TH ZLIB 3 "7 July 2015"
-.SH NAME
-zlib \- compression/decompression library
-.SH SYNOPSIS
-[see
-.I zlib.h
-for full description]
-.SH DESCRIPTION
-The
-.I zlib
-library is a general purpose data compression library.
-The code is thread safe, assuming that the standard library functions
-used are thread safe, such as memory allocation routines.
-It provides in-memory compression and decompression functions,
-including integrity checks of the uncompressed data.
-This version of the library supports only one compression method (deflation)
-but other algorithms may be added later
-with the same stream interface.
-.LP
-Compression can be done in a single step if the buffers are large enough
-or can be done by repeated calls of the compression function.
-In the latter case,
-the application must provide more input and/or consume the output
-(providing more output space) before each call.
-.LP
-The library also supports reading and writing files in
-.IR gzip (1)
-(.gz) format
-with an interface similar to that of stdio.
-.LP
-The library does not install any signal handler.
-The decoder checks the consistency of the compressed data,
-so the library should never crash even in the case of corrupted input.
-.LP
-All functions of the compression library are documented in the file
-.IR zlib.h .
-The distribution source includes examples of use of the library
-in the files
-.I test/example.c
-and
-.IR test/minigzip.c,
-as well as other examples in the
-.IR examples/
-directory.
-.LP
-Changes to this version are documented in the file
-.I ChangeLog
-that accompanies the source.
-.LP
-.I zlib
-is available in Java using the java.util.zip package:
-.IP
-http://java.sun.com/developer/technicalArticles/Programming/compression/
-.LP
-A Perl interface to
-.IR zlib ,
-written by Paul Marquess (pmqs@cpan.org),
-is available at CPAN (Comprehensive Perl Archive Network) sites,
-including:
-.IP
-http://search.cpan.org/~pmqs/IO-Compress-Zlib/
-.LP
-A Python interface to
-.IR zlib ,
-written by A.M. Kuchling (amk@magnet.com),
-is available in Python 1.5 and later versions:
-.IP
-http://docs.python.org/library/zlib.html
-.LP
-.I zlib
-is built into
-.IR tcl:
-.IP
-http://wiki.tcl.tk/4610
-.LP
-An experimental package to read and write files in .zip format,
-written on top of
-.I zlib
-by Gilles Vollant (info@winimage.com),
-is available at:
-.IP
-http://www.winimage.com/zLibDll/minizip.html
-and also in the
-.I contrib/minizip
-directory of the main
-.I zlib
-source distribution.
-.SH "SEE ALSO"
-The
-.I zlib
-web site can be found at:
-.IP
-http://zlib.net/
-.LP
-The data format used by the zlib library is described by RFC
-(Request for Comments) 1950 to 1952 in the files:
-.IP
-http://tools.ietf.org/html/rfc1950 (for the zlib header and trailer format)
-.br
-http://tools.ietf.org/html/rfc1951 (for the deflate compressed data format)
-.br
-http://tools.ietf.org/html/rfc1952 (for the gzip header and trailer format)
-.LP
-Mark Nelson wrote an article about
-.I zlib
-for the Jan. 1997 issue of  Dr. Dobb's Journal;
-a copy of the article is available at:
-.IP
-http://marknelson.us/1997/01/01/zlib-engine/
-.SH "REPORTING PROBLEMS"
-Before reporting a problem,
-please check the
-.I zlib
-web site to verify that you have the latest version of
-.IR zlib ;
-otherwise,
-obtain the latest version and see if the problem still exists.
-Please read the
-.I zlib
-FAQ at:
-.IP
-http://zlib.net/zlib_faq.html
-.LP
-before asking for help.
-Send questions and/or comments to zlib@gzip.org,
-or (for the Windows DLL version) to Gilles Vollant (info@winimage.com).
-.SH AUTHORS AND LICENSE
-Version 1.2.8.1
-.LP
-Copyright (C) 1995-2015 Jean-loup Gailly and Mark Adler
-.LP
-This software is provided 'as-is', without any express or implied
-warranty.  In no event will the authors be held liable for any damages
-arising from the use of this software.
-.LP
-Permission is granted to anyone to use this software for any purpose,
-including commercial applications, and to alter it and redistribute it
-freely, subject to the following restrictions:
-.LP
-.nr step 1 1
-.IP \n[step]. 3
-The origin of this software must not be misrepresented; you must not
-claim that you wrote the original software. If you use this software
-in a product, an acknowledgment in the product documentation would be
-appreciated but is not required.
-.IP \n+[step].
-Altered source versions must be plainly marked as such, and must not be
-misrepresented as being the original software.
-.IP \n+[step].
-This notice may not be removed or altered from any source distribution.
-.LP
-Jean-loup Gailly        Mark Adler
-.br
-jloup@gzip.org          madler@alumni.caltech.edu
-.LP
-The deflate format used by
-.I zlib
-was defined by Phil Katz.
-The deflate and
-.I zlib
-specifications were written by L. Peter Deutsch.
-Thanks to all the people who reported problems and suggested various
-improvements in
-.IR zlib ;
-who are too numerous to cite here.
-.LP
-UNIX manual page by R. P. C. Rodgers,
-U.S. National Library of Medicine (rodgers@nlm.nih.gov).
-.\" end of man page
diff --git a/contrib/libzlib-ng/zlib.3.pdf b/contrib/libzlib-ng/zlib.3.pdf
deleted file mode 100644
index a346b5d7e24834806b0871b209637c728fb36d60..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 8734
zcmcgyc|6o>+eadkB}+)9$uc7`yJ0M2-wiSxOO#;-leL+#muyG-WLHRJUy>zz3rU6S
zLM3F05=xee>iv!CoX*pE-sgEgpYwTt|G4M+UDtJgukF6C`~H!&)H6^-!Z0A&2X8K1
z1u20MU|*LbAa!-P8O6t);Q_`16f3v^)r&!)f#C*TBnCx~;_6GL;PD_jgGM2FgM!j?
z9a`guYXxtu+KypMPQgUjw>eI>FBw(nR$xtcGv6}0B05}bkEZG;*B0dazZDz0GJb*q
z!A4dYp#x^RbEPgCO)f4{uHqA7Q9|RI?`wvfO7IYJ-{EL7{oTjN!jt#b_XSMmd)md0
ziw&-decEjxWF9XkHQ2B<F4y{Q{)4k))5_Pw>iO=?Mb=uJojv?wj&~&Qk{-JhWY8BD
z8EET!7#8-Hvw79@e(SPCzn1;s+1JeVlOl6Iqe;gPS9Kh53i&Gi_NMMDg-(z3aI3ek
z<NM@nu21g{R(%@Us(acqMImorsQ~`-#Pc<QD~FEvnqKhd@%dEIFJSMHK{M!6X<uS0
zoAl_5a4{M_Onq8zLFGg`ie+FViE(a)hxQED$T9n5T5R_5HHF0m4?Lf!wA3^ru4>s&
zLd0iNOWJSGh?+vE;t;8Vl}$tAVpZ?g3lzwSxt9V5#Ne75Uq8HVUM^l;=#*Ry31vKu
zrM<Xed-C$FM^+MPCp)D%4)Hv}rIba-C``Wez?@rpRg^JFCSoZy;lyZ#Gf_7oYl7zc
z?>djJ$l6cqnloM4x;lFkA&bMzF~*I3Gc6FqZcleF(Wad%5s&4DlFJ6`Wip4#=Gu-C
zJ~`sHI6jiOopMwnbb;sdp<v@hV}@Do*5u5E2TqT@61T<aV~icU`xH9+XPdEmoSWm9
zbVo|w`^-sc2$#vd7%lUJpxmm;7v~@3HG*HY4yAa;2Ts*ZAestA?x&rjNwanKtxe;q
zTJ5}yM-rUsJd=tzZn3w!8dFk-CN!sRxBf21X@B)zzyHC>0)<ykj~1j_dGkW7_azyn
zn#|s^O^`EhZoL+zYIP6YX8&?LWVG-`v(sGi>BJ*l@a>Z#g{isuH$@!Q&PArAue99A
zb#S>Ma5J3qLLANv_r6P}5|dY6cCxPI=FOAaAGui*`zItgxcYaRY{w4RBJ*`j+#+0s
zz*LtwYLHY*wSuTZw!M7zSQd0nBPN+kUhpJ_Lt1=iM6<to#9f0ETg1$8MUetR=bmWY
zuQJP@TNYiMXpb~3<L-*AAm$IO1%2G1<6*C&CRo33DxMIhxHJ(qyzq?4+ZG_0zi+F+
z_AO8I!lb;3oqi-+{$~LMpD6#23&#qjBC}h@gX7qRn~uoY25x1>N>@7XGTNFND05v|
zkwY<k|Aet6-?QEK0!z(Zd(zl%xDThU@#M(tJHumg%N!RCl?)%@oK>=`>f|087mR*w
z))jbhJ~mNpidwMgu8#8on8=VjRjX?B;yJmqP-k~*+GTu~hOkJm?mQc+2eX|M@@g;h
z$Z+0pf=Pp+Hcm{CkMM|d;#MRl+gLxnda~Rgvefp&f$8UYGL$}Mnj$;*$I$206SOv+
zw0H}MY?GZcH+N9{j>(0#<2+pUQR(&7NE35eK_`U?L`05Rr0scT*)c7mXz=xH2@?xZ
zYGreI4k4$#>3T`8E}}JOfFpWp?YPqpwx@OSn3YZ1>y4I;7@bBi+jhu#mGtfRIwp#a
ztZXw5=h}}EAb+jhpLCne^TQ;zObA)4B?ZB?-Prm`BS=!Z^5$W-<U-1a+DGiv9&=T3
z2Jg)#`aOxxQtzjq{q}MabU$8GRgbtR?6=9L#`m=OtriqWsYg5{Qfbp;y>p@Ixm;mu
z*B!D7NK#CEnYGo+aG&>8Pxo}6JckmaHhDLWJ*r`Ue(d)<@*>hN%kyPzbJ_ZCN0F_~
zH_sycW*EG}Hu4Q%#I0yhHm@+qie#(JyHh;6mMo>l8IxR~!`n0@Fk9qgr|Z#h62sp|
zTw(V5UQ#o58h)}ms5o?u%H1st!Xs|p>`CG<zjil?n6V|r<ksOR=hILN+wmiPY~D{J
z6JA&JJx*vbiI2V)H_(e;V-JdBcHTW&7Jdy`==JWQO!IhFWyP!gjj?$_i$eZXD|XR#
z#3kY2JMnA@9{G1O!?|9M1se!UH<gt>mL)x7E~jF0Niav7W}|LIwU^Wft4|_3dxKmg
zv~BI$vNPBXS2Cs~jbwyB#}HbNX<k?gbFECvEX<T)Q#94@<~?NW+_+Ow`!|T;x=yI5
zw>xTUoZGOpyu1Q(s4JWE$V&8Q%O*bm`pE7}1tUDX{*aVzc#C@-Dw;ZJ^ioEWbmF-v
zo9p=j<JOZonjT`}B34aPmtM-n7@6|dOKVTGZl+sh=$D_j<uyH}*3rdzUeBfOf{zin
zuD9DJ{eX7RDAOrxH?(nU)<w(Iyh!^T1LkI&oqW1J|NDctpGl`i2pY~M<5Jj167RiJ
z=G}7Jp9`~db3)6fO$qutme}vcRafl!%|L7m`?a&hA~z6ho*iPkGWUm{a#VcLTT4EQ
zPvBQH%8j+Nb2%`>rz7bo*~Tro`{)8@SmbnuI?VC`!X#3NRIKcmD&=IsKW0rY>P<p<
zx_Bo=-G8!AARWyJ7D~KBC}+=4U36-9*o~<=ZSq1FeyzAvA!gtMNVJ7WFAkcI&(&F_
zU|W`WGB)M-Xt~;mL)vyCO@q7KA8H#<zLly8JyP!bw8Jr!=eTg18*h=w)aE?;h;?p^
zi}1*nQ6u8a3%qHDRvy}y!>=MVC1G#*<|`BFoSo_~j?AkyKEM^^1=e@4h4!EEyIpNQ
z1<H&oQ?qz^m><!%>BX_7{pp_RaV}$7Cob<7kBCedeh;$JicZyeBs^ww=8dc3iHFKl
zXx*Z{sO)a#fdKK9uHTBI__FkwcPbBRt(9ku6+aF+q$J`S=x8X$oEXes$@f{M)JU|s
zJY(B`?Rutg5$N2Kz-6YG?fuM5y=2$R*Id+gX_Tx-q(UU(=H>P}vYq+eJ)&43>{(Z?
zp{y%Og2O89wrcf6O5--z5+eK3PR`$pUf3A%h<JGjgqt`=@9Mae9&qTP&Plbp^~Iir
zGdoIaMBb2XcWE_r$JTkl$_1*0uG}Oxms{cV-3TKupHB;xoa78!t@~OYek{kkrq0PR
ze&Wq(S2^p^v!Y3AMX=DifGB%T+}HKy$X5fH+7RwEe4wML5ytKfL8Z-`XV@#*q4Dgl
zkWQxTXFs(7H<gHS8(Xhw9o!0^u>76(r*pU=Q*S+(+X;s`-r{Gn5VrWrCmJ(FGu3S4
zNc)F7FMtayC?ib64C)v&Q|**_j^E*zep`+lulfY7_gQ}Zxp$?#{mR~9YiwiBrC#TK
z<LFD_3aZA>#dW6T8DE>LFDvb|H1x{Z!-mG5%bK%uENHlP!o6U2`Of~{%O0g$E_y;r
zj}5l?n4ipVTPmD6X!4~f6gtM^T7FINlyBA~e!aF`nScX#*Ui+#URS!uuf7Iz$T)X`
zsE3y;R^@sSk<uBwIooPEJ0z1s>B*xOf5N;{?ON&0a&7k9`oSuq8~bz5lqSQfY*51K
zx7umWJWtaXuI(~Mo_J(h(_D&gtdTV>d;IzHV-<$$yTThxoAc+#j~cO`Gz<19cawYV
zPH#2cH3!L3F=sw_optps$8O2r1QAEQ-wgR8`}H;-JZDg&?dbo+uw_iS;I|x|PYK1%
zx^?gG?wT!Kp}jnHUif&n36i#7>Ea5M*C>)*^3Ab`0;#a;pQXxcF8g_5C2BD~r!71_
zZ3%G+D3E=7ZT5P8r4CGBPO|pvUVH9SCPSoohg3A3@|qw!Znki2RqxCAB3qj@_XyJa
z+Mu<P<nlsW@9Xe@n(9NT#tx@ybh!&Hr};XQie8Si(AFlTEssC!qn%lL|4Kgd{#W)q
z?yv(&Z9;M}l{bV>uYCAW8ymCIXS`>^p(Ww=?ZWv({Z&WI%HRh&307bM(b&6YMD8Se
zd3=9j+YJG_7{&6+u$C(=qzAj{!{^R9l<BsaY@x5Y33D8x;>u}*S?r(rm$soUcd5q~
z&My|>cqO^2AMr;`n|&GOOdU(R9az8Ew_-?VhCo8b7X>&p37<ndQ{b(S(<~MQLUI<I
z)_0%8se$O%CpA0W_YSAgI0N6eCMgR(c!L!tqw}JO)zY7axWp{{_o_2tXlFzvuE21A
zXx$5ehxQo0*?!rpl8O+_<n-I-bE3jX8~y$I&$D-cE*<s%Ey9*mT58_xR<bK=e{ESq
z{XliLxMld2EvgH@MVB+4Y8>6(G{WI3B)cy<+RCWw4!RVgfIKFY{7Lip(j|4eYf{=+
zR~I`PpKNr5n-Zpue=8OJ?n{8S9YoiZl&sG5kZ27qX$H;vH{2>xhnmiJS6A86i)k0v
zugSw8t3?g){=Aw9F}}+}*U#1b4vJVsZ`%_q3OXIlyI2$h_jelO@rt_~Pz<?ZT1jSR
zevL|flb9Ox3S-u+j9$CZmiu~IXw=#q{_#%IM1Ep(Q&$9^eUS6*{whUxj7X5{eB5as
zN|v^ifP7&1DH_(PQpRm$rId5bC-Y{F^VMAsAZK$eqhxjztRznc&Z+ErF1;lYdV&4b
z*aOj^E8vp%9TybYd}P$#d7j-zK)*Rq@o?wE+XLX8i)^V}4<i*K;-6el;lqffa?BJw
zp4L}>#_h`-)?YrmW4`WSXIkbhqOF-x$wC;S)pK*sN`~sp;VWUI?;j1tL9Tx#+gO_E
z=_SfO;&XJf9o#|R)EuB0>KU*gre5VfQm>4W$zG3*bv<RD;&Qqdrs1{|N!0ZF*qk7H
zPzXf~N)~d^m)#Wp;mD|<Br0n{;Gl%`l^4qJ>+mmJU%zbq6z`x*@gaXdqyZz=!H#vD
zWBo;ARM4RBG$iJiQy-Fb5d4qFzT>vfXcKzdj<4F9y^|rnBbQ3>99p?sp+JU{J93TW
zOv<6vcJ?$G-2FAaw_S`b{fb*#r>t8B9xXAh;E&fYYl%-qzkseE_JX7g#+20aNEf#@
zM>psTeNn_tKG}sOe{c@deCMu$j1<p(cnlpEY@l@PnMM3)=^>2<!sJ{c?`Yn8O=wvl
zgorw9?iQKX>+Q7qd8N3$ozN36P<5?7FRx)fe!8xXyz49ex2flk28t`HQ#>XYRk_7H
zN_)=kNS)l*(JiMNrQEuFHqiHae&m7s4AhC`m$Jdi>&MpKyl$CY?HipQ-SayKtfN+I
zYb!eRLZF{MpF0PKUL~djHSO8w(EHT8Z(Op4T13FkBfosQU1FO9epX#auc0+3wE4gu
zR#)h|x4L+Xb+Q}VfZRoeVIl<mvczLEJ*xDr>7b;SB$D^>59uu;;VJi{ZK8Pw-7lJ}
zgeDfQ54DZh<LY;+yQ?dV_)k1PgAzQSa!dBOuH^Fr2L5^LcP|<|i(mW_KC5Hd@hHEn
z<ZQ++bt!p5>TY{6el9;dkDCY3MK^fEXl<WcCk0C-Z<!PhOy6hUVYU6%T*yL}Ng=6c
zTM(9BE7#a`Q9Un}2)Q-u^rSzhPIHs3y!@rkuI?nv#3Jt@LdU7G!H${YOvm=x?(5zS
zaJ5hueTlaFm119yu0ZN$&sIP_A5Cw(q}~U*OaCIa9M2fg5gNumz;99Mx}>!dR|+pa
zV|TJPc3;Ot?ujI)g$n+MFWa79?lU`S^J!i@Bv0hRD^hPtJ=EXxY_6`o+Zhm;qEPUK
zIG|IN_Yqgt82N_R)-nMzFm{eO<@xqm{^Wxu=vXS-6Q1fbU-rA3Xi>)bq7cJ+Nk?n;
zC2~j$J3JfF_&5<JZ*QgE?SH3G9eP<Ny06t~+h*fFWXLP(`FKmlp0bxcCg4ERf$FEK
z#4W|`N^GunylJ;JTWpvyzbkv~%@R<1s6?)5UOE){SikbgQ2j!gc+Y!i@r9`X`Kmj~
z*tyq{jn&WY>2r?8ZoQMZT=DKqGsY&W`%ObRtm0x>X4a^q)7}R+4BP0u{kuw!^Qc$s
z{uq3OX3>~ebf*5KTKiM!aA+!YtpcXp(q<mK#GiiWa<AQchu@FwDgMaw#^Qtove!BX
zRn)WIP&2roX(16SCaoPW^*OBiflCp&L}{Dy%a4=o+|i<D8ot$~1Zt7Ke5dR@n^28|
znqqu<+oMVMYM=OLlekRI4%05qD50+-qRS;m0uC-#unqHv_g?vcp5!wXPZfH}$0YIG
zfjw=MNT}<MjzEcrHuoXZdHYe-SIG8Huw)_;cmG717sxTx%DREz)T@7BIiNf*psv{w
zT)cbOR`{G;i`>h@BQo#(pTw2cEvyn}Hks>zz^dw;q@z11@)nZqxlZx$Gd{ls_#B2T
zPL6M_fUo&i&h7<^oxQ3~a8lqEITRyd!oN~GSit^v^18QY1AnliPqht??VF?S$;4BE
zvG=Ze=kI!w?9TIcVViS%QbU`~I2g5*<hiv+fVo@VWQ|}oNZc%!!wVYBsFp!U^ImY1
zyrAx8&A&;9V`((|CRh0;K@4-WJg)$w4Lh@2t1n=(^Qw-5v5ly9K84>3BoVnv=K^7w
zdwL5HVc?w76Ml0!4n`%{<fcwe&0L9QH#qN1l8robqi=_Rl2d?r<x{r_Jr{1N5$6SQ
zp@m)SJ@Fykg9E?kQ(-nnY3t`Q*x4tJ#cCPq%$j<jm{+<dD5?52ZRLh@mecAV&hUT)
zx!-1fiCl!Y55Pj$n$GV4WjuJnO(w1xvlVi86g<0YZe2Wpe=~MbtiwiFuNj)M-}nIt
z)Oy|%`q6uKZ+$w=Lj|cGT~?*bFd=rvTxwlb0_(&qj%8?%ri@sK!DQ(c;(X7))K<Oj
z=l1#<;bY<WJ|bC>GO6Hvm6CHW&o5qvmRhtVyfb!Cwr(r^pj(WTTDt$#uDn}`CwwmU
z=Y!Om9Rz{<i%Ph<?D>2d{=}$9kmrlF52v(@E!VY<tOaTWiF-SjHOpMwHL{y-%Cm!5
z4cot{+jD}U%GFAaQqK&Yd(;(oT+*<6uria+%I0ikrUk@ZapDspvPAytA(7j%3%Ay5
zS3Fwr$)XPrJXx)diCvHNz2TmSKrFxVnDtXi8gdVcL5t2WZ90z|P<+;G_xb$u<=sZr
zwxZ1>wt<Ol#m6%aRGj@3wUZZgU61U!GiVCD<}ZB6!A*XKB5>-8#i`4C_6F|X268;X
zE4*o`<;_juyA2Lc-qd&V@Lh=K4|$$3AZ}LJtnl&hB91fe14?nW5~F>j@6Cw{hHCg4
zcFPp_!$<2VOXoeaX)*n<<Brp<KCTB(ab+DGJIl}eTBS-R%(~SB=5lcTRY&pRtPv(t
zbo-OY8!_bOQzY@#X0Bn)nc){9ZFLc793;)uQkyII1b%8r=-uqHQG|ki(}h@U`*yR#
zr3VD=XT?7@ia&eQEV4<=#3J2eF-YM-dUUSx1NTRMTv1c_79-lJ`J$We?*h(t$^ODg
zfJI6)=Ui;DJ=3!VlQ@{k+#2M+XDIE$alz@_0qzeurPv#=K@rSTg3uZ0g`*C7GrVRo
zCOTVmRfQW@UscPhcm#`K&R>%i{4m*aY*G5ym(7Vf=)zxmfsIX`)eInUSd|~mz)!t^
zb+8`=Zb@>dzzGyGm89bv1U`rW`T{Hx1y;tPoIr3ZUj}d=3`PK4G>Q)cjAnHW0GUGf
z^{2T~=)g6yCC%5BNMRg=0~gI;xHTn+0m$hGF${?tqDbU75d&X99MH>>2X2<(y1;Kh
zBOScah_FaMnibX@-><0uUjS}gfP>)Q04o0qaHD(L0R0`|p8x@S0T+Tdd`JhwO{ru$
z_#lYoVJi^wo3EU}fT{j~?Wmt^{Huuo3yDGU@^$~A>ARZ=6b6Y5ya6L|KVW@_z=HX+
zkN)sC2yS6X03-4EAKqlS|2wCZGHAoRpM1@V$B(y21PIBBz7^aG2ilkrZlwZJVNrgP
z_|abik^dWgKjE_a@AR=|{Ek3}M5nN#05_s|1yC4NSCXQIix>5%KV`$s8xaD*iT*AO
zR^GBa57_x5ZCHT+y&fH3FY<q(gk|i%Rr0gEz7Oz)gzDoCMsE1$-+|hA`(5EiF8`2&
z>rvg@C_qU8HFOY!L}B3!su!68LShhbH!9rC3xrfg!@a3K{&c55ZQMwMpVj?HkUza*
zM=<;GVF!uEVDb3xrvr7(AU~3;Cxroap}13hG@uI&cc5S@Sp#aTL_iSybSWNGqYxT}
z7-DYi8sh1SBSSUuAazX=aHyat29f*}-8Q}u(ZLkDtA>=Wm6?GQiy=rg$lK2w$Ww5T
zx0erHHAn-xA)*S5S!6gAyurfo)PUL%EWr$4UoTH8Pz^8~45^4jD}dc-ByUQfFU=E-
zgkhn8N*dWs)e2Zkz9|HLX+S*~3_n#kJTNd27Kn!V(%j)l91aIZpx`K!BEX?Y5B6b@
zf)st|(!hKhK&W<qi22ZA8<=3OzTR-E9UKWmz<*4n2be>n`Z1`!K48|wBo|+Qh6dE%
zpGsC$A|aJgu1aJ@ii$Eu5s9Rb6%oLrNWx-W+{kEGlq(tcV>-W|VE$!3-~})t8t?-!
zQUw-EvcD^ZrU5myGy@xY_|h5Q<_F_o2qh@|yZQeVDj+t0?*$;B-`$`N@Td}iWOfVI
z1D1L`3V}o`A~1?56>B6`6@gY|{Zv*(Ak^Xi!U+T)5Y+{~5CUHe{|nKdIDZoLrC9?h
zfp@3*y19V^C^R}N5=a;l2Sa_EaYO7ompYskqo2I<Py37HM<D#~9`p8Qr8J9ARnOPe
z-y7J&jP?F63G+|KnC$uoU_XDF*G6@aUEvfj3JV(@2s08uOm<au^QC!{fZQhe`FR0r
zD=X#UKu$vO>cC3|mElFfZ`7W)7vtN&i^{4cRWFi{y9P8!kxX$T`Fk;-cpIM$Zt}Ni
zcv11+1{-qlKXv_0tTsqMZ3AJ0|FLr5LEwMr`R5e<xm*JKs0K8UwHN}Uzh1Tcw0Zuh
zYq`HG>wQ4C!>SU%;jB85(^F*?83Kb+L1Gc;jrxKj5Kw>(sKfuj@x2=4{;pp3{juu@
z(I{>p1Q>+?u@<av4;ZVYgjNE(fxpv$se#>^^?-eT&{PnpUua4=WuS-nE1wb;1MIhd
zr6CZkcJr?^v=SEBAOA|jA`yV&{)L9Y{344*D+9g8zwn_EKx_0bG$iJ4Xv)9PlvEJE
zU`8vc{DMyji~5CzMWKGtheav<N>f7pY6lhpG=x7eGiW5L7lj7={{<LMq=ry{7=eK<
z+ZX7KS&bGLZtUac3;xz7!;SU82h|O<^>t8aJp-)14ps@RkJLx1pm0h!eXNcy3Z;b6
e$Ny&zCsyl8XOL)&jl@tvsvtqKvicSVp#K4G_#7?(

diff --git a/contrib/libzlib-ng/zlib.h b/contrib/libzlib-ng/zlib.h
deleted file mode 100644
index 3a1cbb2f05b..00000000000
--- a/contrib/libzlib-ng/zlib.h
+++ /dev/null
@@ -1,1728 +0,0 @@
-#ifndef ZLIB_H_
-#define ZLIB_H_
-/* zlib.h -- interface of the 'zlib-ng' compression library
-   Forked from and compatible with zlib 1.2.8
-
-  Copyright (C) 1995-2013 Jean-loup Gailly and Mark Adler
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-
-  Jean-loup Gailly        Mark Adler
-  jloup@gzip.org          madler@alumni.caltech.edu
-
-
-  The data format used by the zlib library is described by RFCs (Request for
-  Comments) 1950 to 1952 in the files http://tools.ietf.org/html/rfc1950
-  (zlib format), rfc1951 (deflate format) and rfc1952 (gzip format).
-*/
-
-#include <stdint.h>
-#include "zconf.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#define ZLIBNG_VERSION "1.9.9"
-#define ZLIBNG_VERNUM 0x1990
-#define ZLIBNG_VER_MAJOR 1
-#define ZLIBNG_VER_MINOR 9
-#define ZLIBNG_VER_REVISION 9
-#define ZLIBNG_VER_SUBREVISION 0
-
-#define ZLIB_VERSION "1.2.8.zlib-ng"
-#define ZLIB_VERNUM 0x128f
-#define ZLIB_VER_MAJOR 1
-#define ZLIB_VER_MINOR 2
-#define ZLIB_VER_REVISION 8
-#define ZLIB_VER_SUBREVISION 0
-
-/*
-    The 'zlib' compression library provides in-memory compression and
-  decompression functions, including integrity checks of the uncompressed data.
-  This version of the library supports only one compression method (deflation)
-  but other algorithms will be added later and will have the same stream
-  interface.
-
-    Compression can be done in a single step if the buffers are large enough,
-  or can be done by repeated calls of the compression function.  In the latter
-  case, the application must provide more input and/or consume the output
-  (providing more output space) before each call.
-
-    The compressed data format used by default by the in-memory functions is
-  the zlib format, which is a zlib wrapper documented in RFC 1950, wrapped
-  around a deflate stream, which is itself documented in RFC 1951.
-
-    The library also supports reading and writing files in gzip (.gz) format
-  with an interface similar to that of stdio using the functions that start
-  with "gz".  The gzip format is different from the zlib format.  gzip is a
-  gzip wrapper, documented in RFC 1952, wrapped around a deflate stream.
-
-    This library can optionally read and write gzip streams in memory as well.
-
-    The zlib format was designed to be compact and fast for use in memory
-  and on communications channels.  The gzip format was designed for single-
-  file compression on file systems, has a larger header than zlib to maintain
-  directory information, and uses a different, slower check method than zlib.
-
-    The library does not install any signal handler.  The decoder checks
-  the consistency of the compressed data, so the library should never crash
-  even in case of corrupted input.
-*/
-
-typedef void *(*alloc_func) (void *opaque, unsigned int items, unsigned int size);
-typedef void  (*free_func)  (void *opaque, void *address);
-
-struct internal_state;
-
-typedef struct z_stream_s {
-    const unsigned char   *next_in;   /* next input byte */
-    uint32_t              avail_in;   /* number of bytes available at next_in */
-    size_t                total_in;   /* total number of input bytes read so far */
-
-    unsigned char         *next_out;  /* next output byte should be put there */
-    uint32_t              avail_out;  /* remaining free space at next_out */
-    size_t                total_out;  /* total number of bytes output so far */
-
-    const char            *msg;       /* last error message, NULL if no error */
-    struct internal_state *state;     /* not visible by applications */
-
-    alloc_func            zalloc;     /* used to allocate the internal state */
-    free_func             zfree;      /* used to free the internal state */
-    void                  *opaque;    /* private data object passed to zalloc and zfree */
-
-    int                   data_type;  /* best guess about the data type: binary or text */
-    uint32_t              adler;      /* adler32 value of the uncompressed data */
-    unsigned long         reserved;   /* reserved for future use */
-} z_stream;
-
-typedef z_stream *z_streamp;  // Obsolete type, retained for compatability only
-
-/*
-    gzip header information passed to and from zlib routines.  See RFC 1952
-  for more details on the meanings of these fields.
-*/
-typedef struct gz_header_s {
-    int             text;       /* true if compressed data believed to be text */
-    unsigned long   time;       /* modification time */
-    int             xflags;     /* extra flags (not used when writing a gzip file) */
-    int             os;         /* operating system */
-    unsigned char   *extra;     /* pointer to extra field or Z_NULL if none */
-    unsigned int    extra_len;  /* extra field length (valid if extra != Z_NULL) */
-    unsigned int    extra_max;  /* space at extra (only when reading header) */
-    unsigned char   *name;      /* pointer to zero-terminated file name or Z_NULL */
-    unsigned int    name_max;   /* space at name (only when reading header) */
-    unsigned char   *comment;   /* pointer to zero-terminated comment or Z_NULL */
-    unsigned int    comm_max;   /* space at comment (only when reading header) */
-    int             hcrc;       /* true if there was or will be a header crc */
-    int             done;       /* true when done reading gzip header (not used when writing a gzip file) */
-} gz_header;
-
-typedef gz_header *gz_headerp;
-
-/*
-     The application must update next_in and avail_in when avail_in has dropped
-   to zero.  It must update next_out and avail_out when avail_out has dropped
-   to zero.  The application must initialize zalloc, zfree and opaque before
-   calling the init function.  All other fields are set by the compression
-   library and must not be updated by the application.
-
-     The opaque value provided by the application will be passed as the first
-   parameter for calls of zalloc and zfree.  This can be useful for custom
-   memory management.  The compression library attaches no meaning to the
-   opaque value.
-
-     zalloc must return Z_NULL if there is not enough memory for the object.
-   If zlib is used in a multi-threaded application, zalloc and zfree must be
-   thread safe.
-
-     The fields total_in and total_out can be used for statistics or progress
-   reports.  After compression, total_in holds the total size of the
-   uncompressed data and may be saved for use in the decompressor (particularly
-   if the decompressor wants to decompress everything in a single step).
-*/
-
-                        /* constants */
-
-#define Z_NO_FLUSH      0
-#define Z_PARTIAL_FLUSH 1
-#define Z_SYNC_FLUSH    2
-#define Z_FULL_FLUSH    3
-#define Z_FINISH        4
-#define Z_BLOCK         5
-#define Z_TREES         6
-/* Allowed flush values; see deflate() and inflate() below for details */
-
-#define Z_OK            0
-#define Z_STREAM_END    1
-#define Z_NEED_DICT     2
-#define Z_ERRNO        (-1)
-#define Z_STREAM_ERROR (-2)
-#define Z_DATA_ERROR   (-3)
-#define Z_MEM_ERROR    (-4)
-#define Z_BUF_ERROR    (-5)
-#define Z_VERSION_ERROR (-6)
-/* Return codes for the compression/decompression functions. Negative values
- * are errors, positive values are used for special but normal events.
- */
-
-#define Z_NO_COMPRESSION         0
-#define Z_BEST_SPEED             1
-#define Z_BEST_COMPRESSION       9
-#define Z_DEFAULT_COMPRESSION  (-1)
-/* compression levels */
-
-#define Z_FILTERED            1
-#define Z_HUFFMAN_ONLY        2
-#define Z_RLE                 3
-#define Z_FIXED               4
-#define Z_DEFAULT_STRATEGY    0
-/* compression strategy; see deflateInit2() below for details */
-
-#define Z_BINARY   0
-#define Z_TEXT     1
-#define Z_ASCII    Z_TEXT   /* for compatibility with 1.2.2 and earlier */
-#define Z_UNKNOWN  2
-/* Possible values of the data_type field (though see inflate()) */
-
-#define Z_DEFLATED   8
-/* The deflate compression method (the only one supported in this version) */
-
-#define Z_NULL  0  /* for initializing zalloc, zfree, opaque */
-
-#define zlib_version zlibVersion()
-/* for compatibility with versions < 1.0.2 */
-
-
-                        /* basic functions */
-
-ZEXTERN const char * ZEXPORT zlibVersion(void);
-/* The application can compare zlibVersion and ZLIB_VERSION for consistency.
-   If the first character differs, the library code actually used is not
-   compatible with the zlib.h header file used by the application.  This check
-   is automatically made by deflateInit and inflateInit.
- */
-
-/*
-ZEXTERN int ZEXPORT deflateInit (z_stream *strm, int level);
-
-     Initializes the internal stream state for compression.  The fields
-   zalloc, zfree and opaque must be initialized before by the caller.  If
-   zalloc and zfree are set to Z_NULL, deflateInit updates them to use default
-   allocation functions.
-
-     The compression level must be Z_DEFAULT_COMPRESSION, or between 0 and 9:
-   1 gives best speed, 9 gives best compression, 0 gives no compression at all
-   (the input data is simply copied a block at a time).  Z_DEFAULT_COMPRESSION
-   requests a default compromise between speed and compression (currently
-   equivalent to level 6).
-
-     deflateInit returns Z_OK if success, Z_MEM_ERROR if there was not enough
-   memory, Z_STREAM_ERROR if level is not a valid compression level, or
-   Z_VERSION_ERROR if the zlib library version (zlib_version) is incompatible
-   with the version assumed by the caller (ZLIB_VERSION).  msg is set to null
-   if there is no error message.  deflateInit does not perform any compression:
-   this will be done by deflate().
-*/
-
-
-ZEXTERN int ZEXPORT deflate(z_stream *strm, int flush);
-/*
-    deflate compresses as much data as possible, and stops when the input
-  buffer becomes empty or the output buffer becomes full.  It may introduce
-  some output latency (reading input without producing any output) except when
-  forced to flush.
-
-    The detailed semantics are as follows.  deflate performs one or both of the
-  following actions:
-
-  - Compress more input starting at next_in and update next_in and avail_in
-    accordingly.  If not all input can be processed (because there is not
-    enough room in the output buffer), next_in and avail_in are updated and
-    processing will resume at this point for the next call of deflate().
-
-  - Provide more output starting at next_out and update next_out and avail_out
-    accordingly.  This action is forced if the parameter flush is non zero.
-    Forcing flush frequently degrades the compression ratio, so this parameter
-    should be set only when necessary (in interactive applications).  Some
-    output may be provided even if flush is not set.
-
-    Before the call of deflate(), the application should ensure that at least
-  one of the actions is possible, by providing more input and/or consuming more
-  output, and updating avail_in or avail_out accordingly; avail_out should
-  never be zero before the call.  The application can consume the compressed
-  output when it wants, for example when the output buffer is full (avail_out
-  == 0), or after each call of deflate().  If deflate returns Z_OK and with
-  zero avail_out, it must be called again after making room in the output
-  buffer because there might be more output pending.
-
-    Normally the parameter flush is set to Z_NO_FLUSH, which allows deflate to
-  decide how much data to accumulate before producing output, in order to
-  maximize compression.
-
-    If the parameter flush is set to Z_SYNC_FLUSH, all pending output is
-  flushed to the output buffer and the output is aligned on a byte boundary, so
-  that the decompressor can get all input data available so far.  (In
-  particular avail_in is zero after the call if enough output space has been
-  provided before the call.) Flushing may degrade compression for some
-  compression algorithms and so it should be used only when necessary.  This
-  completes the current deflate block and follows it with an empty stored block
-  that is three bits plus filler bits to the next byte, followed by four bytes
-  (00 00 ff ff).
-
-    If flush is set to Z_PARTIAL_FLUSH, all pending output is flushed to the
-  output buffer, but the output is not aligned to a byte boundary.  All of the
-  input data so far will be available to the decompressor, as for Z_SYNC_FLUSH.
-  This completes the current deflate block and follows it with an empty fixed
-  codes block that is 10 bits long.  This assures that enough bytes are output
-  in order for the decompressor to finish the block before the empty fixed code
-  block.
-
-    If flush is set to Z_BLOCK, a deflate block is completed and emitted, as
-  for Z_SYNC_FLUSH, but the output is not aligned on a byte boundary, and up to
-  seven bits of the current block are held to be written as the next byte after
-  the next deflate block is completed.  In this case, the decompressor may not
-  be provided enough bits at this point in order to complete decompression of
-  the data provided so far to the compressor.  It may need to wait for the next
-  block to be emitted.  This is for advanced applications that need to control
-  the emission of deflate blocks.
-
-    If flush is set to Z_FULL_FLUSH, all output is flushed as with
-  Z_SYNC_FLUSH, and the compression state is reset so that decompression can
-  restart from this point if previous compressed data has been damaged or if
-  random access is desired.  Using Z_FULL_FLUSH too often can seriously degrade
-  compression.
-
-    If deflate returns with avail_out == 0, this function must be called again
-  with the same value of the flush parameter and more output space (updated
-  avail_out), until the flush is complete (deflate returns with non-zero
-  avail_out).  In the case of a Z_FULL_FLUSH or Z_SYNC_FLUSH, make sure that
-  avail_out is greater than six to avoid repeated flush markers due to
-  avail_out == 0 on return.
-
-    If the parameter flush is set to Z_FINISH, pending input is processed,
-  pending output is flushed and deflate returns with Z_STREAM_END if there was
-  enough output space; if deflate returns with Z_OK, this function must be
-  called again with Z_FINISH and more output space (updated avail_out) but no
-  more input data, until it returns with Z_STREAM_END or an error.  After
-  deflate has returned Z_STREAM_END, the only possible operations on the stream
-  are deflateReset or deflateEnd.
-
-    Z_FINISH can be used immediately after deflateInit if all the compression
-  is to be done in a single step.  In this case, avail_out must be at least the
-  value returned by deflateBound (see below).  Then deflate is guaranteed to
-  return Z_STREAM_END.  If not enough output space is provided, deflate will
-  not return Z_STREAM_END, and it must be called again as described above.
-
-    deflate() sets strm->adler to the adler32 checksum of all input read
-  so far (that is, total_in bytes).
-
-    deflate() may update strm->data_type if it can make a good guess about
-  the input data type (Z_BINARY or Z_TEXT).  In doubt, the data is considered
-  binary.  This field is only for information purposes and does not affect the
-  compression algorithm in any manner.
-
-    deflate() returns Z_OK if some progress has been made (more input
-  processed or more output produced), Z_STREAM_END if all input has been
-  consumed and all output has been produced (only when flush is set to
-  Z_FINISH), Z_STREAM_ERROR if the stream state was inconsistent (for example
-  if next_in or next_out was Z_NULL), Z_BUF_ERROR if no progress is possible
-  (for example avail_in or avail_out was zero).  Note that Z_BUF_ERROR is not
-  fatal, and deflate() can be called again with more input and more output
-  space to continue compressing.
-*/
-
-
-ZEXTERN int ZEXPORT deflateEnd(z_stream *strm);
-/*
-     All dynamically allocated data structures for this stream are freed.
-   This function discards any unprocessed input and does not flush any pending
-   output.
-
-     deflateEnd returns Z_OK if success, Z_STREAM_ERROR if the
-   stream state was inconsistent, Z_DATA_ERROR if the stream was freed
-   prematurely (some input or output was discarded).  In the error case, msg
-   may be set but then points to a static string (which must not be
-   deallocated).
-*/
-
-
-/*
-ZEXTERN int ZEXPORT inflateInit (z_stream *strm);
-
-     Initializes the internal stream state for decompression.  The fields
-   next_in, avail_in, zalloc, zfree and opaque must be initialized before by
-   the caller.  If next_in is not Z_NULL and avail_in is large enough (the
-   exact value depends on the compression method), inflateInit determines the
-   compression method from the zlib header and allocates all data structures
-   accordingly; otherwise the allocation will be deferred to the first call of
-   inflate.  If zalloc and zfree are set to Z_NULL, inflateInit updates them to
-   use default allocation functions.
-
-     inflateInit returns Z_OK if success, Z_MEM_ERROR if there was not enough
-   memory, Z_VERSION_ERROR if the zlib library version is incompatible with the
-   version assumed by the caller, or Z_STREAM_ERROR if the parameters are
-   invalid, such as a null pointer to the structure.  msg is set to null if
-   there is no error message.  inflateInit does not perform any decompression
-   apart from possibly reading the zlib header if present: actual decompression
-   will be done by inflate().  (So next_in and avail_in may be modified, but
-   next_out and avail_out are unused and unchanged.) The current implementation
-   of inflateInit() does not process any header information -- that is deferred
-   until inflate() is called.
-*/
-
-
-ZEXTERN int ZEXPORT inflate(z_stream *strm, int flush);
-/*
-    inflate decompresses as much data as possible, and stops when the input
-  buffer becomes empty or the output buffer becomes full.  It may introduce
-  some output latency (reading input without producing any output) except when
-  forced to flush.
-
-  The detailed semantics are as follows.  inflate performs one or both of the
-  following actions:
-
-  - Decompress more input starting at next_in and update next_in and avail_in
-    accordingly.  If not all input can be processed (because there is not
-    enough room in the output buffer), next_in is updated and processing will
-    resume at this point for the next call of inflate().
-
-  - Provide more output starting at next_out and update next_out and avail_out
-    accordingly.  inflate() provides as much output as possible, until there is
-    no more input data or no more space in the output buffer (see below about
-    the flush parameter).
-
-    Before the call of inflate(), the application should ensure that at least
-  one of the actions is possible, by providing more input and/or consuming more
-  output, and updating the next_* and avail_* values accordingly.  The
-  application can consume the uncompressed output when it wants, for example
-  when the output buffer is full (avail_out == 0), or after each call of
-  inflate().  If inflate returns Z_OK and with zero avail_out, it must be
-  called again after making room in the output buffer because there might be
-  more output pending.
-
-    The flush parameter of inflate() can be Z_NO_FLUSH, Z_SYNC_FLUSH, Z_FINISH,
-  Z_BLOCK, or Z_TREES.  Z_SYNC_FLUSH requests that inflate() flush as much
-  output as possible to the output buffer.  Z_BLOCK requests that inflate()
-  stop if and when it gets to the next deflate block boundary.  When decoding
-  the zlib or gzip format, this will cause inflate() to return immediately
-  after the header and before the first block.  When doing a raw inflate,
-  inflate() will go ahead and process the first block, and will return when it
-  gets to the end of that block, or when it runs out of data.
-
-    The Z_BLOCK option assists in appending to or combining deflate streams.
-  Also to assist in this, on return inflate() will set strm->data_type to the
-  number of unused bits in the last byte taken from strm->next_in, plus 64 if
-  inflate() is currently decoding the last block in the deflate stream, plus
-  128 if inflate() returned immediately after decoding an end-of-block code or
-  decoding the complete header up to just before the first byte of the deflate
-  stream.  The end-of-block will not be indicated until all of the uncompressed
-  data from that block has been written to strm->next_out.  The number of
-  unused bits may in general be greater than seven, except when bit 7 of
-  data_type is set, in which case the number of unused bits will be less than
-  eight.  data_type is set as noted here every time inflate() returns for all
-  flush options, and so can be used to determine the amount of currently
-  consumed input in bits.
-
-    The Z_TREES option behaves as Z_BLOCK does, but it also returns when the
-  end of each deflate block header is reached, before any actual data in that
-  block is decoded.  This allows the caller to determine the length of the
-  deflate block header for later use in random access within a deflate block.
-  256 is added to the value of strm->data_type when inflate() returns
-  immediately after reaching the end of the deflate block header.
-
-    inflate() should normally be called until it returns Z_STREAM_END or an
-  error.  However if all decompression is to be performed in a single step (a
-  single call of inflate), the parameter flush should be set to Z_FINISH.  In
-  this case all pending input is processed and all pending output is flushed;
-  avail_out must be large enough to hold all of the uncompressed data for the
-  operation to complete.  (The size of the uncompressed data may have been
-  saved by the compressor for this purpose.) The use of Z_FINISH is not
-  required to perform an inflation in one step.  However it may be used to
-  inform inflate that a faster approach can be used for the single inflate()
-  call.  Z_FINISH also informs inflate to not maintain a sliding window if the
-  stream completes, which reduces inflate's memory footprint.  If the stream
-  does not complete, either because not all of the stream is provided or not
-  enough output space is provided, then a sliding window will be allocated and
-  inflate() can be called again to continue the operation as if Z_NO_FLUSH had
-  been used.
-
-     In this implementation, inflate() always flushes as much output as
-  possible to the output buffer, and always uses the faster approach on the
-  first call.  So the effects of the flush parameter in this implementation are
-  on the return value of inflate() as noted below, when inflate() returns early
-  when Z_BLOCK or Z_TREES is used, and when inflate() avoids the allocation of
-  memory for a sliding window when Z_FINISH is used.
-
-     If a preset dictionary is needed after this call (see inflateSetDictionary
-  below), inflate sets strm->adler to the Adler-32 checksum of the dictionary
-  chosen by the compressor and returns Z_NEED_DICT; otherwise it sets
-  strm->adler to the Adler-32 checksum of all output produced so far (that is,
-  total_out bytes) and returns Z_OK, Z_STREAM_END or an error code as described
-  below.  At the end of the stream, inflate() checks that its computed adler32
-  checksum is equal to that saved by the compressor and returns Z_STREAM_END
-  only if the checksum is correct.
-
-    inflate() can decompress and check either zlib-wrapped or gzip-wrapped
-  deflate data.  The header type is detected automatically, if requested when
-  initializing with inflateInit2().  Any information contained in the gzip
-  header is not retained, so applications that need that information should
-  instead use raw inflate, see inflateInit2() below, or inflateBack() and
-  perform their own processing of the gzip header and trailer.  When processing
-  gzip-wrapped deflate data, strm->adler32 is set to the CRC-32 of the output
-  producted so far.  The CRC-32 is checked against the gzip trailer.
-
-    inflate() returns Z_OK if some progress has been made (more input processed
-  or more output produced), Z_STREAM_END if the end of the compressed data has
-  been reached and all uncompressed output has been produced, Z_NEED_DICT if a
-  preset dictionary is needed at this point, Z_DATA_ERROR if the input data was
-  corrupted (input stream not conforming to the zlib format or incorrect check
-  value), Z_STREAM_ERROR if the stream structure was inconsistent (for example
-  next_in or next_out was Z_NULL), Z_MEM_ERROR if there was not enough memory,
-  Z_BUF_ERROR if no progress is possible or if there was not enough room in the
-  output buffer when Z_FINISH is used.  Note that Z_BUF_ERROR is not fatal, and
-  inflate() can be called again with more input and more output space to
-  continue decompressing.  If Z_DATA_ERROR is returned, the application may
-  then call inflateSync() to look for a good compression block if a partial
-  recovery of the data is desired.
-*/
-
-
-ZEXTERN int ZEXPORT inflateEnd(z_stream *strm);
-/*
-     All dynamically allocated data structures for this stream are freed.
-   This function discards any unprocessed input and does not flush any pending
-   output.
-
-     inflateEnd returns Z_OK if success, Z_STREAM_ERROR if the stream state
-   was inconsistent.  In the error case, msg may be set but then points to a
-   static string (which must not be deallocated).
-*/
-
-
-                        /* Advanced functions */
-
-/*
-    The following functions are needed only in some special applications.
-*/
-
-/*
-ZEXTERN int ZEXPORT deflateInit2 (z_stream *strm,
-                                     int  level,
-                                     int  method,
-                                     int  windowBits,
-                                     int  memLevel,
-                                     int  strategy);
-
-     This is another version of deflateInit with more compression options.  The
-   fields next_in, zalloc, zfree and opaque must be initialized before by the
-   caller.
-
-     The method parameter is the compression method.  It must be Z_DEFLATED in
-   this version of the library.
-
-     The windowBits parameter is the base two logarithm of the window size
-   (the size of the history buffer).  It should be in the range 8..15 for this
-   version of the library.  Larger values of this parameter result in better
-   compression at the expense of memory usage.  The default value is 15 if
-   deflateInit is used instead.
-
-     For the current implementation of deflate(), a windowBits value of 8 (a
-   window size of 256 bytes) is not supported.  As a result, a request for 8
-   will result in 9 (a 512-byte window).  In that case, providing 8 to
-   inflateInit2() will result in an error when the zlib header with 9 is
-   checked against the initialization of inflate().  The remedy is to not use 8
-   with deflateInit2() with this initialization, or at least in that case use 9
-   with inflateInit2().
-
-     windowBits can also be -8..-15 for raw deflate.  In this case, -windowBits
-   determines the window size.  deflate() will then generate raw deflate data
-   with no zlib header or trailer, and will not compute an adler32 check value.
-
-     windowBits can also be greater than 15 for optional gzip encoding.  Add
-   16 to windowBits to write a simple gzip header and trailer around the
-   compressed data instead of a zlib wrapper.  The gzip header will have no
-   file name, no extra data, no comment, no modification time (set to zero), no
-   header crc, and the operating system will be set to 255 (unknown).  If a
-   gzip stream is being written, strm->adler is a crc32 instead of an adler32.
-
-     The memLevel parameter specifies how much memory should be allocated
-   for the internal compression state.  memLevel=1 uses minimum memory but is
-   slow and reduces compression ratio; memLevel=9 uses maximum memory for
-   optimal speed.  The default value is 8.  See zconf.h for total memory usage
-   as a function of windowBits and memLevel.
-
-     The strategy parameter is used to tune the compression algorithm.  Use the
-   value Z_DEFAULT_STRATEGY for normal data, Z_FILTERED for data produced by a
-   filter (or predictor), Z_HUFFMAN_ONLY to force Huffman encoding only (no
-   string match), or Z_RLE to limit match distances to one (run-length
-   encoding).  Filtered data consists mostly of small values with a somewhat
-   random distribution.  In this case, the compression algorithm is tuned to
-   compress them better.  The effect of Z_FILTERED is to force more Huffman
-   coding and less string matching; it is somewhat intermediate between
-   Z_DEFAULT_STRATEGY and Z_HUFFMAN_ONLY.  Z_RLE is designed to be almost as
-   fast as Z_HUFFMAN_ONLY, but give better compression for PNG image data.  The
-   strategy parameter only affects the compression ratio but not the
-   correctness of the compressed output even if it is not set appropriately.
-   Z_FIXED prevents the use of dynamic Huffman codes, allowing for a simpler
-   decoder for special applications.
-
-     deflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
-   memory, Z_STREAM_ERROR if any parameter is invalid (such as an invalid
-   method), or Z_VERSION_ERROR if the zlib library version (zlib_version) is
-   incompatible with the version assumed by the caller (ZLIB_VERSION).  msg is
-   set to null if there is no error message.  deflateInit2 does not perform any
-   compression: this will be done by deflate().
-*/
-
-ZEXTERN int ZEXPORT deflateSetDictionary(z_stream *strm,
-                                             const unsigned char *dictionary,
-                                             unsigned int dictLength);
-/*
-     Initializes the compression dictionary from the given byte sequence
-   without producing any compressed output.  When using the zlib format, this
-   function must be called immediately after deflateInit, deflateInit2 or
-   deflateReset, and before any call of deflate.  When doing raw deflate, this
-   function must be called either before any call of deflate, or immediately
-   after the completion of a deflate block, i.e. after all input has been
-   consumed and all output has been delivered when using any of the flush
-   options Z_BLOCK, Z_PARTIAL_FLUSH, Z_SYNC_FLUSH, or Z_FULL_FLUSH.  The
-   compressor and decompressor must use exactly the same dictionary (see
-   inflateSetDictionary).
-
-     The dictionary should consist of strings (byte sequences) that are likely
-   to be encountered later in the data to be compressed, with the most commonly
-   used strings preferably put towards the end of the dictionary.  Using a
-   dictionary is most useful when the data to be compressed is short and can be
-   predicted with good accuracy; the data can then be compressed better than
-   with the default empty dictionary.
-
-     Depending on the size of the compression data structures selected by
-   deflateInit or deflateInit2, a part of the dictionary may in effect be
-   discarded, for example if the dictionary is larger than the window size
-   provided in deflateInit or deflateInit2.  Thus the strings most likely to be
-   useful should be put at the end of the dictionary, not at the front.  In
-   addition, the current implementation of deflate will use at most the window
-   size minus 262 bytes of the provided dictionary.
-
-     Upon return of this function, strm->adler is set to the adler32 value
-   of the dictionary; the decompressor may later use this value to determine
-   which dictionary has been used by the compressor.  (The adler32 value
-   applies to the whole dictionary even if only a subset of the dictionary is
-   actually used by the compressor.) If a raw deflate was requested, then the
-   adler32 value is not computed and strm->adler is not set.
-
-     deflateSetDictionary returns Z_OK if success, or Z_STREAM_ERROR if a
-   parameter is invalid (e.g.  dictionary being Z_NULL) or the stream state is
-   inconsistent (for example if deflate has already been called for this stream
-   or if not at a block boundary for raw deflate).  deflateSetDictionary does
-   not perform any compression: this will be done by deflate().
-*/
-
-ZEXTERN int ZEXPORT deflateCopy(z_stream *dest, z_stream *source);
-/*
-     Sets the destination stream as a complete copy of the source stream.
-
-     This function can be useful when several compression strategies will be
-   tried, for example when there are several ways of pre-processing the input
-   data with a filter.  The streams that will be discarded should then be freed
-   by calling deflateEnd.  Note that deflateCopy duplicates the internal
-   compression state which can be quite large, so this strategy is slow and can
-   consume lots of memory.
-
-     deflateCopy returns Z_OK if success, Z_MEM_ERROR if there was not
-   enough memory, Z_STREAM_ERROR if the source stream state was inconsistent
-   (such as zalloc being Z_NULL).  msg is left unchanged in both source and
-   destination.
-*/
-
-ZEXTERN int ZEXPORT deflateReset(z_stream *strm);
-/*
-     This function is equivalent to deflateEnd followed by deflateInit, but
-   does not free and reallocate the internal compression state.  The stream
-   will leave the compression level and any other attributes that may have been
-   set unchanged.
-
-     deflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source
-   stream state was inconsistent (such as zalloc or state being Z_NULL).
-*/
-
-ZEXTERN int ZEXPORT deflateParams(z_stream *strm, int level, int strategy);
-/*
-     Dynamically update the compression level and compression strategy.  The
-   interpretation of level and strategy is as in deflateInit2().  This can be
-   used to switch between compression and straight copy of the input data, or
-   to switch to a different kind of input data requiring a different strategy.
-   If the compression approach (which is a function of the level) or the
-   strategy is changed, then the input available so far is compressed with the
-   old level and strategy using deflate(strm, Z_BLOCK).  There are three
-   approaches for the compression levels 0, 1..3, and 4..9 respectively.  The
-   new level and strategy will take effect at the next call of deflate().
-
-     If a deflate(strm, Z_BLOCK) is performed by deflateParams(), and it does
-   not have enough output space to complete, then the parameter change will
-   take effect at an undetermined location in the uncompressed data provided so
-   far.  In order to assure a change in the parameters at a specific location
-   in the uncompressed data, the deflate stream should first be flushed with
-   Z_BLOCK or another flush parameter, and deflate() called until
-   strm.avail_out is not zero, before the call of deflateParams().  Then no
-   more input data should be provided before the deflateParams() call.  If this
-   is done, the old level and strategy will be applied to the data compressed
-   before deflateParams(), and the new level and strategy will be applied to
-   the the data compressed after deflateParams().
-
-     deflateParams returns Z_OK if success, Z_STREAM_ERROR if the source stream
-   state was inconsistent or if a parameter was invalid, or Z_BUF_ERROR if
-   there was not enough output space to complete the compression before the
-   parameters were changed.  Note that in the case of a Z_BUF_ERROR, the
-   parameters are changed nevertheless, and will take effect at an undetermined
-   location in the previously supplied uncompressed data.  Compression may
-   proceed after a Z_BUF_ERROR.
-*/
-
-ZEXTERN int ZEXPORT deflateTune(z_stream *strm, int good_length, int max_lazy, int nice_length, int max_chain);
-/*
-     Fine tune deflate's internal compression parameters.  This should only be
-   used by someone who understands the algorithm used by zlib's deflate for
-   searching for the best matching string, and even then only by the most
-   fanatic optimizer trying to squeeze out the last compressed bit for their
-   specific input data.  Read the deflate.c source code for the meaning of the
-   max_lazy, good_length, nice_length, and max_chain parameters.
-
-     deflateTune() can be called after deflateInit() or deflateInit2(), and
-   returns Z_OK on success, or Z_STREAM_ERROR for an invalid deflate stream.
- */
-
-ZEXTERN unsigned long ZEXPORT deflateBound(z_stream *strm, unsigned long sourceLen);
-/*
-     deflateBound() returns an upper bound on the compressed size after
-   deflation of sourceLen bytes.  It must be called after deflateInit() or
-   deflateInit2(), and after deflateSetHeader(), if used.  This would be used
-   to allocate an output buffer for deflation in a single pass, and so would be
-   called before deflate().  If that first deflate() call is provided the
-   sourceLen input bytes, an output buffer allocated to the size returned by
-   deflateBound(), and the flush value Z_FINISH, then deflate() is guaranteed
-   to return Z_STREAM_END.  Note that it is possible for the compressed size to
-   be larger than the value returned by deflateBound() if flush options other
-   than Z_FINISH or Z_NO_FLUSH are used.
-*/
-
-ZEXTERN int ZEXPORT deflatePending(z_stream *strm, uint32_t *pending, int *bits);
-/*
-     deflatePending() returns the number of bytes and bits of output that have
-   been generated, but not yet provided in the available output.  The bytes not
-   provided would be due to the available output space having being consumed.
-   The number of bits of output not provided are between 0 and 7, where they
-   await more bits to join them in order to fill out a full byte.  If pending
-   or bits are Z_NULL, then those values are not set.
-
-     deflatePending returns Z_OK if success, or Z_STREAM_ERROR if the source
-   stream state was inconsistent.
- */
-
-ZEXTERN int ZEXPORT deflatePrime(z_stream *strm, int bits, int value);
-/*
-     deflatePrime() inserts bits in the deflate output stream.  The intent
-   is that this function is used to start off the deflate output with the bits
-   leftover from a previous deflate stream when appending to it.  As such, this
-   function can only be used for raw deflate, and must be used before the first
-   deflate() call after a deflateInit2() or deflateReset().  bits must be less
-   than or equal to 16, and that many of the least significant bits of value
-   will be inserted in the output.
-
-     deflatePrime returns Z_OK if success, Z_BUF_ERROR if there was not enough
-   room in the internal buffer to insert the bits, or Z_STREAM_ERROR if the
-   source stream state was inconsistent.
-*/
-
-ZEXTERN int ZEXPORT deflateSetHeader(z_stream *strm, gz_headerp head);
-/*
-     deflateSetHeader() provides gzip header information for when a gzip
-   stream is requested by deflateInit2().  deflateSetHeader() may be called
-   after deflateInit2() or deflateReset() and before the first call of
-   deflate().  The text, time, os, extra field, name, and comment information
-   in the provided gz_header structure are written to the gzip header (xflag is
-   ignored -- the extra flags are set according to the compression level).  The
-   caller must assure that, if not Z_NULL, name and comment are terminated with
-   a zero byte, and that if extra is not Z_NULL, that extra_len bytes are
-   available there.  If hcrc is true, a gzip header crc is included.  Note that
-   the current versions of the command-line version of gzip (up through version
-   1.3.x) do not support header crc's, and will report that it is a "multi-part
-   gzip file" and give up.
-
-     If deflateSetHeader is not used, the default gzip header has text false,
-   the time set to zero, and os set to 255, with no extra, name, or comment
-   fields.  The gzip header is returned to the default state by deflateReset().
-
-     deflateSetHeader returns Z_OK if success, or Z_STREAM_ERROR if the source
-   stream state was inconsistent.
-*/
-
-/*
-ZEXTERN int ZEXPORT inflateInit2(z_stream *strm, int  windowBits);
-
-     This is another version of inflateInit with an extra parameter.  The
-   fields next_in, avail_in, zalloc, zfree and opaque must be initialized
-   before by the caller.
-
-     The windowBits parameter is the base two logarithm of the maximum window
-   size (the size of the history buffer).  It should be in the range 8..15 for
-   this version of the library.  The default value is 15 if inflateInit is used
-   instead.  windowBits must be greater than or equal to the windowBits value
-   provided to deflateInit2() while compressing, or it must be equal to 15 if
-   deflateInit2() was not used.  If a compressed stream with a larger window
-   size is given as input, inflate() will return with the error code
-   Z_DATA_ERROR instead of trying to allocate a larger window.
-
-     windowBits can also be zero to request that inflate use the window size in
-   the zlib header of the compressed stream.
-
-     windowBits can also be -8..-15 for raw inflate.  In this case, -windowBits
-   determines the window size.  inflate() will then process raw deflate data,
-   not looking for a zlib or gzip header, not generating a check value, and not
-   looking for any check values for comparison at the end of the stream.  This
-   is for use with other formats that use the deflate compressed data format
-   such as zip.  Those formats provide their own check values.  If a custom
-   format is developed using the raw deflate format for compressed data, it is
-   recommended that a check value such as an adler32 or a crc32 be applied to
-   the uncompressed data as is done in the zlib, gzip, and zip formats.  For
-   most applications, the zlib format should be used as is.  Note that comments
-   above on the use in deflateInit2() applies to the magnitude of windowBits.
-
-     windowBits can also be greater than 15 for optional gzip decoding.  Add
-   32 to windowBits to enable zlib and gzip decoding with automatic header
-   detection, or add 16 to decode only the gzip format (the zlib format will
-   return a Z_DATA_ERROR).  If a gzip stream is being decoded, strm->adler is a
-   crc32 instead of an adler32.
-
-     inflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
-   memory, Z_VERSION_ERROR if the zlib library version is incompatible with the
-   version assumed by the caller, or Z_STREAM_ERROR if the parameters are
-   invalid, such as a null pointer to the structure.  msg is set to null if
-   there is no error message.  inflateInit2 does not perform any decompression
-   apart from possibly reading the zlib header if present: actual decompression
-   will be done by inflate().  (So next_in and avail_in may be modified, but
-   next_out and avail_out are unused and unchanged.) The current implementation
-   of inflateInit2() does not process any header information -- that is
-   deferred until inflate() is called.
-*/
-
-ZEXTERN int ZEXPORT inflateSetDictionary(z_stream *strm, const unsigned char *dictionary, unsigned int dictLength);
-/*
-     Initializes the decompression dictionary from the given uncompressed byte
-   sequence.  This function must be called immediately after a call of inflate,
-   if that call returned Z_NEED_DICT.  The dictionary chosen by the compressor
-   can be determined from the adler32 value returned by that call of inflate.
-   The compressor and decompressor must use exactly the same dictionary (see
-   deflateSetDictionary).  For raw inflate, this function can be called at any
-   time to set the dictionary.  If the provided dictionary is smaller than the
-   window and there is already data in the window, then the provided dictionary
-   will amend what's there.  The application must insure that the dictionary
-   that was used for compression is provided.
-
-     inflateSetDictionary returns Z_OK if success, Z_STREAM_ERROR if a
-   parameter is invalid (e.g.  dictionary being Z_NULL) or the stream state is
-   inconsistent, Z_DATA_ERROR if the given dictionary doesn't match the
-   expected one (incorrect adler32 value).  inflateSetDictionary does not
-   perform any decompression: this will be done by subsequent calls of
-   inflate().
-*/
-
-ZEXTERN int ZEXPORT inflateGetDictionary(z_stream *strm, unsigned char *dictionary, unsigned int *dictLength);
-/*
-     Returns the sliding dictionary being maintained by inflate.  dictLength is
-   set to the number of bytes in the dictionary, and that many bytes are copied
-   to dictionary.  dictionary must have enough space, where 32768 bytes is
-   always enough.  If inflateGetDictionary() is called with dictionary equal to
-   Z_NULL, then only the dictionary length is returned, and nothing is copied.
-   Similary, if dictLength is Z_NULL, then it is not set.
-
-     inflateGetDictionary returns Z_OK on success, or Z_STREAM_ERROR if the
-   stream state is inconsistent.
-*/
-
-ZEXTERN int ZEXPORT inflateSync(z_stream *strm);
-/*
-     Skips invalid compressed data until a possible full flush point (see above
-   for the description of deflate with Z_FULL_FLUSH) can be found, or until all
-   available input is skipped.  No output is provided.
-
-     inflateSync searches for a 00 00 FF FF pattern in the compressed data.
-   All full flush points have this pattern, but not all occurrences of this
-   pattern are full flush points.
-
-     inflateSync returns Z_OK if a possible full flush point has been found,
-   Z_BUF_ERROR if no more input was provided, Z_DATA_ERROR if no flush point
-   has been found, or Z_STREAM_ERROR if the stream structure was inconsistent.
-   In the success case, the application may save the current current value of
-   total_in which indicates where valid compressed data was found.  In the
-   error case, the application may repeatedly call inflateSync, providing more
-   input each time, until success or end of the input data.
-*/
-
-ZEXTERN int ZEXPORT inflateCopy(z_stream *dest, z_stream *source);
-/*
-     Sets the destination stream as a complete copy of the source stream.
-
-     This function can be useful when randomly accessing a large stream.  The
-   first pass through the stream can periodically record the inflate state,
-   allowing restarting inflate at those points when randomly accessing the
-   stream.
-
-     inflateCopy returns Z_OK if success, Z_MEM_ERROR if there was not
-   enough memory, Z_STREAM_ERROR if the source stream state was inconsistent
-   (such as zalloc being Z_NULL).  msg is left unchanged in both source and
-   destination.
-*/
-
-ZEXTERN int ZEXPORT inflateReset(z_stream *strm);
-/*
-     This function is equivalent to inflateEnd followed by inflateInit,
-   but does not free and reallocate all the internal decompression state.  The
-   stream will keep attributes that may have been set by inflateInit2.
-
-     inflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source
-   stream state was inconsistent (such as zalloc or state being Z_NULL).
-*/
-
-ZEXTERN int ZEXPORT inflateReset2(z_stream *strm, int windowBits);
-/*
-     This function is the same as inflateReset, but it also permits changing
-   the wrap and window size requests.  The windowBits parameter is interpreted
-   the same as it is for inflateInit2.
-
-     inflateReset2 returns Z_OK if success, or Z_STREAM_ERROR if the source
-   stream state was inconsistent (such as zalloc or state being Z_NULL), or if
-   the windowBits parameter is invalid.
-*/
-
-ZEXTERN int ZEXPORT inflatePrime(z_stream *strm, int bits, int value);
-/*
-     This function inserts bits in the inflate input stream.  The intent is
-   that this function is used to start inflating at a bit position in the
-   middle of a byte.  The provided bits will be used before any bytes are used
-   from next_in.  This function should only be used with raw inflate, and
-   should be used before the first inflate() call after inflateInit2() or
-   inflateReset().  bits must be less than or equal to 16, and that many of the
-   least significant bits of value will be inserted in the input.
-
-     If bits is negative, then the input stream bit buffer is emptied.  Then
-   inflatePrime() can be called again to put bits in the buffer.  This is used
-   to clear out bits leftover after feeding inflate a block description prior
-   to feeding inflate codes.
-
-     inflatePrime returns Z_OK if success, or Z_STREAM_ERROR if the source
-   stream state was inconsistent.
-*/
-
-ZEXTERN long ZEXPORT inflateMark(z_stream *strm);
-/*
-     This function returns two values, one in the lower 16 bits of the return
-   value, and the other in the remaining upper bits, obtained by shifting the
-   return value down 16 bits.  If the upper value is -1 and the lower value is
-   zero, then inflate() is currently decoding information outside of a block.
-   If the upper value is -1 and the lower value is non-zero, then inflate is in
-   the middle of a stored block, with the lower value equaling the number of
-   bytes from the input remaining to copy.  If the upper value is not -1, then
-   it is the number of bits back from the current bit position in the input of
-   the code (literal or length/distance pair) currently being processed.  In
-   that case the lower value is the number of bytes already emitted for that
-   code.
-
-     A code is being processed if inflate is waiting for more input to complete
-   decoding of the code, or if it has completed decoding but is waiting for
-   more output space to write the literal or match data.
-
-     inflateMark() is used to mark locations in the input data for random
-   access, which may be at bit positions, and to note those cases where the
-   output of a code may span boundaries of random access blocks.  The current
-   location in the input stream can be determined from avail_in and data_type
-   as noted in the description for the Z_BLOCK flush parameter for inflate.
-
-     inflateMark returns the value noted above or -65536 if the provided
-   source stream state was inconsistent.
-*/
-
-ZEXTERN int ZEXPORT inflateGetHeader(z_stream *strm, gz_headerp head);
-/*
-     inflateGetHeader() requests that gzip header information be stored in the
-   provided gz_header structure.  inflateGetHeader() may be called after
-   inflateInit2() or inflateReset(), and before the first call of inflate().
-   As inflate() processes the gzip stream, head->done is zero until the header
-   is completed, at which time head->done is set to one.  If a zlib stream is
-   being decoded, then head->done is set to -1 to indicate that there will be
-   no gzip header information forthcoming.  Note that Z_BLOCK or Z_TREES can be
-   used to force inflate() to return immediately after header processing is
-   complete and before any actual data is decompressed.
-
-     The text, time, xflags, and os fields are filled in with the gzip header
-   contents.  hcrc is set to true if there is a header CRC.  (The header CRC
-   was valid if done is set to one.) If extra is not Z_NULL, then extra_max
-   contains the maximum number of bytes to write to extra.  Once done is true,
-   extra_len contains the actual extra field length, and extra contains the
-   extra field, or that field truncated if extra_max is less than extra_len.
-   If name is not Z_NULL, then up to name_max characters are written there,
-   terminated with a zero unless the length is greater than name_max.  If
-   comment is not Z_NULL, then up to comm_max characters are written there,
-   terminated with a zero unless the length is greater than comm_max.  When any
-   of extra, name, or comment are not Z_NULL and the respective field is not
-   present in the header, then that field is set to Z_NULL to signal its
-   absence.  This allows the use of deflateSetHeader() with the returned
-   structure to duplicate the header.  However if those fields are set to
-   allocated memory, then the application will need to save those pointers
-   elsewhere so that they can be eventually freed.
-
-     If inflateGetHeader is not used, then the header information is simply
-   discarded.  The header is always checked for validity, including the header
-   CRC if present.  inflateReset() will reset the process to discard the header
-   information.  The application would need to call inflateGetHeader() again to
-   retrieve the header from the next gzip stream.
-
-     inflateGetHeader returns Z_OK if success, or Z_STREAM_ERROR if the source
-   stream state was inconsistent.
-*/
-
-/*
-ZEXTERN int ZEXPORT inflateBackInit (z_stream *strm, int windowBits, unsigned char *window);
-
-     Initialize the internal stream state for decompression using inflateBack()
-   calls.  The fields zalloc, zfree and opaque in strm must be initialized
-   before the call.  If zalloc and zfree are Z_NULL, then the default library-
-   derived memory allocation routines are used.  windowBits is the base two
-   logarithm of the window size, in the range 8..15.  window is a caller
-   supplied buffer of that size.  Except for special applications where it is
-   assured that deflate was used with small window sizes, windowBits must be 15
-   and a 32K byte window must be supplied to be able to decompress general
-   deflate streams.
-
-     See inflateBack() for the usage of these routines.
-
-     inflateBackInit will return Z_OK on success, Z_STREAM_ERROR if any of
-   the parameters are invalid, Z_MEM_ERROR if the internal state could not be
-   allocated, or Z_VERSION_ERROR if the version of the library does not match
-   the version of the header file.
-*/
-
-typedef uint32_t (*in_func) (void *, const unsigned char * *);
-typedef int (*out_func) (void *, unsigned char *, uint32_t);
-
-ZEXTERN int ZEXPORT inflateBack(z_stream *strm, in_func in, void *in_desc, out_func out, void *out_desc);
-/*
-     inflateBack() does a raw inflate with a single call using a call-back
-   interface for input and output.  This is potentially more efficient than
-   inflate() for file i/o applications, in that it avoids copying between the
-   output and the sliding window by simply making the window itself the output
-   buffer.  inflate() can be faster on modern CPUs when used with large
-   buffers.  inflateBack() trusts the application to not change the output
-   buffer passed by the output function, at least until inflateBack() returns.
-
-     inflateBackInit() must be called first to allocate the internal state
-   and to initialize the state with the user-provided window buffer.
-   inflateBack() may then be used multiple times to inflate a complete, raw
-   deflate stream with each call.  inflateBackEnd() is then called to free the
-   allocated state.
-
-     A raw deflate stream is one with no zlib or gzip header or trailer.
-   This routine would normally be used in a utility that reads zip or gzip
-   files and writes out uncompressed files.  The utility would decode the
-   header and process the trailer on its own, hence this routine expects only
-   the raw deflate stream to decompress.  This is different from the normal
-   behavior of inflate(), which expects either a zlib or gzip header and
-   trailer around the deflate stream.
-
-     inflateBack() uses two subroutines supplied by the caller that are then
-   called by inflateBack() for input and output.  inflateBack() calls those
-   routines until it reads a complete deflate stream and writes out all of the
-   uncompressed data, or until it encounters an error.  The function's
-   parameters and return types are defined above in the in_func and out_func
-   typedefs.  inflateBack() will call in(in_desc, &buf) which should return the
-   number of bytes of provided input, and a pointer to that input in buf.  If
-   there is no input available, in() must return zero--buf is ignored in that
-   case--and inflateBack() will return a buffer error.  inflateBack() will call
-   out(out_desc, buf, len) to write the uncompressed data buf[0..len-1].  out()
-   should return zero on success, or non-zero on failure.  If out() returns
-   non-zero, inflateBack() will return with an error.  Neither in() nor out()
-   are permitted to change the contents of the window provided to
-   inflateBackInit(), which is also the buffer that out() uses to write from.
-   The length written by out() will be at most the window size.  Any non-zero
-   amount of input may be provided by in().
-
-     For convenience, inflateBack() can be provided input on the first call by
-   setting strm->next_in and strm->avail_in.  If that input is exhausted, then
-   in() will be called.  Therefore strm->next_in must be initialized before
-   calling inflateBack().  If strm->next_in is Z_NULL, then in() will be called
-   immediately for input.  If strm->next_in is not Z_NULL, then strm->avail_in
-   must also be initialized, and then if strm->avail_in is not zero, input will
-   initially be taken from strm->next_in[0 ..  strm->avail_in - 1].
-
-     The in_desc and out_desc parameters of inflateBack() is passed as the
-   first parameter of in() and out() respectively when they are called.  These
-   descriptors can be optionally used to pass any information that the caller-
-   supplied in() and out() functions need to do their job.
-
-     On return, inflateBack() will set strm->next_in and strm->avail_in to
-   pass back any unused input that was provided by the last in() call.  The
-   return values of inflateBack() can be Z_STREAM_END on success, Z_BUF_ERROR
-   if in() or out() returned an error, Z_DATA_ERROR if there was a format error
-   in the deflate stream (in which case strm->msg is set to indicate the nature
-   of the error), or Z_STREAM_ERROR if the stream was not properly initialized.
-   In the case of Z_BUF_ERROR, an input or output error can be distinguished
-   using strm->next_in which will be Z_NULL only if in() returned an error.  If
-   strm->next_in is not Z_NULL, then the Z_BUF_ERROR was due to out() returning
-   non-zero.  (in() will always be called before out(), so strm->next_in is
-   assured to be defined if out() returns non-zero.) Note that inflateBack()
-   cannot return Z_OK.
-*/
-
-ZEXTERN int ZEXPORT inflateBackEnd(z_stream *strm);
-/*
-     All memory allocated by inflateBackInit() is freed.
-
-     inflateBackEnd() returns Z_OK on success, or Z_STREAM_ERROR if the stream
-   state was inconsistent.
-*/
-
-ZEXTERN unsigned long ZEXPORT zlibCompileFlags(void);
-/* Return flags indicating compile-time options.
-
-    Type sizes, two bits each, 00 = 16 bits, 01 = 32, 10 = 64, 11 = other:
-     1.0: size of unsigned int
-     3.2: size of unsigned long
-     5.4: size of void * (pointer)
-     7.6: size of z_off_t
-
-    Compiler, assembler, and debug options:
-     8: DEBUG
-     9: ASMV or ASMINF -- use ASM code
-     10: ZLIB_WINAPI -- exported functions use the WINAPI calling convention
-     11: 0 (reserved)
-
-    One-time table building (smaller code, but not thread-safe if true):
-     12: BUILDFIXED -- build static block decoding tables when needed
-     13: DYNAMIC_CRC_TABLE -- build CRC calculation tables when needed
-     14,15: 0 (reserved)
-
-    Library content (indicates missing functionality):
-     16: NO_GZCOMPRESS -- gz* functions cannot compress (to avoid linking
-                          deflate code when not needed)
-     17: NO_GZIP -- deflate can't write gzip streams, and inflate can't detect
-                    and decode gzip streams (to avoid linking crc code)
-     18-19: 0 (reserved)
-
-    Operation variations (changes in library functionality):
-     20: PKZIP_BUG_WORKAROUND -- slightly more permissive inflate
-     21: FASTEST -- deflate algorithm with only one, lowest compression level
-     22,23: 0 (reserved)
-
-    The sprintf variant used by gzprintf (zero is best):
-     24: 0 = vs*, 1 = s* -- 1 means limited to 20 arguments after the format
-     25: 0 = *nprintf, 1 = *printf -- 1 means gzprintf() not secure!
-     26: 0 = returns value, 1 = void -- 1 means inferred string length returned
-
-    Remainder:
-     27-31: 0 (reserved)
- */
-
-
-                        /* utility functions */
-
-/*
-     The following utility functions are implemented on top of the basic
-   stream-oriented functions.  To simplify the interface, some default options
-   are assumed (compression level and memory usage, standard memory allocation
-   functions).  The source code of these utility functions can be modified if
-   you need special options.
-*/
-
-ZEXTERN int ZEXPORT compress(unsigned char *dest, size_t *destLen, const unsigned char *source, size_t sourceLen);
-/*
-     Compresses the source buffer into the destination buffer.  sourceLen is
-   the byte length of the source buffer.  Upon entry, destLen is the total size
-   of the destination buffer, which must be at least the value returned by
-   compressBound(sourceLen).  Upon exit, destLen is the actual size of the
-   compressed buffer.  compress() is equivalent to compress2() with a level
-   parameter of Z_DEFAULT_COMPRESSION.
-
-     compress returns Z_OK if success, Z_MEM_ERROR if there was not
-   enough memory, Z_BUF_ERROR if there was not enough room in the output
-   buffer.
-*/
-
-ZEXTERN int ZEXPORT compress2(unsigned char *dest, size_t *destLen, const unsigned char *source,
-                              size_t sourceLen, int level);
-/*
-     Compresses the source buffer into the destination buffer.  The level
-   parameter has the same meaning as in deflateInit.  sourceLen is the byte
-   length of the source buffer.  Upon entry, destLen is the total size of the
-   destination buffer, which must be at least the value returned by
-   compressBound(sourceLen).  Upon exit, destLen is the actual size of the
-   compressed buffer.
-
-     compress2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
-   memory, Z_BUF_ERROR if there was not enough room in the output buffer,
-   Z_STREAM_ERROR if the level parameter is invalid.
-*/
-
-ZEXTERN size_t ZEXPORT compressBound(size_t sourceLen);
-/*
-     compressBound() returns an upper bound on the compressed size after
-   compress() or compress2() on sourceLen bytes.  It would be used before a
-   compress() or compress2() call to allocate the destination buffer.
-*/
-
-ZEXTERN int ZEXPORT uncompress(unsigned char *dest, size_t *destLen, const unsigned char *source, size_t sourceLen);
-/*
-     Decompresses the source buffer into the destination buffer.  sourceLen is
-   the byte length of the source buffer.  Upon entry, destLen is the total size
-   of the destination buffer, which must be large enough to hold the entire
-   uncompressed data.  (The size of the uncompressed data must have been saved
-   previously by the compressor and transmitted to the decompressor by some
-   mechanism outside the scope of this compression library.) Upon exit, destLen
-   is the actual size of the uncompressed buffer.
-
-     uncompress returns Z_OK if success, Z_MEM_ERROR if there was not
-   enough memory, Z_BUF_ERROR if there was not enough room in the output
-   buffer, or Z_DATA_ERROR if the input data was corrupted or incomplete.  In
-   the case where there is not enough room, uncompress() will fill the output
-   buffer with the uncompressed data up to that point.
-*/
-
-#ifdef WITH_GZFILEOP
-                        /* gzip file access functions */
-
-/*
-     This library supports reading and writing files in gzip (.gz) format with
-   an interface similar to that of stdio, using the functions that start with
-   "gz".  The gzip format is different from the zlib format.  gzip is a gzip
-   wrapper, documented in RFC 1952, wrapped around a deflate stream.
-*/
-
-typedef struct gzFile_s *gzFile;    /* semi-opaque gzip file descriptor */
-
-/*
-ZEXTERN gzFile ZEXPORT gzopen(const char *path, const char *mode);
-
-     Opens a gzip (.gz) file for reading or writing.  The mode parameter is as
-   in fopen ("rb" or "wb") but can also include a compression level ("wb9") or
-   a strategy: 'f' for filtered data as in "wb6f", 'h' for Huffman-only
-   compression as in "wb1h", 'R' for run-length encoding as in "wb1R", or 'F'
-   for fixed code compression as in "wb9F".  (See the description of
-   deflateInit2 for more information about the strategy parameter.)  'T' will
-   request transparent writing or appending with no compression and not using
-   the gzip format.
-
-     "a" can be used instead of "w" to request that the gzip stream that will
-   be written be appended to the file.  "+" will result in an error, since
-   reading and writing to the same gzip file is not supported.  The addition of
-   "x" when writing will create the file exclusively, which fails if the file
-   already exists.  On systems that support it, the addition of "e" when
-   reading or writing will set the flag to close the file on an execve() call.
-
-     These functions, as well as gzip, will read and decode a sequence of gzip
-   streams in a file.  The append function of gzopen() can be used to create
-   such a file.  (Also see gzflush() for another way to do this.)  When
-   appending, gzopen does not test whether the file begins with a gzip stream,
-   nor does it look for the end of the gzip streams to begin appending.  gzopen
-   will simply append a gzip stream to the existing file.
-
-     gzopen can be used to read a file which is not in gzip format; in this
-   case gzread will directly read from the file without decompression.  When
-   reading, this will be detected automatically by looking for the magic two-
-   byte gzip header.
-
-     gzopen returns NULL if the file could not be opened, if there was
-   insufficient memory to allocate the gzFile state, or if an invalid mode was
-   specified (an 'r', 'w', or 'a' was not provided, or '+' was provided).
-   errno can be checked to determine if the reason gzopen failed was that the
-   file could not be opened.
-*/
-
-ZEXTERN gzFile ZEXPORT gzdopen(int fd, const char *mode);
-/*
-     gzdopen associates a gzFile with the file descriptor fd.  File descriptors
-   are obtained from calls like open, dup, creat, pipe or fileno (if the file
-   has been previously opened with fopen).  The mode parameter is as in gzopen.
-
-     The next call of gzclose on the returned gzFile will also close the file
-   descriptor fd, just like fclose(fdopen(fd, mode)) closes the file descriptor
-   fd.  If you want to keep fd open, use fd = dup(fd_keep); gz = gzdopen(fd,
-   mode);.  The duplicated descriptor should be saved to avoid a leak, since
-   gzdopen does not close fd if it fails.  If you are using fileno() to get the
-   file descriptor from a FILE *, then you will have to use dup() to avoid
-   double-close()ing the file descriptor.  Both gzclose() and fclose() will
-   close the associated file descriptor, so they need to have different file
-   descriptors.
-
-     gzdopen returns NULL if there was insufficient memory to allocate the
-   gzFile state, if an invalid mode was specified (an 'r', 'w', or 'a' was not
-   provided, or '+' was provided), or if fd is -1.  The file descriptor is not
-   used until the next gz* read, write, seek, or close operation, so gzdopen
-   will not detect if fd is invalid (unless fd is -1).
-*/
-
-ZEXTERN int ZEXPORT gzbuffer(gzFile file, unsigned size);
-/*
-     Set the internal buffer size used by this library's functions.  The
-   default buffer size is 8192 bytes.  This function must be called after
-   gzopen() or gzdopen(), and before any other calls that read or write the
-   file.  The buffer memory allocation is always deferred to the first read or
-   write.  Three times that size in buffer space is allocated.  A larger buffer
-   size of, for example, 64K or 128K bytes will noticeably increase the speed
-   of decompression (reading).
-
-     The new buffer size also affects the maximum length for gzprintf().
-
-     gzbuffer() returns 0 on success, or -1 on failure, such as being called
-   too late.
-*/
-
-ZEXTERN int ZEXPORT gzsetparams(gzFile file, int level, int strategy);
-/*
-     Dynamically update the compression level or strategy.  See the description
-   of deflateInit2 for the meaning of these parameters.
-
-     gzsetparams returns Z_OK if success, or Z_STREAM_ERROR if the file was not
-   opened for writing.
-*/
-
-ZEXTERN int ZEXPORT gzread(gzFile file, void *buf, unsigned len);
-/*
-     Reads the given number of uncompressed bytes from the compressed file.  If
-   the input file is not in gzip format, gzread copies the given number of
-   bytes into the buffer directly from the file.
-
-     After reaching the end of a gzip stream in the input, gzread will continue
-   to read, looking for another gzip stream.  Any number of gzip streams may be
-   concatenated in the input file, and will all be decompressed by gzread().
-   If something other than a gzip stream is encountered after a gzip stream,
-   that remaining trailing garbage is ignored (and no error is returned).
-
-     gzread can be used to read a gzip file that is being concurrently written.
-   Upon reaching the end of the input, gzread will return with the available
-   data.  If the error code returned by gzerror is Z_OK or Z_BUF_ERROR, then
-   gzclearerr can be used to clear the end of file indicator in order to permit
-   gzread to be tried again.  Z_OK indicates that a gzip stream was completed
-   on the last gzread.  Z_BUF_ERROR indicates that the input file ended in the
-   middle of a gzip stream.  Note that gzread does not return -1 in the event
-   of an incomplete gzip stream.  This error is deferred until gzclose(), which
-   will return Z_BUF_ERROR if the last gzread ended in the middle of a gzip
-   stream.  Alternatively, gzerror can be used before gzclose to detect this
-   case.
-
-     gzread returns the number of uncompressed bytes actually read, less than
-   len for end of file, or -1 for error.
-*/
-
-ZEXTERN int ZEXPORT gzwrite(gzFile file, void const *buf, unsigned len);
-/*
-     Writes the given number of uncompressed bytes into the compressed file.
-   gzwrite returns the number of uncompressed bytes written or 0 in case of
-   error.
-*/
-
-ZEXTERN int ZEXPORTVA gzprintf(gzFile file, const char *format, ...);
-/*
-     Converts, formats, and writes the arguments to the compressed file under
-   control of the format string, as in fprintf.  gzprintf returns the number of
-   uncompressed bytes actually written, or 0 in case of error.  The number of
-   uncompressed bytes written is limited to 8191, or one less than the buffer
-   size given to gzbuffer().  The caller should assure that this limit is not
-   exceeded.  If it is exceeded, then gzprintf() will return an error (0) with
-   nothing written.  In this case, there may also be a buffer overflow with
-   unpredictable consequences, which is possible only if zlib was compiled with
-   the insecure functions sprintf() or vsprintf() because the secure snprintf()
-   or vsnprintf() functions were not available.  This can be determined using
-   zlibCompileFlags().
-*/
-
-ZEXTERN int ZEXPORT gzputs(gzFile file, const char *s);
-/*
-     Writes the given null-terminated string to the compressed file, excluding
-   the terminating null character.
-
-     gzputs returns the number of characters written, or -1 in case of error.
-*/
-
-ZEXTERN char * ZEXPORT gzgets(gzFile file, char *buf, int len);
-/*
-     Reads bytes from the compressed file until len-1 characters are read, or a
-   newline character is read and transferred to buf, or an end-of-file
-   condition is encountered.  If any characters are read or if len == 1, the
-   string is terminated with a null character.  If no characters are read due
-   to an end-of-file or len < 1, then the buffer is left untouched.
-
-     gzgets returns buf which is a null-terminated string, or it returns NULL
-   for end-of-file or in case of error.  If there was an error, the contents at
-   buf are indeterminate.
-*/
-
-ZEXTERN int ZEXPORT gzputc(gzFile file, int c);
-/*
-     Writes c, converted to an unsigned char, into the compressed file.  gzputc
-   returns the value that was written, or -1 in case of error.
-*/
-
-ZEXTERN int ZEXPORT gzgetc(gzFile file);
-/*
-     Reads one byte from the compressed file.  gzgetc returns this byte or -1
-   in case of end of file or error.  This is implemented as a macro for speed.
-   As such, it does not do all of the checking the other functions do.  I.e.
-   it does not check to see if file is NULL, nor whether the structure file
-   points to has been clobbered or not.
-*/
-
-ZEXTERN int ZEXPORT gzungetc(int c, gzFile file);
-/*
-     Push one character back onto the stream to be read as the first character
-   on the next read.  At least one character of push-back is allowed.
-   gzungetc() returns the character pushed, or -1 on failure.  gzungetc() will
-   fail if c is -1, and may fail if a character has been pushed but not read
-   yet.  If gzungetc is used immediately after gzopen or gzdopen, at least the
-   output buffer size of pushed characters is allowed.  (See gzbuffer above.)
-   The pushed character will be discarded if the stream is repositioned with
-   gzseek() or gzrewind().
-*/
-
-ZEXTERN int ZEXPORT gzflush(gzFile file, int flush);
-/*
-     Flushes all pending output into the compressed file.  The parameter flush
-   is as in the deflate() function.  The return value is the zlib error number
-   (see function gzerror below).  gzflush is only permitted when writing.
-
-     If the flush parameter is Z_FINISH, the remaining data is written and the
-   gzip stream is completed in the output.  If gzwrite() is called again, a new
-   gzip stream will be started in the output.  gzread() is able to read such
-   concatented gzip streams.
-
-     gzflush should be called only when strictly necessary because it will
-   degrade compression if called too often.
-*/
-
-/*
-ZEXTERN z_off_t ZEXPORT gzseek (gzFile file, z_off_t offset, int whence);
-
-     Sets the starting position for the next gzread or gzwrite on the given
-   compressed file.  The offset represents a number of bytes in the
-   uncompressed data stream.  The whence parameter is defined as in lseek(2);
-   the value SEEK_END is not supported.
-
-     If the file is opened for reading, this function is emulated but can be
-   extremely slow.  If the file is opened for writing, only forward seeks are
-   supported; gzseek then compresses a sequence of zeroes up to the new
-   starting position.
-
-     gzseek returns the resulting offset location as measured in bytes from
-   the beginning of the uncompressed stream, or -1 in case of error, in
-   particular if the file is opened for writing and the new starting position
-   would be before the current position.
-*/
-
-ZEXTERN int ZEXPORT gzrewind(gzFile file);
-/*
-     Rewinds the given file. This function is supported only for reading.
-
-     gzrewind(file) is equivalent to (int)gzseek(file, 0L, SEEK_SET)
-*/
-
-/*
-ZEXTERN z_off_t ZEXPORT gztell(gzFile file);
-
-     Returns the starting position for the next gzread or gzwrite on the given
-   compressed file.  This position represents a number of bytes in the
-   uncompressed data stream, and is zero when starting, even if appending or
-   reading a gzip stream from the middle of a file using gzdopen().
-
-     gztell(file) is equivalent to gzseek(file, 0L, SEEK_CUR)
-*/
-
-/*
-ZEXTERN z_off_t ZEXPORT gzoffset(gzFile file);
-
-     Returns the current offset in the file being read or written.  This offset
-   includes the count of bytes that precede the gzip stream, for example when
-   appending or when using gzdopen() for reading.  When reading, the offset
-   does not include as yet unused buffered input.  This information can be used
-   for a progress indicator.  On error, gzoffset() returns -1.
-*/
-
-ZEXTERN int ZEXPORT gzeof(gzFile file);
-/*
-     Returns true (1) if the end-of-file indicator has been set while reading,
-   false (0) otherwise.  Note that the end-of-file indicator is set only if the
-   read tried to go past the end of the input, but came up short.  Therefore,
-   just like feof(), gzeof() may return false even if there is no more data to
-   read, in the event that the last read request was for the exact number of
-   bytes remaining in the input file.  This will happen if the input file size
-   is an exact multiple of the buffer size.
-
-     If gzeof() returns true, then the read functions will return no more data,
-   unless the end-of-file indicator is reset by gzclearerr() and the input file
-   has grown since the previous end of file was detected.
-*/
-
-ZEXTERN int ZEXPORT gzdirect(gzFile file);
-/*
-     Returns true (1) if file is being copied directly while reading, or false
-   (0) if file is a gzip stream being decompressed.
-
-     If the input file is empty, gzdirect() will return true, since the input
-   does not contain a gzip stream.
-
-     If gzdirect() is used immediately after gzopen() or gzdopen() it will
-   cause buffers to be allocated to allow reading the file to determine if it
-   is a gzip file.  Therefore if gzbuffer() is used, it should be called before
-   gzdirect().
-
-     When writing, gzdirect() returns true (1) if transparent writing was
-   requested ("wT" for the gzopen() mode), or false (0) otherwise.  (Note:
-   gzdirect() is not needed when writing.  Transparent writing must be
-   explicitly requested, so the application already knows the answer.  When
-   linking statically, using gzdirect() will include all of the zlib code for
-   gzip file reading and decompression, which may not be desired.)
-*/
-
-ZEXTERN int ZEXPORT gzclose(gzFile file);
-/*
-     Flushes all pending output if necessary, closes the compressed file and
-   deallocates the (de)compression state.  Note that once file is closed, you
-   cannot call gzerror with file, since its structures have been deallocated.
-   gzclose must not be called more than once on the same file, just as free
-   must not be called more than once on the same allocation.
-
-     gzclose will return Z_STREAM_ERROR if file is not valid, Z_ERRNO on a
-   file operation error, Z_MEM_ERROR if out of memory, Z_BUF_ERROR if the
-   last read ended in the middle of a gzip stream, or Z_OK on success.
-*/
-
-ZEXTERN int ZEXPORT gzclose_r(gzFile file);
-ZEXTERN int ZEXPORT gzclose_w(gzFile file);
-/*
-     Same as gzclose(), but gzclose_r() is only for use when reading, and
-   gzclose_w() is only for use when writing or appending.  The advantage to
-   using these instead of gzclose() is that they avoid linking in zlib
-   compression or decompression code that is not used when only reading or only
-   writing respectively.  If gzclose() is used, then both compression and
-   decompression code will be included the application when linking to a static
-   zlib library.
-*/
-
-ZEXTERN const char * ZEXPORT gzerror(gzFile file, int *errnum);
-/*
-     Returns the error message for the last error which occurred on the given
-   compressed file.  errnum is set to zlib error number.  If an error occurred
-   in the file system and not in the compression library, errnum is set to
-   Z_ERRNO and the application may consult errno to get the exact error code.
-
-     The application must not modify the returned string.  Future calls to
-   this function may invalidate the previously returned string.  If file is
-   closed, then the string previously returned by gzerror will no longer be
-   available.
-
-     gzerror() should be used to distinguish errors from end-of-file for those
-   functions above that do not distinguish those cases in their return values.
-*/
-
-ZEXTERN void ZEXPORT gzclearerr(gzFile file);
-/*
-     Clears the error and end-of-file flags for file.  This is analogous to the
-   clearerr() function in stdio.  This is useful for continuing to read a gzip
-   file that is being written concurrently.
-*/
-
-#endif /* WITH_GZFILEOP */
-
-                        /* checksum functions */
-
-/*
-     These functions are not related to compression but are exported
-   anyway because they might be useful in applications using the compression
-   library.
-*/
-
-ZEXTERN uint32_t ZEXPORT adler32(uint32_t adler, const unsigned char *buf, uint32_t len);
-/*
-     Update a running Adler-32 checksum with the bytes buf[0..len-1] and
-   return the updated checksum.  If buf is Z_NULL, this function returns the
-   required initial value for the checksum.
-
-     An Adler-32 checksum is almost as reliable as a CRC32 but can be computed
-   much faster.
-
-   Usage example:
-
-     uint32_t adler = adler32(0L, Z_NULL, 0);
-
-     while (read_buffer(buffer, length) != EOF) {
-       adler = adler32(adler, buffer, length);
-     }
-     if (adler != original_adler) error();
-*/
-
-/*
-ZEXTERN uint32_t ZEXPORT adler32_combine(uint32_t adler1, uint32_t adler2, z_off_t len2);
-
-     Combine two Adler-32 checksums into one.  For two sequences of bytes, seq1
-   and seq2 with lengths len1 and len2, Adler-32 checksums were calculated for
-   each, adler1 and adler2.  adler32_combine() returns the Adler-32 checksum of
-   seq1 and seq2 concatenated, requiring only adler1, adler2, and len2.  Note
-   that the z_off_t type (like off_t) is a signed integer.  If len2 is
-   negative, the result has no meaning or utility.
-*/
-
-ZEXTERN uint32_t ZEXPORT crc32(uint32_t crc, const unsigned char *buf, z_off64_t len);
-/*
-     Update a running CRC-32 with the bytes buf[0..len-1] and return the
-   updated CRC-32.  If buf is Z_NULL, this function returns the required
-   initial value for the crc.  Pre- and post-conditioning (one's complement) is
-   performed within this function so it shouldn't be done by the application.
-
-   Usage example:
-
-     uint32_t crc = crc32(0L, Z_NULL, 0);
-
-     while (read_buffer(buffer, length) != EOF) {
-       crc = crc32(crc, buffer, length);
-     }
-     if (crc != original_crc) error();
-*/
-
-/*
-ZEXTERN uint32_t ZEXPORT crc32_combine(uint32_t crc1, uint32_t crc2, z_off64_t len2);
-
-     Combine two CRC-32 check values into one.  For two sequences of bytes,
-   seq1 and seq2 with lengths len1 and len2, CRC-32 check values were
-   calculated for each, crc1 and crc2.  crc32_combine() returns the CRC-32
-   check value of seq1 and seq2 concatenated, requiring only crc1, crc2, and
-   len2.
-*/
-
-
-                        /* various hacks, don't look :) */
-
-/* deflateInit and inflateInit are macros to allow checking the zlib version
- * and the compiler's view of z_stream:
- */
-ZEXTERN int ZEXPORT deflateInit_(z_stream *strm, int level, const char *version, int stream_size);
-ZEXTERN int ZEXPORT inflateInit_(z_stream *strm, const char *version, int stream_size);
-ZEXTERN int ZEXPORT deflateInit2_(z_stream *strm, int  level, int  method, int windowBits, int memLevel,
-                                   int strategy, const char *version, int stream_size);
-ZEXTERN int ZEXPORT inflateInit2_(z_stream *strm, int  windowBits, const char *version, int stream_size);
-ZEXTERN int ZEXPORT inflateBackInit_(z_stream *strm, int windowBits, unsigned char *window,
-                                      const char *version, int stream_size);
-#define deflateInit(strm, level) deflateInit_((strm), (level), ZLIB_VERSION, (int)sizeof(z_stream))
-#define inflateInit(strm) inflateInit_((strm), ZLIB_VERSION, (int)sizeof(z_stream))
-#define deflateInit2(strm, level, method, windowBits, memLevel, strategy) \
-        deflateInit2_((strm), (level), (method), (windowBits), (memLevel), \
-                     (strategy), ZLIB_VERSION, (int)sizeof(z_stream))
-#define inflateInit2(strm, windowBits) inflateInit2_((strm), (windowBits), ZLIB_VERSION, (int)sizeof(z_stream))
-#define inflateBackInit(strm, windowBits, window) \
-                        inflateBackInit_((strm), (windowBits), (window), ZLIB_VERSION, (int)sizeof(z_stream))
-
-#ifdef WITH_GZFILEOP
-
-/* gzgetc() macro and its supporting function and exposed data structure.  Note
- * that the real internal state is much larger than the exposed structure.
- * This abbreviated structure exposes just enough for the gzgetc() macro.  The
- * user should not mess with these exposed elements, since their names or
- * behavior could change in the future, perhaps even capriciously.  They can
- * only be used by the gzgetc() macro.  You have been warned.
- */
-struct gzFile_s {
-    unsigned have;
-    unsigned char *next;
-    z_off64_t pos;
-};
-ZEXTERN int ZEXPORT gzgetc_(gzFile file);  /* backward compatibility */
-#  define gzgetc(g) ((g)->have ? ((g)->have--, (g)->pos++, *((g)->next)++) : gzgetc(g))
-
-/* provide 64-bit offset functions if _LARGEFILE64_SOURCE defined, and/or
- * change the regular functions to 64 bits if _FILE_OFFSET_BITS is 64 (if
- * both are true, the application gets the *64 functions, and the regular
- * functions are changed to 64 bits) -- in case these are set on systems
- * without large file support, _LFS64_LARGEFILE must also be true
- */
-#ifdef Z_LARGE64
-   ZEXTERN gzFile ZEXPORT gzopen64(const char *, const char *);
-   ZEXTERN z_off64_t ZEXPORT gzseek64(gzFile, z_off64_t, int);
-   ZEXTERN z_off64_t ZEXPORT gztell64(gzFile);
-   ZEXTERN z_off64_t ZEXPORT gzoffset64(gzFile);
-#endif
-
-#if !defined(ZLIB_INTERNAL) && defined(Z_WANT64)
-#    define gzopen gzopen64
-#    define gzseek gzseek64
-#    define gztell gztell64
-#    define gzoffset gzoffset64
-#  ifndef Z_LARGE64
-     ZEXTERN gzFile ZEXPORT gzopen64(const char *, const char *);
-     ZEXTERN z_off_t ZEXPORT gzseek64(gzFile, z_off_t, int);
-     ZEXTERN z_off_t ZEXPORT gztell64(gzFile);
-     ZEXTERN z_off_t ZEXPORT gzoffset64(gzFile);
-#  endif
-#else
-   ZEXTERN gzFile ZEXPORT gzopen(const char *, const char *);
-   ZEXTERN z_off_t ZEXPORT gzseek(gzFile, z_off_t, int);
-   ZEXTERN z_off_t ZEXPORT gztell(gzFile);
-   ZEXTERN z_off_t ZEXPORT gzoffset(gzFile);
-#endif
-#endif /* WITH_GZFILEOP */
-
-
-/* provide 64-bit offset functions if _LARGEFILE64_SOURCE defined, and/or
- * change the regular functions to 64 bits if _FILE_OFFSET_BITS is 64 (if
- * both are true, the application gets the *64 functions, and the regular
- * functions are changed to 64 bits) -- in case these are set on systems
- * without large file support, _LFS64_LARGEFILE must also be true
- */
-#ifdef Z_LARGE64
-   ZEXTERN uint32_t ZEXPORT adler32_combine64(uint32_t, uint32_t, z_off64_t);
-   ZEXTERN uint32_t ZEXPORT crc32_combine64(uint32_t, uint32_t, z_off64_t);
-#endif
-
-#if !defined(ZLIB_INTERNAL) && defined(Z_WANT64)
-#    define adler32_combine adler32_combine64
-#    define crc32_combine crc32_combine64
-#  ifndef Z_LARGE64
-     ZEXTERN uint32_t ZEXPORT adler32_combine64(uint32_t, uint32_t, z_off_t);
-     ZEXTERN uint32_t ZEXPORT crc32_combine64(uint32_t, uint32_t, z_off_t);
-#  endif
-#else
-   ZEXTERN uint32_t ZEXPORT adler32_combine(uint32_t, uint32_t, z_off_t);
-   ZEXTERN uint32_t ZEXPORT crc32_combine(uint32_t, uint32_t, z_off_t);
-#endif
-
-
-/* undocumented functions */
-ZEXTERN const char     * ZEXPORT zError           (int);
-ZEXTERN int              ZEXPORT inflateSyncPoint (z_stream *);
-ZEXTERN const uint32_t * ZEXPORT get_crc_table    (void);
-ZEXTERN int              ZEXPORT inflateUndermine (z_stream *, int);
-ZEXTERN int              ZEXPORT inflateResetKeep (z_stream *);
-ZEXTERN int              ZEXPORT deflateResetKeep (z_stream *);
-
-#ifdef WITH_GZFILEOP
-# if (defined(WIN32) || defined(__CYGWIN__) || defined(__MINGW__))
-    ZEXTERN gzFile ZEXPORT gzopen_w(const wchar_t *path, const char *mode);
-# endif
-ZEXTERN int ZEXPORTVA gzvprintf(gzFile file, const char *format, va_list va);
-#endif
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* ZLIB_H_ */
diff --git a/contrib/libzlib-ng/zlib.map b/contrib/libzlib-ng/zlib.map
deleted file mode 100644
index 55c6647eb46..00000000000
--- a/contrib/libzlib-ng/zlib.map
+++ /dev/null
@@ -1,83 +0,0 @@
-ZLIB_1.2.0 {
-  global:
-    compressBound;
-    deflateBound;
-    inflateBack;
-    inflateBackEnd;
-    inflateBackInit_;
-    inflateCopy;
-  local:
-    deflate_copyright;
-    inflate_copyright;
-    inflate_fast;
-    inflate_table;
-    zcalloc;
-    zcfree;
-    z_errmsg;
-    gz_error;
-    gz_intmax;
-    _*;
-};
-
-ZLIB_1.2.0.2 {
-    gzclearerr;
-    gzungetc;
-    zlibCompileFlags;
-} ZLIB_1.2.0;
-
-ZLIB_1.2.0.8 {
-    deflatePrime;
-} ZLIB_1.2.0.2;
-
-ZLIB_1.2.2 {
-    adler32_combine;
-    crc32_combine;
-    deflateSetHeader;
-    inflateGetHeader;
-} ZLIB_1.2.0.8;
-
-ZLIB_1.2.2.3 {
-    deflateTune;
-    gzdirect;
-} ZLIB_1.2.2;
-
-ZLIB_1.2.2.4 {
-    inflatePrime;
-} ZLIB_1.2.2.3;
-
-ZLIB_1.2.3.3 {
-    adler32_combine64;
-    crc32_combine64;
-    gzopen64;
-    gzseek64;
-    gztell64;
-    inflateUndermine;
-} ZLIB_1.2.2.4;
-
-ZLIB_1.2.3.4 {
-    inflateReset2;
-    inflateMark;
-} ZLIB_1.2.3.3;
-
-ZLIB_1.2.3.5 {
-    gzbuffer;
-    gzoffset;
-    gzoffset64;
-    gzclose_r;
-    gzclose_w;
-} ZLIB_1.2.3.4;
-
-ZLIB_1.2.5.1 {
-    deflatePending;
-} ZLIB_1.2.3.5;
-
-ZLIB_1.2.5.2 {
-    deflateResetKeep;
-    gzgetc_;
-    inflateResetKeep;
-} ZLIB_1.2.5.1;
-
-ZLIB_1.2.7.1 {
-    inflateGetDictionary;
-    gzvprintf;
-} ZLIB_1.2.5.2;
diff --git a/contrib/libzlib-ng/zlib.pc.cmakein b/contrib/libzlib-ng/zlib.pc.cmakein
deleted file mode 100644
index a5e642938c6..00000000000
--- a/contrib/libzlib-ng/zlib.pc.cmakein
+++ /dev/null
@@ -1,13 +0,0 @@
-prefix=@CMAKE_INSTALL_PREFIX@
-exec_prefix=@CMAKE_INSTALL_PREFIX@
-libdir=@INSTALL_LIB_DIR@
-sharedlibdir=@INSTALL_LIB_DIR@
-includedir=@INSTALL_INC_DIR@
-
-Name: zlib
-Description: zlib compression library
-Version: @VERSION@
-
-Requires:
-Libs: -L${libdir} -L${sharedlibdir} -lz
-Cflags: -I${includedir}
diff --git a/contrib/libzlib-ng/zlib.pc.in b/contrib/libzlib-ng/zlib.pc.in
deleted file mode 100644
index 7e5acf9c77e..00000000000
--- a/contrib/libzlib-ng/zlib.pc.in
+++ /dev/null
@@ -1,13 +0,0 @@
-prefix=@prefix@
-exec_prefix=@exec_prefix@
-libdir=@libdir@
-sharedlibdir=@sharedlibdir@
-includedir=@includedir@
-
-Name: zlib
-Description: zlib compression library
-Version: @VERSION@
-
-Requires:
-Libs: -L${libdir} -L${sharedlibdir} -lz
-Cflags: -I${includedir}
diff --git a/contrib/libzlib-ng/zutil.c b/contrib/libzlib-ng/zutil.c
deleted file mode 100644
index e46277b8786..00000000000
--- a/contrib/libzlib-ng/zutil.c
+++ /dev/null
@@ -1,124 +0,0 @@
-/* zutil.c -- target dependent utility functions for the compression library
- * Copyright (C) 1995-2005, 2010, 2011, 2012 Jean-loup Gailly.
- * For conditions of distribution and use, see copyright notice in zlib.h
- */
-
-/* @(#) $Id$ */
-
-#include "zutil.h"
-#ifdef WITH_GZFILEOP
-#  include "gzguts.h"
-#endif
-
-const char * const z_errmsg[10] = {
-"need dictionary",     /* Z_NEED_DICT       2  */
-"stream end",          /* Z_STREAM_END      1  */
-"",                    /* Z_OK              0  */
-"file error",          /* Z_ERRNO         (-1) */
-"stream error",        /* Z_STREAM_ERROR  (-2) */
-"data error",          /* Z_DATA_ERROR    (-3) */
-"insufficient memory", /* Z_MEM_ERROR     (-4) */
-"buffer error",        /* Z_BUF_ERROR     (-5) */
-"incompatible version",/* Z_VERSION_ERROR (-6) */
-""};
-
-const char zlibng_string[] =
-   " zlib-ng 1.9.9 forked from zlib 1.2.8 ";
-
-const char * ZEXPORT zlibVersion(void)
-{
-    return ZLIB_VERSION;
-}
-
-unsigned long ZEXPORT zlibCompileFlags(void)
-{
-    unsigned long flags;
-
-    flags = 0;
-    switch ((int)(sizeof(unsigned int))) {
-    case 2:     break;
-    case 4:     flags += 1;     break;
-    case 8:     flags += 2;     break;
-    default:    flags += 3;
-    }
-    switch ((int)(sizeof(unsigned long))) {
-    case 2:     break;
-    case 4:     flags += 1 << 2;        break;
-    case 8:     flags += 2 << 2;        break;
-    default:    flags += 3 << 2;
-    }
-    switch ((int)(sizeof(void *))) {
-    case 2:     break;
-    case 4:     flags += 1 << 4;        break;
-    case 8:     flags += 2 << 4;        break;
-    default:    flags += 3 << 4;
-    }
-    switch ((int)(sizeof(z_off_t))) {
-    case 2:     break;
-    case 4:     flags += 1 << 6;        break;
-    case 8:     flags += 2 << 6;        break;
-    default:    flags += 3 << 6;
-    }
-#ifdef DEBUG
-    flags += 1 << 8;
-#endif
-#ifdef ZLIB_WINAPI
-    flags += 1 << 10;
-#endif
-#ifdef BUILDFIXED
-    flags += 1 << 12;
-#endif
-#ifdef DYNAMIC_CRC_TABLE
-    flags += 1 << 13;
-#endif
-#ifdef NO_GZCOMPRESS
-    flags += 1L << 16;
-#endif
-#ifdef NO_GZIP
-    flags += 1L << 17;
-#endif
-#ifdef PKZIP_BUG_WORKAROUND
-    flags += 1L << 20;
-#endif
-    return flags;
-}
-
-#ifdef DEBUG
-
-#  ifndef verbose
-#    define verbose 0
-#  endif
-int ZLIB_INTERNAL z_verbose = verbose;
-
-void ZLIB_INTERNAL z_error (m)
-    char *m;
-{
-    fprintf(stderr, "%s\n", m);
-    exit(1);
-}
-#endif
-
-/* exported to allow conversion of error code to string for compress() and
- * uncompress()
- */
-const char * ZEXPORT zError(int err)
-{
-    return ERR_MSG(err);
-}
-
-#ifndef MY_ZCALLOC /* Any system without a special alloc function */
-
-void ZLIB_INTERNAL *zcalloc (void *opaque, unsigned items, unsigned size)
-{
-    (void)opaque;
-    return sizeof(unsigned int) > 2 ? (void *)malloc(items * size) :
-                              (void *)calloc(items, size);
-}
-
-void ZLIB_INTERNAL zcfree (void *opaque, void *ptr)
-{
-    (void)opaque;
-    free(ptr);
-}
-
-#endif /* MY_ZCALLOC */
diff --git a/contrib/libzlib-ng/zutil.h b/contrib/libzlib-ng/zutil.h
deleted file mode 100644
index b6e858c9cd2..00000000000
--- a/contrib/libzlib-ng/zutil.h
+++ /dev/null
@@ -1,185 +0,0 @@
-#ifndef ZUTIL_H_
-#define ZUTIL_H_
-/* zutil.h -- internal interface and configuration of the compression library
- * Copyright (C) 1995-2013 Jean-loup Gailly.
- * For conditions of distribution and use, see copyright notice in zlib.h
- */
-
-/* WARNING: this file should *not* be used by applications. It is
-   part of the implementation of the compression library and is
-   subject to change. Applications should only use zlib.h.
- */
-
-/* @(#) $Id$ */
-
-#if defined(HAVE_INTERNAL)
-#  define ZLIB_INTERNAL __attribute__((visibility ("internal")))
-#elif defined(HAVE_HIDDEN)
-#  define ZLIB_INTERNAL __attribute__((visibility ("hidden")))
-#else
-#  define ZLIB_INTERNAL
-#endif
-
-#include <stddef.h>
-#include <string.h>
-#include <stdlib.h>
-#include <stdint.h>
-#include "zlib.h"
-
-#ifndef local
-#  define local static
-#endif
-/* compile with -Dlocal if your debugger can't find static symbols */
-
-typedef unsigned char uch; /* Included for compatibility with external code only */
-typedef uint16_t ush;      /* Included for compatibility with external code only */
-typedef unsigned long  ulg;
-
-extern const char * const z_errmsg[10]; /* indexed by 2-zlib_error */
-/* (size given to avoid silly warnings with Visual C++) */
-
-#define ERR_MSG(err) z_errmsg[Z_NEED_DICT-(err)]
-
-#define ERR_RETURN(strm, err) return (strm->msg = ERR_MSG(err), (err))
-/* To be used only when the state is known to be valid */
-
-        /* common constants */
-
-#ifndef DEF_WBITS
-#  define DEF_WBITS MAX_WBITS
-#endif
-/* default windowBits for decompression. MAX_WBITS is for compression only */
-
-#if MAX_MEM_LEVEL >= 8
-#  define DEF_MEM_LEVEL 8
-#else
-#  define DEF_MEM_LEVEL  MAX_MEM_LEVEL
-#endif
-/* default memLevel */
-
-#define STORED_BLOCK 0
-#define STATIC_TREES 1
-#define DYN_TREES    2
-/* The three kinds of block type */
-
-#define MIN_MATCH  3
-#define MAX_MATCH  258
-/* The minimum and maximum match lengths */
-
-#define PRESET_DICT 0x20 /* preset dictionary flag in zlib header */
-
-        /* target dependencies */
-
-#ifdef WIN32
-#  ifndef __CYGWIN__  /* Cygwin is Unix, not Win32 */
-#    define OS_CODE  0x0b
-#  endif
-#endif
-
-#if (defined(_MSC_VER) && (_MSC_VER > 600))
-#  define fdopen(fd, type)  _fdopen(fd, type)
-#endif
-
-/* provide prototypes for these when building zlib without LFS */
-#if !defined(WIN32) && !defined(__MSYS__) && (!defined(_LARGEFILE64_SOURCE) || _LFS64_LARGEFILE-0 == 0)
-    ZEXTERN uint32_t ZEXPORT adler32_combine64(uint32_t, uint32_t, z_off_t);
-    ZEXTERN uint32_t ZEXPORT crc32_combine64(uint32_t, uint32_t, z_off_t);
-#endif
-
-/* MS Visual Studio does not allow inline in C, only C++.
-   But it provides __inline instead, so use that. */
-#if defined(_MSC_VER) && !defined(inline)
-#  define inline __inline
-#endif
-
-        /* common defaults */
-
-#ifndef OS_CODE
-#  define OS_CODE  0x03  /* assume Unix */
-#endif
-
-#ifndef F_OPEN
-#  define F_OPEN(name, mode) fopen((name), (mode))
-#endif
-
-         /* functions */
-
-/* Diagnostic functions */
-#ifdef DEBUG
-#   include <stdio.h>
-    extern int ZLIB_INTERNAL z_verbose;
-    extern void ZLIB_INTERNAL z_error(char *m);
-#   define Assert(cond, msg) {if(!(cond)) z_error(msg);}
-#   define Trace(x) {if (z_verbose >= 0) fprintf x;}
-#   define Tracev(x) {if (z_verbose > 0) fprintf x;}
-#   define Tracevv(x) {if (z_verbose > 1) fprintf x;}
-#   define Tracec(c, x) {if (z_verbose > 0 && (c)) fprintf x;}
-#   define Tracecv(c, x) {if (z_verbose > 1 && (c)) fprintf x;}
-#else
-#   define Assert(cond, msg)
-#   define Trace(x)
-#   define Tracev(x)
-#   define Tracevv(x)
-#   define Tracec(c, x)
-#   define Tracecv(c, x)
-#endif
-
-void ZLIB_INTERNAL *zcalloc(void *opaque, unsigned items, unsigned size);
-void ZLIB_INTERNAL   zcfree(void *opaque, void *ptr);
-
-#define ZALLOC(strm, items, size) (*((strm)->zalloc))((strm)->opaque, (items), (size))
-#define ZFREE(strm, addr)         (*((strm)->zfree))((strm)->opaque, (void *)(addr))
-#define TRY_FREE(s, p) {if (p) ZFREE(s, p);}
-
-/* Reverse the bytes in a 32-bit value. Use compiler intrinsics when
-   possible to take advantage of hardware implementations. */
-#if defined(WIN32) && (_MSC_VER >= 1300)
-#  pragma intrinsic(_byteswap_ulong)
-#  define ZSWAP32(q) _byteswap_ulong(q)
-
-#elif defined(__Clang__) || (defined(__GNUC__) && \
-        (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2)))
-#  define ZSWAP32(q) __builtin_bswap32(q)
-
-#elif defined(__GNUC__) && (__GNUC__ >= 2) && defined(__linux__)
-#  include <byteswap.h>
-#  define ZSWAP32(q) bswap_32(q)
-
-#elif defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__) || defined(__DragonFly__)
-#  include <sys/endian.h>
-#  define ZSWAP32(q) bswap32(q)
-
-#elif defined(__INTEL_COMPILER)
-#  define ZSWAP32(q) _bswap(q)
-
-#else
-#  define ZSWAP32(q) ((((q) >> 24) & 0xff) + (((q) >> 8) & 0xff00) + \
-                    (((q) & 0xff00) << 8) + (((q) & 0xff) << 24))
-#endif /* ZSWAP32 */
-
-/* Only enable likely/unlikely if the compiler is known to support it */
-#if (defined(__GNUC__) && (__GNUC__ >= 3)) || defined(__INTEL_COMPILER) || defined(__Clang__)
-#  ifndef likely
-#    define likely(x)      __builtin_expect(!!(x), 1)
-#  endif
-#  ifndef unlikely
-#    define unlikely(x)    __builtin_expect(!!(x), 0)
-#  endif
-#else
-#  ifndef likely
-#    define likely(x)      x
-#  endif
-#  ifndef unlikely
-#    define unlikely(x)    x
-#  endif
-#endif /* (un)likely */
-
-#if defined(_MSC_VER)
-#define ALIGNED_(x) __declspec(align(x))
-#else
-#if defined(__GNUC__)
-#define ALIGNED_(x) __attribute__ ((aligned(x)))
-#endif
-#endif
-
-#endif /* ZUTIL_H_ */

From b972516bfc2f8433ba6e00f572f278ca14158e34 Mon Sep 17 00:00:00 2001
From: proller <proller@github.com>
Date: Wed, 22 Nov 2017 15:15:17 +0300
Subject: [PATCH 009/107] Zlib: remove unused test targets

---
 cmake/find_zlib.cmake  | 1 +
 contrib/CMakeLists.txt | 4 ++++
 2 files changed, 5 insertions(+)

diff --git a/cmake/find_zlib.cmake b/cmake/find_zlib.cmake
index 93e62497c25..3b41280f1c5 100644
--- a/cmake/find_zlib.cmake
+++ b/cmake/find_zlib.cmake
@@ -7,6 +7,7 @@ endif ()
 if (NOT ZLIB_FOUND)
     set (USE_INTERNAL_ZLIB_LIBRARY 1)
     set (ZLIB_COMPAT 1) # for zlib-ng, also enables WITH_GZFILEOP
+    set (WITH_NATIVE_INSTRUCTIONS ${ARCHNATIVE})
     set (ZLIB_INCLUDE_DIR "${ClickHouse_SOURCE_DIR}/contrib/libzlib-ng" "${ClickHouse_BINARY_DIR}/contrib/libzlib-ng") # generated zconf.h
     set (ZLIB_INCLUDE_DIRS ${ZLIB_INCLUDE_DIR}) # for poco
     set (ZLIB_FOUND 1) # for poco
diff --git a/contrib/CMakeLists.txt b/contrib/CMakeLists.txt
index 137eea988bc..814e1c54c08 100644
--- a/contrib/CMakeLists.txt
+++ b/contrib/CMakeLists.txt
@@ -50,6 +50,10 @@ if (USE_INTERNAL_ZLIB_LIBRARY)
     # We should use same defines when including zlib.h as used when zlib compiled
     target_compile_definitions (zlib PUBLIC ZLIB_COMPAT WITH_GZFILEOP)
     target_compile_definitions (zlibstatic PUBLIC ZLIB_COMPAT WITH_GZFILEOP)
+    set_target_properties(example PROPERTIES EXCLUDE_FROM_ALL 1)
+    set_target_properties(example64 PROPERTIES EXCLUDE_FROM_ALL 1)
+    set_target_properties(minigzip PROPERTIES EXCLUDE_FROM_ALL 1)
+    set_target_properties(minigzip64 PROPERTIES EXCLUDE_FROM_ALL 1)
 endif ()
 
 if (USE_INTERNAL_CCTZ_LIBRARY)

From 5d21519d2762895ce02571962ff2ca25e742b590 Mon Sep 17 00:00:00 2001
From: proller <proller@github.com>
Date: Wed, 22 Nov 2017 17:03:09 +0300
Subject: [PATCH 010/107] Freebsd: zlib: dont use optimizations (broken asm)

---
 cmake/find_zlib.cmake | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/cmake/find_zlib.cmake b/cmake/find_zlib.cmake
index 3b41280f1c5..d38ef13a5e9 100644
--- a/cmake/find_zlib.cmake
+++ b/cmake/find_zlib.cmake
@@ -8,6 +8,9 @@ if (NOT ZLIB_FOUND)
     set (USE_INTERNAL_ZLIB_LIBRARY 1)
     set (ZLIB_COMPAT 1) # for zlib-ng, also enables WITH_GZFILEOP
     set (WITH_NATIVE_INSTRUCTIONS ${ARCHNATIVE})
+    if (CMAKE_SYSTEM MATCHES "FreeBSD")
+        set (WITH_OPTIM 0 CACHE INTERNAL "") # Bug in assembler
+    endif ()
     set (ZLIB_INCLUDE_DIR "${ClickHouse_SOURCE_DIR}/contrib/libzlib-ng" "${ClickHouse_BINARY_DIR}/contrib/libzlib-ng") # generated zconf.h
     set (ZLIB_INCLUDE_DIRS ${ZLIB_INCLUDE_DIR}) # for poco
     set (ZLIB_FOUND 1) # for poco

From 2ea3e6c67fe468a6b69263a0a15cdbee3d4f432e Mon Sep 17 00:00:00 2001
From: proller <proller@github.com>
Date: Wed, 22 Nov 2017 22:15:17 +0300
Subject: [PATCH 011/107] Fix include path contrib/zlib-ng

---
 cmake/find_poco.cmake  | 4 ++--
 cmake/find_zlib.cmake  | 2 +-
 utils/check_include.sh | 4 ++--
 3 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/cmake/find_poco.cmake b/cmake/find_poco.cmake
index c63cbc3da13..19b0cf3ffca 100644
--- a/cmake/find_poco.cmake
+++ b/cmake/find_poco.cmake
@@ -62,8 +62,8 @@ else ()
 
     if (USE_STATIC_LIBRARIES AND USE_INTERNAL_ZLIB_LIBRARY)
         list (APPEND Poco_INCLUDE_DIRS
-            "${ClickHouse_SOURCE_DIR}/contrib/libzlib-ng/"
-            "${ClickHouse_BINARY_DIR}/contrib/libzlib-ng/"
+            "${ClickHouse_SOURCE_DIR}/contrib/zlib-ng/"
+            "${ClickHouse_BINARY_DIR}/contrib/zlib-ng/"
         )
     endif ()
 
diff --git a/cmake/find_zlib.cmake b/cmake/find_zlib.cmake
index d38ef13a5e9..db26c0ad2de 100644
--- a/cmake/find_zlib.cmake
+++ b/cmake/find_zlib.cmake
@@ -11,7 +11,7 @@ if (NOT ZLIB_FOUND)
     if (CMAKE_SYSTEM MATCHES "FreeBSD")
         set (WITH_OPTIM 0 CACHE INTERNAL "") # Bug in assembler
     endif ()
-    set (ZLIB_INCLUDE_DIR "${ClickHouse_SOURCE_DIR}/contrib/libzlib-ng" "${ClickHouse_BINARY_DIR}/contrib/libzlib-ng") # generated zconf.h
+    set (ZLIB_INCLUDE_DIR "${ClickHouse_SOURCE_DIR}/contrib/zlib-ng" "${ClickHouse_BINARY_DIR}/contrib/zlib-ng") # generated zconf.h
     set (ZLIB_INCLUDE_DIRS ${ZLIB_INCLUDE_DIR}) # for poco
     set (ZLIB_FOUND 1) # for poco
     if (USE_STATIC_LIBRARIES)
diff --git a/utils/check_include.sh b/utils/check_include.sh
index 22429d16a40..80c39ddff0c 100755
--- a/utils/check_include.sh
+++ b/utils/check_include.sh
@@ -15,8 +15,8 @@ inc="-I. \
 -I./contrib/zookeeper/src/c/include \
 -I./contrib/zookeeper/src/c/generated \
 -I./contrib/libtcmalloc/include \
--I./build/contrib/libzlib-ng \
--I./contrib/libzlib-ng \
+-I./build/contrib/zlib-ng \
+-I./contrib/zlib-ng \
 -I./contrib/poco/MongoDB/include \
 -I./contrib/poco/XML/include \
 -I./contrib/poco/Crypto/include \

From c0dab866d9be60d88e5c3f860e76bfe4da6faef3 Mon Sep 17 00:00:00 2001
From: proller <proller@github.com>
Date: Fri, 17 Nov 2017 16:14:13 +0300
Subject: [PATCH 012/107] Update build_debian.sh

---
 utils/build/build_debian.sh | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/utils/build/build_debian.sh b/utils/build/build_debian.sh
index 6124c1b482d..6d9594049b4 100755
--- a/utils/build/build_debian.sh
+++ b/utils/build/build_debian.sh
@@ -6,9 +6,9 @@
 # curl https://raw.githubusercontent.com/yandex/ClickHouse/master/utils/build/build_debian.sh | sh
 
 # install compiler and libs
-sudo apt install -y git bash cmake gcc-6 g++-6 libicu-dev libreadline-dev libmysqlclient-dev unixodbc-dev libltdl-dev libssl-dev
+sudo apt install -y git bash cmake gcc-7 g++-7 libicu-dev libreadline-dev libmysqlclient-dev unixodbc-dev libltdl-dev libssl-dev
 # for -DUNBUNDLED=1 mode:
-#sudo apt install -y libboost-dev zlib1g-dev liblz4-dev libdouble-conversion-dev libzstd-dev libre2-dev libzookeeper-mt-dev libsparsehash-dev  #  libpoco-dev
+#sudo apt install -y libboost-dev zlib1g-dev liblz4-dev libdouble-conversion-dev libzstd-dev libre2-dev libzookeeper-mt-dev libsparsehash-dev librdkafka-dev libpoco-dev libsparsehash-dev libgoogle-perftools-dev libunwind-dev libzstd-dev
 
 # install testing only stuff if you want:
 sudo apt install -y python python-lxml python-termcolor curl perl
@@ -19,7 +19,7 @@ git clone --recursive https://github.com/yandex/ClickHouse.git
 # Build!
 mkdir -p ClickHouse/build
 cd ClickHouse/build
-cmake .. -DCMAKE_CXX_COMPILER=`which g++-6` -DCMAKE_C_COMPILER=`which gcc-6`
+cmake .. -DCMAKE_CXX_COMPILER=`which g++-7` -DCMAKE_C_COMPILER=`which gcc-7`
 
 make -j $(nproc || sysctl -n hw.ncpu || echo 2)
 cd ..

From 33faccbfd325908fb70d9445be43a18d04136ab3 Mon Sep 17 00:00:00 2001
From: Vitaliy Lyudvichenko <vludv@yandex-team.ru>
Date: Wed, 29 Nov 2017 15:37:55 +0300
Subject: [PATCH 013/107] Update compiler version. [#CLICKHOUSE-2]

---
 release | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/release b/release
index 255f973eb91..ed622de6487 100755
--- a/release
+++ b/release
@@ -7,8 +7,8 @@ cd $CURDIR
 
 source "./release_lib.sh"
 
-DEB_CC=gcc-6
-DEB_CXX=g++-6
+DEB_CC=gcc-7
+DEB_CXX=g++-7
 
 CONTROL=debian/control
 DEBUILD_NOSIGN_OPTIONS="-us -uc"

From 9b7f75940a852273e46d1e4559a87bb9e9756668 Mon Sep 17 00:00:00 2001
From: Vitaliy Lyudvichenko <vludv@yandex-team.ru>
Date: Thu, 30 Nov 2017 16:34:07 +0300
Subject: [PATCH 014/107] Added missing include dirs for dynamic compilation.
 [#CLICKHOUSE-2]

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

diff --git a/dbms/src/Interpreters/Compiler.cpp b/dbms/src/Interpreters/Compiler.cpp
index fde9e717690..e791ac7457a 100644
--- a/dbms/src/Interpreters/Compiler.cpp
+++ b/dbms/src/Interpreters/Compiler.cpp
@@ -215,7 +215,7 @@ void Compiler::compile(
 
     std::stringstream command;
 
-    /// Slightly unconvenient.
+    /// Slightly inconvenient.
     command <<
         "LD_LIBRARY_PATH=" PATH_SHARE "/clickhouse/bin/"
         " " INTERNAL_COMPILER_EXECUTABLE
@@ -224,6 +224,7 @@ void Compiler::compile(
 #if INTERNAL_COMPILER_CUSTOM_ROOT
         " -isystem " INTERNAL_COMPILER_HEADERS_ROOT "/usr/local/include/"
         " -isystem " INTERNAL_COMPILER_HEADERS_ROOT "/usr/include/"
+        " -isystem " INTERNAL_COMPILER_HEADERS_ROOT "/usr/local/include/c++/*/"
         " -isystem " INTERNAL_COMPILER_HEADERS_ROOT "/usr/include/c++/*/"
         " -isystem " INTERNAL_COMPILER_HEADERS_ROOT "/usr/include/x86_64-linux-gnu/"
         " -isystem " INTERNAL_COMPILER_HEADERS_ROOT "/usr/include/x86_64-linux-gnu/c++/*/"

From 902c9374b62bcbdd2fcb787665312643b6145a29 Mon Sep 17 00:00:00 2001
From: proller <proller@github.com>
Date: Thu, 30 Nov 2017 20:09:33 +0300
Subject: [PATCH 015/107] zlib fix flags in headers

---
 contrib/CMakeLists.txt                        |  5 +++
 dbms/src/IO/ZlibDeflatingWriteBuffer.cpp      |  2 +-
 dbms/src/IO/ZlibInflatingReadBuffer.cpp       |  2 +-
 .../0_stateless/00302_http_compression.sh     | 36 ++++++++++---------
 4 files changed, 27 insertions(+), 18 deletions(-)

diff --git a/contrib/CMakeLists.txt b/contrib/CMakeLists.txt
index 814e1c54c08..3f46ccfaaca 100644
--- a/contrib/CMakeLists.txt
+++ b/contrib/CMakeLists.txt
@@ -50,6 +50,11 @@ if (USE_INTERNAL_ZLIB_LIBRARY)
     # We should use same defines when including zlib.h as used when zlib compiled
     target_compile_definitions (zlib PUBLIC ZLIB_COMPAT WITH_GZFILEOP)
     target_compile_definitions (zlibstatic PUBLIC ZLIB_COMPAT WITH_GZFILEOP)
+    if(CMAKE_SYSTEM_PROCESSOR MATCHES "x86_64" OR CMAKE_SYSTEM_PROCESSOR MATCHES "AMD64")
+       target_compile_definitions (zlib PUBLIC X86_64)
+       target_compile_definitions (zlibstatic PUBLIC X86_64)
+    endif ()
+
     set_target_properties(example PROPERTIES EXCLUDE_FROM_ALL 1)
     set_target_properties(example64 PROPERTIES EXCLUDE_FROM_ALL 1)
     set_target_properties(minigzip PROPERTIES EXCLUDE_FROM_ALL 1)
diff --git a/dbms/src/IO/ZlibDeflatingWriteBuffer.cpp b/dbms/src/IO/ZlibDeflatingWriteBuffer.cpp
index c2165c382a9..61450e19db4 100644
--- a/dbms/src/IO/ZlibDeflatingWriteBuffer.cpp
+++ b/dbms/src/IO/ZlibDeflatingWriteBuffer.cpp
@@ -34,7 +34,7 @@ ZlibDeflatingWriteBuffer::ZlibDeflatingWriteBuffer(
 #pragma GCC diagnostic pop
 
     if (rc != Z_OK)
-        throw Exception(std::string("deflateInit2 failed: ") + zError(rc), ErrorCodes::ZLIB_DEFLATE_FAILED);
+        throw Exception(std::string("deflateInit2 failed: ") + zError(rc) + "; zlib version: " + ZLIB_VERSION, ErrorCodes::ZLIB_DEFLATE_FAILED);
 }
 
 ZlibDeflatingWriteBuffer::~ZlibDeflatingWriteBuffer()
diff --git a/dbms/src/IO/ZlibInflatingReadBuffer.cpp b/dbms/src/IO/ZlibInflatingReadBuffer.cpp
index 869108515d3..8100cf88de7 100644
--- a/dbms/src/IO/ZlibInflatingReadBuffer.cpp
+++ b/dbms/src/IO/ZlibInflatingReadBuffer.cpp
@@ -34,7 +34,7 @@ ZlibInflatingReadBuffer::ZlibInflatingReadBuffer(
 #pragma GCC diagnostic pop
 
     if (rc != Z_OK)
-        throw Exception(std::string("inflateInit2 failed: ") + zError(rc), ErrorCodes::ZLIB_INFLATE_FAILED);
+        throw Exception(std::string("inflateInit2 failed: ") + zError(rc) + "; zlib version: " + ZLIB_VERSION, ErrorCodes::ZLIB_INFLATE_FAILED);
 }
 
 ZlibInflatingReadBuffer::~ZlibInflatingReadBuffer()
diff --git a/dbms/tests/queries/0_stateless/00302_http_compression.sh b/dbms/tests/queries/0_stateless/00302_http_compression.sh
index f71b8975fd0..013f3988d0e 100755
--- a/dbms/tests/queries/0_stateless/00302_http_compression.sh
+++ b/dbms/tests/queries/0_stateless/00302_http_compression.sh
@@ -1,24 +1,28 @@
 #!/usr/bin/env bash
 
-curl -sS 'http://localhost:8123/?enable_http_compression=1'                                     -d 'SELECT number FROM system.numbers LIMIT 10';
-curl -sS 'http://localhost:8123/?enable_http_compression=0' -H 'Accept-Encoding: gzip'          -d 'SELECT number FROM system.numbers LIMIT 10';
-curl -sS 'http://localhost:8123/?enable_http_compression=1' -H 'Accept-Encoding: gzip'          -d 'SELECT number FROM system.numbers LIMIT 10' | gzip -d;
-curl -sS 'http://localhost:8123/?enable_http_compression=1' -H 'Accept-Encoding: gzip, deflate' -d 'SELECT number FROM system.numbers LIMIT 10' | gzip -d;
-curl -sS 'http://localhost:8123/?enable_http_compression=1' -H 'Accept-Encoding: zip, eflate'   -d 'SELECT number FROM system.numbers LIMIT 10';
+CURDIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
+. $CURDIR/../shell_config.sh
 
-curl -vsS 'http://localhost:8123/?enable_http_compression=1'                                     -d 'SELECT number FROM system.numbers LIMIT 10' 2>&1 | grep --text '< Content-Encoding';
-curl -vsS 'http://localhost:8123/?enable_http_compression=1' -H 'Accept-Encoding: gzip'          -d 'SELECT number FROM system.numbers LIMIT 10' 2>&1 | grep --text '< Content-Encoding';
-curl -vsS 'http://localhost:8123/?enable_http_compression=1' -H 'Accept-Encoding: deflate'       -d 'SELECT number FROM system.numbers LIMIT 10' 2>&1 | grep --text '< Content-Encoding';
-curl -vsS 'http://localhost:8123/?enable_http_compression=1' -H 'Accept-Encoding: gzip, deflate' -d 'SELECT number FROM system.numbers LIMIT 10' 2>&1 | grep --text '< Content-Encoding';
-curl -vsS 'http://localhost:8123/?enable_http_compression=1' -H 'Accept-Encoding: zip, eflate'   -d 'SELECT number FROM system.numbers LIMIT 10' 2>&1 | grep --text '< Content-Encoding';
 
-echo "SELECT 1" | curl -sS --data-binary @- 'http://localhost:8123/';
-echo "SELECT 1" | gzip -c | curl -sS --data-binary @- -H 'Content-Encoding: gzip' 'http://localhost:8123/';
+${CLICKHOUSE_CURL} -sS "${CLICKHOUSE_URL}?enable_http_compression=1"                                     -d 'SELECT number FROM system.numbers LIMIT 10';
+${CLICKHOUSE_CURL} -sS "${CLICKHOUSE_URL}?enable_http_compression=0" -H 'Accept-Encoding: gzip'          -d 'SELECT number FROM system.numbers LIMIT 10';
+${CLICKHOUSE_CURL} -sS "${CLICKHOUSE_URL}?enable_http_compression=1" -H 'Accept-Encoding: gzip'          -d 'SELECT number FROM system.numbers LIMIT 10' | gzip -d;
+${CLICKHOUSE_CURL} -sS "${CLICKHOUSE_URL}?enable_http_compression=1" -H 'Accept-Encoding: gzip, deflate' -d 'SELECT number FROM system.numbers LIMIT 10' | gzip -d;
+${CLICKHOUSE_CURL} -sS "${CLICKHOUSE_URL}?enable_http_compression=1" -H 'Accept-Encoding: zip, eflate'   -d 'SELECT number FROM system.numbers LIMIT 10';
 
-echo "'Hello, world'" | curl -sS --data-binary @- 'http://localhost:8123/?query=SELECT';
-echo "'Hello, world'" | gzip -c | curl -sS --data-binary @- -H 'Content-Encoding: gzip' 'http://localhost:8123/?query=SELECT';
+${CLICKHOUSE_CURL} -vsS "${CLICKHOUSE_URL}?enable_http_compression=1"                                     -d 'SELECT number FROM system.numbers LIMIT 10' 2>&1 | grep --text '< Content-Encoding';
+${CLICKHOUSE_CURL} -vsS "${CLICKHOUSE_URL}?enable_http_compression=1" -H 'Accept-Encoding: gzip'          -d 'SELECT number FROM system.numbers LIMIT 10' 2>&1 | grep --text '< Content-Encoding';
+${CLICKHOUSE_CURL} -vsS "${CLICKHOUSE_URL}?enable_http_compression=1" -H 'Accept-Encoding: deflate'       -d 'SELECT number FROM system.numbers LIMIT 10' 2>&1 | grep --text '< Content-Encoding';
+${CLICKHOUSE_CURL} -vsS "${CLICKHOUSE_URL}?enable_http_compression=1" -H 'Accept-Encoding: gzip, deflate' -d 'SELECT number FROM system.numbers LIMIT 10' 2>&1 | grep --text '< Content-Encoding';
+ -vsS '${CLICKHOUSE_URL}?enable_http_compression=1' -H 'Accept-Encoding: zip, eflate'   -d 'SELECT number FROM system.numbers LIMIT 10' 2>&1 | grep --text '< Content-Encoding';
 
-curl -sS 'http://localhost:8123/?enable_http_compression=1' -H 'Accept-Encoding: gzip'          -d 'SELECT number FROM system.numbers LIMIT 0' | wc -c;
+echo "SELECT 1" | ${CLICKHOUSE_CURL} -sS --data-binary @- ${CLICKHOUSE_URL};
+echo "SELECT 1" | gzip -c | ${CLICKHOUSE_CURL} -sS --data-binary @- -H 'Content-Encoding: gzip' ${CLICKHOUSE_URL};
+
+echo "'Hello, world'" | ${CLICKHOUSE_CURL} -sS --data-binary @- "${CLICKHOUSE_URL}?query=SELECT";
+echo "'Hello, world'" | gzip -c | ${CLICKHOUSE_CURL} -sS --data-binary @- -H 'Content-Encoding: gzip' "${CLICKHOUSE_URL}?query=SELECT";
+
+${CLICKHOUSE_CURL} -sS "${CLICKHOUSE_URL}?enable_http_compression=1" -H 'Accept-Encoding: gzip'          -d 'SELECT number FROM system.numbers LIMIT 0' | wc -c;
 
 # POST multiple concatenated gzip streams.
-(echo -n "SELECT 'Part1" | gzip -c; echo " Part2'" | gzip -c) | curl -sS -H 'Content-Encoding: gzip' 'http://localhost:8123/?' --data-binary @-
+(echo -n "SELECT 'Part1" | gzip -c; echo " Part2'" | gzip -c) | ${CLICKHOUSE_CURL} -sS -H 'Content-Encoding: gzip' "${CLICKHOUSE_URL}?" --data-binary @-

From 89e633d0649c94b160f8b6afe94f67f072b19d4a Mon Sep 17 00:00:00 2001
From: proller <proller@github.com>
Date: Thu, 30 Nov 2017 20:21:03 +0300
Subject: [PATCH 016/107] Fix compile (missing boost libs)

---
 .../boost/archive/archive_exception.hpp       |  100 +
 .../boost/archive/basic_archive.hpp           |  304 +++
 .../boost/archive/basic_binary_iarchive.hpp   |  204 ++
 .../boost/archive/basic_binary_iprimitive.hpp |  198 ++
 .../boost/archive/basic_binary_oarchive.hpp   |  185 ++
 .../boost/archive/basic_binary_oprimitive.hpp |  188 ++
 .../archive/basic_streambuf_locale_saver.hpp  |  108 ++
 .../boost/archive/basic_text_iarchive.hpp     |   96 +
 .../boost/archive/basic_text_iprimitive.hpp   |  142 ++
 .../boost/archive/basic_text_oarchive.hpp     |  119 ++
 .../boost/archive/basic_text_oprimitive.hpp   |  209 ++
 .../boost/archive/basic_xml_archive.hpp       |   67 +
 .../boost/archive/basic_xml_iarchive.hpp      |  119 ++
 .../boost/archive/basic_xml_oarchive.hpp      |  138 ++
 .../boost/archive/binary_iarchive.hpp         |   64 +
 .../boost/archive/binary_iarchive_impl.hpp    |  105 +
 .../boost/archive/binary_oarchive.hpp         |   64 +
 .../boost/archive/binary_oarchive_impl.hpp    |  106 +
 .../boost/archive/binary_wiarchive.hpp        |   56 +
 .../boost/archive/binary_woarchive.hpp        |   59 +
 .../boost/archive/codecvt_null.hpp            |  109 ++
 .../boost/archive/detail/abi_prefix.hpp       |   16 +
 .../boost/archive/detail/abi_suffix.hpp       |   15 +
 .../archive/detail/archive_serializer_map.hpp |   54 +
 .../archive/detail/auto_link_archive.hpp      |   48 +
 .../archive/detail/auto_link_warchive.hpp     |   47 +
 .../boost/archive/detail/basic_iarchive.hpp   |  105 +
 .../archive/detail/basic_iserializer.hpp      |   91 +
 .../boost/archive/detail/basic_oarchive.hpp   |   94 +
 .../archive/detail/basic_oserializer.hpp      |   89 +
 .../detail/basic_pointer_iserializer.hpp      |   70 +
 .../detail/basic_pointer_oserializer.hpp      |   68 +
 .../boost/archive/detail/basic_serializer.hpp |   77 +
 .../archive/detail/basic_serializer_map.hpp   |   69 +
 .../boost/archive/detail/check.hpp            |  169 ++
 .../boost/archive/detail/common_iarchive.hpp  |   88 +
 .../boost/archive/detail/common_oarchive.hpp  |   88 +
 .../boost/archive/detail/decl.hpp             |   57 +
 .../archive/detail/helper_collection.hpp      |   99 +
 .../archive/detail/interface_iarchive.hpp     |   85 +
 .../archive/detail/interface_oarchive.hpp     |   87 +
 .../boost/archive/detail/iserializer.hpp      |  631 ++++++
 .../boost/archive/detail/oserializer.hpp      |  540 ++++++
 .../detail/polymorphic_iarchive_route.hpp     |  218 +++
 .../detail/polymorphic_oarchive_route.hpp     |  209 ++
 .../boost/archive/detail/register_archive.hpp |   91 +
 .../archive/detail/utf8_codecvt_facet.hpp     |   39 +
 .../boost_1_65_0/boost/archive/dinkumware.hpp |  224 +++
 .../archive/impl/archive_serializer_map.ipp   |   75 +
 .../archive/impl/basic_binary_iarchive.ipp    |  134 ++
 .../archive/impl/basic_binary_iprimitive.ipp  |  171 ++
 .../archive/impl/basic_binary_oarchive.ipp    |   42 +
 .../archive/impl/basic_binary_oprimitive.ipp  |  126 ++
 .../archive/impl/basic_text_iarchive.ipp      |   76 +
 .../archive/impl/basic_text_iprimitive.ipp    |  137 ++
 .../archive/impl/basic_text_oarchive.ipp      |   62 +
 .../archive/impl/basic_text_oprimitive.ipp    |  115 ++
 .../boost/archive/impl/basic_xml_grammar.hpp  |  173 ++
 .../boost/archive/impl/basic_xml_iarchive.ipp |  115 ++
 .../boost/archive/impl/basic_xml_oarchive.ipp |  272 +++
 .../boost/archive/impl/text_iarchive_impl.ipp |  128 ++
 .../boost/archive/impl/text_oarchive_impl.ipp |  122 ++
 .../archive/impl/text_wiarchive_impl.ipp      |  118 ++
 .../archive/impl/text_woarchive_impl.ipp      |   85 +
 .../boost/archive/impl/xml_iarchive_impl.ipp  |  199 ++
 .../boost/archive/impl/xml_oarchive_impl.ipp  |  142 ++
 .../boost/archive/impl/xml_wiarchive_impl.ipp |  189 ++
 .../boost/archive/impl/xml_woarchive_impl.ipp |  171 ++
 .../archive/iterators/base64_exception.hpp    |   68 +
 .../archive/iterators/base64_from_binary.hpp  |  109 ++
 .../archive/iterators/binary_from_base64.hpp  |  118 ++
 .../boost/archive/iterators/dataflow.hpp      |  102 +
 .../archive/iterators/dataflow_exception.hpp  |   80 +
 .../boost/archive/iterators/escape.hpp        |  115 ++
 .../archive/iterators/insert_linebreaks.hpp   |   99 +
 .../archive/iterators/istream_iterator.hpp    |   92 +
 .../boost/archive/iterators/mb_from_wchar.hpp |  139 ++
 .../archive/iterators/ostream_iterator.hpp    |   83 +
 .../archive/iterators/remove_whitespace.hpp   |  167 ++
 .../archive/iterators/transform_width.hpp     |  177 ++
 .../boost/archive/iterators/unescape.hpp      |   89 +
 .../boost/archive/iterators/wchar_from_mb.hpp |  194 ++
 .../boost/archive/iterators/xml_escape.hpp    |  121 ++
 .../boost/archive/iterators/xml_unescape.hpp  |  125 ++
 .../iterators/xml_unescape_exception.hpp      |   49 +
 .../archive/polymorphic_binary_iarchive.hpp   |   54 +
 .../archive/polymorphic_binary_oarchive.hpp   |   43 +
 .../boost/archive/polymorphic_iarchive.hpp    |  168 ++
 .../boost/archive/polymorphic_oarchive.hpp    |  154 ++
 .../archive/polymorphic_text_iarchive.hpp     |   54 +
 .../archive/polymorphic_text_oarchive.hpp     |   39 +
 .../archive/polymorphic_text_wiarchive.hpp    |   59 +
 .../archive/polymorphic_text_woarchive.hpp    |   44 +
 .../archive/polymorphic_xml_iarchive.hpp      |   54 +
 .../archive/polymorphic_xml_oarchive.hpp      |   39 +
 .../archive/polymorphic_xml_wiarchive.hpp     |   50 +
 .../archive/polymorphic_xml_woarchive.hpp     |   44 +
 .../boost/archive/text_iarchive.hpp           |  132 ++
 .../boost/archive/text_oarchive.hpp           |  121 ++
 .../boost/archive/text_wiarchive.hpp          |  137 ++
 .../boost/archive/text_woarchive.hpp          |  155 ++
 .../boost_1_65_0/boost/archive/tmpdir.hpp     |   50 +
 .../boost_1_65_0/boost/archive/wcslen.hpp     |   58 +
 .../boost/archive/xml_archive_exception.hpp   |   57 +
 .../boost/archive/xml_iarchive.hpp            |  142 ++
 .../boost/archive/xml_oarchive.hpp            |  137 ++
 .../boost/archive/xml_wiarchive.hpp           |  149 ++
 .../boost/archive/xml_woarchive.hpp           |  134 ++
 .../boost_1_65_0/boost/foreach_fwd.hpp        |   51 +
 .../boost/multi_index/composite_key.hpp       | 1513 +++++++++++++++
 .../multi_index/detail/access_specifier.hpp   |   54 +
 .../boost/multi_index/detail/adl_swap.hpp     |   44 +
 .../detail/archive_constructed.hpp            |   83 +
 .../boost/multi_index/detail/auto_space.hpp   |   91 +
 .../boost/multi_index/detail/base_type.hpp    |   74 +
 .../detail/bidir_node_iterator.hpp            |  114 ++
 .../boost/multi_index/detail/bucket_array.hpp |  243 +++
 .../multi_index/detail/cons_stdtuple.hpp      |   93 +
 .../boost/multi_index/detail/converter.hpp    |   52 +
 .../boost/multi_index/detail/copy_map.hpp     |  142 ++
 .../detail/do_not_copy_elements_tag.hpp       |   34 +
 .../detail/duplicates_iterator.hpp            |  120 ++
 .../boost/multi_index/detail/has_tag.hpp      |   42 +
 .../multi_index/detail/hash_index_args.hpp    |  105 +
 .../detail/hash_index_iterator.hpp            |  166 ++
 .../multi_index/detail/hash_index_node.hpp    |  778 ++++++++
 .../multi_index/detail/header_holder.hpp      |   50 +
 .../detail/ignore_wstrict_aliasing.hpp        |   18 +
 .../boost/multi_index/detail/index_base.hpp   |  293 +++
 .../boost/multi_index/detail/index_loader.hpp |  139 ++
 .../multi_index/detail/index_matcher.hpp      |  249 +++
 .../multi_index/detail/index_node_base.hpp    |  135 ++
 .../boost/multi_index/detail/index_saver.hpp  |  135 ++
 .../multi_index/detail/invariant_assert.hpp   |   21 +
 .../multi_index/detail/is_index_list.hpp      |   40 +
 .../multi_index/detail/is_transparent.hpp     |  135 ++
 .../boost/multi_index/detail/iter_adaptor.hpp |  321 +++
 .../multi_index/detail/modify_key_adaptor.hpp |   49 +
 .../multi_index/detail/no_duplicate_tags.hpp  |   97 +
 .../boost/multi_index/detail/node_type.hpp    |   66 +
 .../multi_index/detail/ord_index_args.hpp     |   83 +
 .../multi_index/detail/ord_index_impl.hpp     | 1567 +++++++++++++++
 .../multi_index/detail/ord_index_impl_fwd.hpp |  128 ++
 .../multi_index/detail/ord_index_node.hpp     |  658 +++++++
 .../multi_index/detail/ord_index_ops.hpp      |  266 +++
 .../boost/multi_index/detail/promotes_arg.hpp |   83 +
 .../boost/multi_index/detail/raw_ptr.hpp      |   52 +
 .../detail/restore_wstrict_aliasing.hpp       |   11 +
 .../multi_index/detail/rnd_index_loader.hpp   |  173 ++
 .../multi_index/detail/rnd_index_node.hpp     |  273 +++
 .../multi_index/detail/rnd_index_ops.hpp      |  203 ++
 .../detail/rnd_index_ptr_array.hpp            |  144 ++
 .../multi_index/detail/rnd_node_iterator.hpp  |  140 ++
 .../multi_index/detail/rnk_index_ops.hpp      |  300 +++
 .../boost/multi_index/detail/safe_mode.hpp    |  588 ++++++
 .../boost/multi_index/detail/scope_guard.hpp  |  453 +++++
 .../multi_index/detail/seq_index_node.hpp     |  217 +++
 .../multi_index/detail/seq_index_ops.hpp      |  203 ++
 .../detail/serialization_version.hpp          |   73 +
 .../boost/multi_index/detail/uintptr_type.hpp |   76 +
 .../boost/multi_index/detail/unbounded.hpp    |   66 +
 .../multi_index/detail/value_compare.hpp      |   56 +
 .../multi_index/detail/vartempl_support.hpp   |  247 +++
 .../boost/multi_index/global_fun.hpp          |  185 ++
 .../boost/multi_index/hashed_index.hpp        | 1725 +++++++++++++++++
 .../boost/multi_index/hashed_index_fwd.hpp    |   74 +
 .../boost/multi_index/identity.hpp            |  145 ++
 .../boost/multi_index/identity_fwd.hpp        |   26 +
 .../boost/multi_index/indexed_by.hpp          |   68 +
 .../boost/multi_index/key_extractors.hpp      |   22 +
 .../boost/multi_index/mem_fun.hpp             |  205 ++
 .../boost_1_65_0/boost/multi_index/member.hpp |  262 +++
 .../boost/multi_index/ordered_index.hpp       |  114 ++
 .../boost/multi_index/ordered_index_fwd.hpp   |   35 +
 .../boost/multi_index/random_access_index.hpp | 1167 +++++++++++
 .../multi_index/random_access_index_fwd.hpp   |   91 +
 .../boost/multi_index/ranked_index.hpp        |  382 ++++
 .../boost/multi_index/ranked_index_fwd.hpp    |   35 +
 .../boost/multi_index/safe_mode_errors.hpp    |   48 +
 .../boost/multi_index/sequenced_index.hpp     | 1062 ++++++++++
 .../boost/multi_index/sequenced_index_fwd.hpp |   91 +
 .../boost_1_65_0/boost/multi_index/tag.hpp    |   88 +
 .../boost/multi_index_container.hpp           | 1362 +++++++++++++
 .../boost/multi_index_container_fwd.hpp       |  121 ++
 .../boost/serialization/access.hpp            |  145 ++
 .../archive_input_unordered_map.hpp           |   85 +
 .../archive_input_unordered_set.hpp           |   72 +
 .../boost/serialization/array.hpp             |   48 +
 .../serialization/array_optimization.hpp      |   37 +
 .../boost/serialization/array_wrapper.hpp     |  121 ++
 .../boost/serialization/assume_abstract.hpp   |   60 +
 .../boost/serialization/base_object.hpp       |  100 +
 .../boost/serialization/binary_object.hpp     |   79 +
 .../boost/serialization/bitset.hpp            |   75 +
 .../boost/serialization/boost_array.hpp       |   33 +
 .../serialization/boost_unordered_map.hpp     |  154 ++
 .../serialization/boost_unordered_set.hpp     |  150 ++
 .../serialization/collection_size_type.hpp    |   62 +
 .../boost/serialization/collection_traits.hpp |   79 +
 .../serialization/collections_load_imp.hpp    |  106 +
 .../serialization/collections_save_imp.hpp    |   82 +
 .../boost/serialization/complex.hpp           |   81 +
 .../boost/serialization/config.hpp            |   74 +
 .../boost/serialization/deque.hpp             |   80 +
 .../detail/is_default_constructible.hpp       |   54 +
 .../serialization/detail/shared_count_132.hpp |  551 ++++++
 .../serialization/detail/shared_ptr_132.hpp   |  443 +++++
 .../detail/shared_ptr_nmt_132.hpp             |  182 ++
 .../detail/stack_constructor.hpp              |   66 +
 .../boost/serialization/ephemeral.hpp         |   72 +
 .../boost/serialization/export.hpp            |  225 +++
 .../serialization/extended_type_info.hpp      |  116 ++
 .../extended_type_info_no_rtti.hpp            |  182 ++
 .../extended_type_info_typeid.hpp             |  167 ++
 .../boost/serialization/factory.hpp           |  102 +
 .../boost/serialization/force_include.hpp     |   55 +
 .../boost/serialization/forward_list.hpp      |  124 ++
 .../hash_collections_load_imp.hpp             |   77 +
 .../hash_collections_save_imp.hpp             |   97 +
 .../boost/serialization/hash_map.hpp          |  232 +++
 .../boost/serialization/hash_set.hpp          |  222 +++
 .../serialization/is_bitwise_serializable.hpp |   46 +
 .../boost/serialization/item_version_type.hpp |   68 +
 .../boost/serialization/level.hpp             |  116 ++
 .../boost/serialization/level_enum.hpp        |   55 +
 .../boost_1_65_0/boost/serialization/list.hpp |   85 +
 .../boost_1_65_0/boost/serialization/map.hpp  |  139 ++
 .../boost_1_65_0/boost/serialization/nvp.hpp  |  123 ++
 .../boost/serialization/optional.hpp          |  107 +
 .../boost/serialization/priority_queue.hpp    |   76 +
 .../boost/serialization/queue.hpp             |   76 +
 .../boost/serialization/scoped_ptr.hpp        |   58 +
 .../boost/serialization/serialization.hpp     |  154 ++
 .../boost_1_65_0/boost/serialization/set.hpp  |  137 ++
 .../boost/serialization/shared_ptr.hpp        |  281 +++
 .../boost/serialization/shared_ptr_132.hpp    |  222 +++
 .../boost/serialization/shared_ptr_helper.hpp |  209 ++
 .../boost/serialization/singleton.hpp         |  166 ++
 .../boost/serialization/slist.hpp             |  145 ++
 .../boost/serialization/smart_cast.hpp        |  275 +++
 .../boost/serialization/split_free.hpp        |   93 +
 .../boost/serialization/split_member.hpp      |   86 +
 .../boost/serialization/stack.hpp             |   76 +
 .../boost/serialization/state_saver.hpp       |   96 +
 .../boost/serialization/static_warning.hpp    |  103 +
 .../boost/serialization/string.hpp            |   30 +
 .../boost/serialization/strong_typedef.hpp    |   50 +
 .../boost/serialization/throw_exception.hpp   |   44 +
 .../boost/serialization/tracking.hpp          |  118 ++
 .../boost/serialization/tracking_enum.hpp     |   41 +
 .../boost/serialization/traits.hpp            |   65 +
 .../type_info_implementation.hpp              |   73 +
 .../boost/serialization/unique_ptr.hpp        |   68 +
 .../unordered_collections_load_imp.hpp        |   73 +
 .../unordered_collections_save_imp.hpp        |   86 +
 .../boost/serialization/unordered_map.hpp     |  160 ++
 .../boost/serialization/unordered_set.hpp     |  162 ++
 .../boost/serialization/utility.hpp           |   56 +
 .../boost/serialization/valarray.hpp          |   86 +
 .../boost/serialization/variant.hpp           |  158 ++
 .../boost/serialization/vector.hpp            |  233 +++
 .../boost/serialization/vector_135.hpp        |   26 +
 .../boost/serialization/version.hpp           |  107 +
 .../boost/serialization/void_cast.hpp         |  298 +++
 .../boost/serialization/void_cast_fwd.hpp     |   37 +
 .../boost/serialization/weak_ptr.hpp          |   99 +
 .../boost/serialization/wrapper.hpp           |   60 +
 267 files changed, 41588 insertions(+)
 create mode 100644 contrib/libboost/boost_1_65_0/boost/archive/archive_exception.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/archive/basic_archive.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/archive/basic_binary_iarchive.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/archive/basic_binary_iprimitive.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/archive/basic_binary_oarchive.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/archive/basic_binary_oprimitive.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/archive/basic_streambuf_locale_saver.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/archive/basic_text_iarchive.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/archive/basic_text_iprimitive.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/archive/basic_text_oarchive.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/archive/basic_text_oprimitive.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/archive/basic_xml_archive.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/archive/basic_xml_iarchive.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/archive/basic_xml_oarchive.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/archive/binary_iarchive.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/archive/binary_iarchive_impl.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/archive/binary_oarchive.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/archive/binary_oarchive_impl.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/archive/binary_wiarchive.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/archive/binary_woarchive.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/archive/codecvt_null.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/archive/detail/abi_prefix.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/archive/detail/abi_suffix.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/archive/detail/archive_serializer_map.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/archive/detail/auto_link_archive.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/archive/detail/auto_link_warchive.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/archive/detail/basic_iarchive.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/archive/detail/basic_iserializer.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/archive/detail/basic_oarchive.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/archive/detail/basic_oserializer.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/archive/detail/basic_pointer_iserializer.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/archive/detail/basic_pointer_oserializer.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/archive/detail/basic_serializer.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/archive/detail/basic_serializer_map.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/archive/detail/check.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/archive/detail/common_iarchive.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/archive/detail/common_oarchive.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/archive/detail/decl.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/archive/detail/helper_collection.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/archive/detail/interface_iarchive.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/archive/detail/interface_oarchive.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/archive/detail/iserializer.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/archive/detail/oserializer.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/archive/detail/polymorphic_iarchive_route.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/archive/detail/polymorphic_oarchive_route.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/archive/detail/register_archive.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/archive/detail/utf8_codecvt_facet.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/archive/dinkumware.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/archive/impl/archive_serializer_map.ipp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/archive/impl/basic_binary_iarchive.ipp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/archive/impl/basic_binary_iprimitive.ipp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/archive/impl/basic_binary_oarchive.ipp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/archive/impl/basic_binary_oprimitive.ipp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/archive/impl/basic_text_iarchive.ipp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/archive/impl/basic_text_iprimitive.ipp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/archive/impl/basic_text_oarchive.ipp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/archive/impl/basic_text_oprimitive.ipp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/archive/impl/basic_xml_grammar.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/archive/impl/basic_xml_iarchive.ipp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/archive/impl/basic_xml_oarchive.ipp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/archive/impl/text_iarchive_impl.ipp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/archive/impl/text_oarchive_impl.ipp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/archive/impl/text_wiarchive_impl.ipp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/archive/impl/text_woarchive_impl.ipp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/archive/impl/xml_iarchive_impl.ipp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/archive/impl/xml_oarchive_impl.ipp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/archive/impl/xml_wiarchive_impl.ipp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/archive/impl/xml_woarchive_impl.ipp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/archive/iterators/base64_exception.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/archive/iterators/base64_from_binary.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/archive/iterators/binary_from_base64.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/archive/iterators/dataflow.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/archive/iterators/dataflow_exception.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/archive/iterators/escape.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/archive/iterators/insert_linebreaks.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/archive/iterators/istream_iterator.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/archive/iterators/mb_from_wchar.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/archive/iterators/ostream_iterator.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/archive/iterators/remove_whitespace.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/archive/iterators/transform_width.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/archive/iterators/unescape.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/archive/iterators/wchar_from_mb.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/archive/iterators/xml_escape.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/archive/iterators/xml_unescape.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/archive/iterators/xml_unescape_exception.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/archive/polymorphic_binary_iarchive.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/archive/polymorphic_binary_oarchive.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/archive/polymorphic_iarchive.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/archive/polymorphic_oarchive.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/archive/polymorphic_text_iarchive.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/archive/polymorphic_text_oarchive.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/archive/polymorphic_text_wiarchive.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/archive/polymorphic_text_woarchive.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/archive/polymorphic_xml_iarchive.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/archive/polymorphic_xml_oarchive.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/archive/polymorphic_xml_wiarchive.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/archive/polymorphic_xml_woarchive.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/archive/text_iarchive.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/archive/text_oarchive.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/archive/text_wiarchive.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/archive/text_woarchive.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/archive/tmpdir.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/archive/wcslen.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/archive/xml_archive_exception.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/archive/xml_iarchive.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/archive/xml_oarchive.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/archive/xml_wiarchive.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/archive/xml_woarchive.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/foreach_fwd.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/composite_key.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/access_specifier.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/adl_swap.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/archive_constructed.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/auto_space.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/base_type.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/bidir_node_iterator.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/bucket_array.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/cons_stdtuple.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/converter.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/copy_map.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/do_not_copy_elements_tag.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/duplicates_iterator.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/has_tag.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/hash_index_args.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/hash_index_iterator.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/hash_index_node.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/header_holder.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/ignore_wstrict_aliasing.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/index_base.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/index_loader.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/index_matcher.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/index_node_base.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/index_saver.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/invariant_assert.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/is_index_list.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/is_transparent.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/iter_adaptor.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/modify_key_adaptor.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/no_duplicate_tags.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/node_type.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/ord_index_args.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/ord_index_impl.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/ord_index_impl_fwd.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/ord_index_node.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/ord_index_ops.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/promotes_arg.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/raw_ptr.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/restore_wstrict_aliasing.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/rnd_index_loader.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/rnd_index_node.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/rnd_index_ops.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/rnd_index_ptr_array.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/rnd_node_iterator.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/rnk_index_ops.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/safe_mode.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/scope_guard.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/seq_index_node.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/seq_index_ops.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/serialization_version.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/uintptr_type.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/unbounded.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/value_compare.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/vartempl_support.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/global_fun.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/hashed_index.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/hashed_index_fwd.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/identity.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/identity_fwd.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/indexed_by.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/key_extractors.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/mem_fun.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/member.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/ordered_index.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/ordered_index_fwd.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/random_access_index.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/random_access_index_fwd.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/ranked_index.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/ranked_index_fwd.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/safe_mode_errors.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/sequenced_index.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/sequenced_index_fwd.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/tag.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index_container.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index_container_fwd.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/access.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/archive_input_unordered_map.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/archive_input_unordered_set.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/array.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/array_optimization.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/array_wrapper.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/assume_abstract.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/base_object.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/binary_object.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/bitset.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/boost_array.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/boost_unordered_map.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/boost_unordered_set.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/collection_size_type.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/collection_traits.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/collections_load_imp.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/collections_save_imp.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/complex.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/config.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/deque.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/detail/is_default_constructible.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/detail/shared_count_132.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/detail/shared_ptr_132.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/detail/shared_ptr_nmt_132.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/detail/stack_constructor.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/ephemeral.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/export.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/extended_type_info.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/extended_type_info_no_rtti.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/extended_type_info_typeid.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/factory.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/force_include.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/forward_list.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/hash_collections_load_imp.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/hash_collections_save_imp.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/hash_map.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/hash_set.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/is_bitwise_serializable.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/item_version_type.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/level.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/level_enum.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/list.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/map.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/nvp.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/optional.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/priority_queue.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/queue.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/scoped_ptr.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/serialization.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/set.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/shared_ptr.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/shared_ptr_132.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/shared_ptr_helper.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/singleton.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/slist.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/smart_cast.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/split_free.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/split_member.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/stack.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/state_saver.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/static_warning.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/string.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/strong_typedef.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/throw_exception.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/tracking.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/tracking_enum.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/traits.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/type_info_implementation.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/unique_ptr.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/unordered_collections_load_imp.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/unordered_collections_save_imp.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/unordered_map.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/unordered_set.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/utility.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/valarray.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/variant.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/vector.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/vector_135.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/version.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/void_cast.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/void_cast_fwd.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/weak_ptr.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/wrapper.hpp

diff --git a/contrib/libboost/boost_1_65_0/boost/archive/archive_exception.hpp b/contrib/libboost/boost_1_65_0/boost/archive/archive_exception.hpp
new file mode 100644
index 00000000000..fabcdb5fa71
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/archive/archive_exception.hpp
@@ -0,0 +1,100 @@
+#ifndef BOOST_ARCHIVE_ARCHIVE_EXCEPTION_HPP
+#define BOOST_ARCHIVE_ARCHIVE_EXCEPTION_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// archive/archive_exception.hpp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+#include <exception>
+#include <boost/assert.hpp>
+#include <string>
+
+#include <boost/config.hpp> 
+#include <boost/archive/detail/decl.hpp>
+
+// note: the only reason this is in here is that windows header
+// includes #define exception_code _exception_code (arrrgghhhh!).
+// the most expedient way to address this is be sure that this
+// header is always included whenever this header file is included.
+#if defined(BOOST_WINDOWS) 
+#include <excpt.h> 
+#endif 
+
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+namespace boost {
+namespace archive {
+
+//////////////////////////////////////////////////////////////////////
+// exceptions thrown by archives
+//
+class BOOST_SYMBOL_VISIBLE archive_exception : 
+    public virtual std::exception
+{
+private:
+    char m_buffer[128];
+protected:
+    BOOST_ARCHIVE_DECL unsigned int
+    append(unsigned int l, const char * a);
+    BOOST_ARCHIVE_DECL
+    archive_exception() BOOST_NOEXCEPT;
+public:
+    typedef enum {
+        no_exception,       // initialized without code
+        other_exception,    // any excepton not listed below
+        unregistered_class, // attempt to serialize a pointer of
+                            // an unregistered class
+        invalid_signature,  // first line of archive does not contain
+                            // expected string
+        unsupported_version,// archive created with library version
+                            // subsequent to this one
+        pointer_conflict,   // an attempt has been made to directly
+                            // serialize an object which has
+                            // already been serialized through a pointer.  
+                            // Were this permitted, the archive load would result 
+                            // in the creation of an extra copy of the obect.
+        incompatible_native_format, // attempt to read native binary format
+                            // on incompatible platform
+        array_size_too_short,// array being loaded doesn't fit in array allocated
+        input_stream_error, // error on input stream
+        invalid_class_name, // class name greater than the maximum permitted.
+                            // most likely a corrupted archive or an attempt
+                            // to insert virus via buffer overrun method.
+        unregistered_cast,   // base - derived relationship not registered with 
+                            // void_cast_register
+        unsupported_class_version, // type saved with a version # greater than the 
+                            // one used by the program.  This indicates that the program
+                            // needs to be rebuilt.
+        multiple_code_instantiation, // code for implementing serialization for some
+                            // type has been instantiated in more than one module.
+        output_stream_error // error on input stream
+    } exception_code;
+    exception_code code;
+
+    BOOST_ARCHIVE_DECL archive_exception(
+        exception_code c, 
+        const char * e1 = NULL,
+        const char * e2 = NULL
+    ) BOOST_NOEXCEPT;
+    BOOST_ARCHIVE_DECL archive_exception(archive_exception const &) BOOST_NOEXCEPT ;
+    virtual BOOST_ARCHIVE_DECL ~archive_exception() BOOST_NOEXCEPT_OR_NOTHROW ;
+    virtual BOOST_ARCHIVE_DECL const char * what() const BOOST_NOEXCEPT_OR_NOTHROW ;
+};
+
+}// namespace archive
+}// namespace boost
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#endif //BOOST_ARCHIVE_ARCHIVE_EXCEPTION_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/basic_archive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/basic_archive.hpp
new file mode 100644
index 00000000000..ce7ac99a6dd
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/archive/basic_archive.hpp
@@ -0,0 +1,304 @@
+#ifndef BOOST_ARCHIVE_BASIC_ARCHIVE_HPP
+#define BOOST_ARCHIVE_BASIC_ARCHIVE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// basic_archive.hpp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+#include <cstring> // count
+#include <boost/assert.hpp>
+#include <boost/config.hpp>
+#include <boost/cstdint.hpp> // size_t
+#include <boost/noncopyable.hpp>
+#include <boost/integer_traits.hpp>
+
+#include <boost/archive/detail/auto_link_archive.hpp>
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+namespace boost {
+namespace archive {
+
+#if defined(_MSC_VER)
+#pragma warning( push )
+#pragma warning( disable : 4244 4267 )
+#endif
+
+/* NOTE : Warning  : Warning : Warning : Warning : Warning
+ * Don't ever changes this.  If you do, they previously created
+ * binary archives won't be readable !!!
+ */
+class library_version_type {
+private:
+    typedef uint_least16_t base_type;
+    base_type t;
+public:
+    library_version_type(): t(0) {};
+    explicit library_version_type(const unsigned int & t_) : t(t_){
+        BOOST_ASSERT(t_ <= boost::integer_traits<base_type>::const_max);
+    }
+    library_version_type(const library_version_type & t_) : 
+        t(t_.t)
+    {}
+    library_version_type & operator=(const library_version_type & rhs){
+        t = rhs.t; 
+        return *this;
+    }
+    // used for text output
+    operator base_type () const {
+        return t;
+    }                
+    // used for text input
+    operator base_type & (){
+        return t;
+    }                
+    bool operator==(const library_version_type & rhs) const {
+        return t == rhs.t;
+    } 
+    bool operator<(const library_version_type & rhs) const {
+        return t < rhs.t;
+    }   
+};
+
+BOOST_ARCHIVE_DECL library_version_type
+BOOST_ARCHIVE_VERSION();
+
+class version_type {
+private:
+    typedef uint_least32_t base_type;
+    base_type t;
+public:
+    // should be private - but MPI fails if it's not!!!
+    version_type(): t(0) {};
+    explicit version_type(const unsigned int & t_) : t(t_){
+        BOOST_ASSERT(t_ <= boost::integer_traits<base_type>::const_max);
+    }
+    version_type(const version_type & t_) : 
+        t(t_.t)
+    {}
+    version_type & operator=(const version_type & rhs){
+        t = rhs.t; 
+        return *this;
+    }
+    // used for text output
+    operator base_type () const {
+        return t;
+    }                
+    // used for text intput
+    operator base_type  & (){
+        return t;
+    }                
+    bool operator==(const version_type & rhs) const {
+        return t == rhs.t;
+    } 
+    bool operator<(const version_type & rhs) const {
+        return t < rhs.t;
+    }   
+};
+
+class class_id_type {
+private:
+    typedef int_least16_t base_type;
+    base_type t;
+public:
+    // should be private - but then can't use BOOST_STRONG_TYPE below
+    class_id_type() : t(0) {};
+    explicit class_id_type(const int t_) : t(t_){
+        BOOST_ASSERT(t_ <= boost::integer_traits<base_type>::const_max);
+    }
+    explicit class_id_type(const std::size_t t_) : t(t_){
+ //       BOOST_ASSERT(t_ <= boost::integer_traits<base_type>::const_max);
+    }
+    class_id_type(const class_id_type & t_) : 
+        t(t_.t)
+    {}
+    class_id_type & operator=(const class_id_type & rhs){
+        t = rhs.t; 
+        return *this;
+    }
+
+    // used for text output
+    operator int () const {
+        return t;
+    }                
+    // used for text input
+    operator int_least16_t &() {
+        return t;
+    }                
+    bool operator==(const class_id_type & rhs) const {
+        return t == rhs.t;
+    } 
+    bool operator<(const class_id_type & rhs) const {
+        return t < rhs.t;
+    }   
+};
+
+#define NULL_POINTER_TAG boost::archive::class_id_type(-1)
+
+class object_id_type {
+private:
+    typedef uint_least32_t base_type;
+    base_type t;
+public:
+    object_id_type(): t(0) {};
+    // note: presumes that size_t >= unsigned int.
+    explicit object_id_type(const std::size_t & t_) : t(t_){
+        BOOST_ASSERT(t_ <= boost::integer_traits<base_type>::const_max);
+    }
+    object_id_type(const object_id_type & t_) : 
+        t(t_.t)
+    {}
+    object_id_type & operator=(const object_id_type & rhs){
+        t = rhs.t; 
+        return *this;
+    }
+    // used for text output
+    operator uint_least32_t () const {
+        return t;
+    }                
+    // used for text input
+    operator uint_least32_t & () {
+        return t;
+    }                
+    bool operator==(const object_id_type & rhs) const {
+        return t == rhs.t;
+    } 
+    bool operator<(const object_id_type & rhs) const {
+        return t < rhs.t;
+    }   
+};
+
+#if defined(_MSC_VER)
+#pragma warning( pop )
+#endif
+
+struct tracking_type {
+    bool t;
+    explicit tracking_type(const bool t_ = false)
+        : t(t_)
+    {};
+    tracking_type(const tracking_type & t_)
+        : t(t_.t)
+    {}
+    operator bool () const {
+        return t;
+    };
+    operator bool & () {
+        return t;
+    };
+    tracking_type & operator=(const bool t_){
+        t = t_;
+        return *this;
+    }
+    bool operator==(const tracking_type & rhs) const {
+        return t == rhs.t;
+    }
+    bool operator==(const bool & rhs) const {
+        return t == rhs;
+    }
+    tracking_type & operator=(const tracking_type & rhs){
+        t = rhs.t;
+        return *this;
+    }
+};
+
+struct class_name_type : 
+    private boost::noncopyable 
+{
+    char *t;
+    operator const char * & () const {
+        return const_cast<const char * &>(t);
+    }
+    operator char * () {
+        return t;
+    }
+    std::size_t size() const {
+        return std::strlen(t);
+    }
+    explicit class_name_type(const char *key_) 
+    : t(const_cast<char *>(key_)){}
+    explicit class_name_type(char *key_) 
+    : t(key_){}
+    class_name_type & operator=(const class_name_type & rhs){
+        t = rhs.t;
+        return *this;
+    }
+};
+
+enum archive_flags {
+    no_header = 1,  // suppress archive header info
+    no_codecvt = 2,  // suppress alteration of codecvt facet
+    no_xml_tag_checking = 4,   // suppress checking of xml tags
+    no_tracking = 8,           // suppress ALL tracking
+    flags_last = 8
+};
+
+BOOST_ARCHIVE_DECL const char *
+BOOST_ARCHIVE_SIGNATURE();
+
+/* NOTE : Warning  : Warning : Warning : Warning : Warning
+ * If any of these are changed to different sized types, 
+ * binary_iarchive won't be able to read older archives
+ * unless you rev the library version and include conditional
+ * code based on the library version.  There is nothing
+ * inherently wrong in doing this - but you have to be super
+ * careful because it's easy to get wrong and start breaking
+ * old archives !!!
+ */
+
+#define BOOST_ARCHIVE_STRONG_TYPEDEF(T, D)         \
+    class D : public T {                           \
+    public:                                        \
+        explicit D(const T tt) : T(tt){}           \
+    };                                             \
+/**/
+
+BOOST_ARCHIVE_STRONG_TYPEDEF(class_id_type, class_id_reference_type)
+BOOST_ARCHIVE_STRONG_TYPEDEF(class_id_type, class_id_optional_type)
+BOOST_ARCHIVE_STRONG_TYPEDEF(object_id_type, object_reference_type)
+
+}// namespace archive
+}// namespace boost
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#include <boost/serialization/level.hpp>
+
+// set implementation level to primitive for all types
+// used internally by the serialization library
+
+BOOST_CLASS_IMPLEMENTATION(boost::archive::library_version_type, primitive_type)
+BOOST_CLASS_IMPLEMENTATION(boost::archive::version_type, primitive_type)
+BOOST_CLASS_IMPLEMENTATION(boost::archive::class_id_type, primitive_type)
+BOOST_CLASS_IMPLEMENTATION(boost::archive::class_id_reference_type, primitive_type)
+BOOST_CLASS_IMPLEMENTATION(boost::archive::class_id_optional_type, primitive_type)
+BOOST_CLASS_IMPLEMENTATION(boost::archive::class_name_type, primitive_type)
+BOOST_CLASS_IMPLEMENTATION(boost::archive::object_id_type, primitive_type)
+BOOST_CLASS_IMPLEMENTATION(boost::archive::object_reference_type, primitive_type)
+BOOST_CLASS_IMPLEMENTATION(boost::archive::tracking_type, primitive_type)
+
+#include <boost/serialization/is_bitwise_serializable.hpp>
+
+// set types used internally by the serialization library 
+// to be bitwise serializable
+
+BOOST_IS_BITWISE_SERIALIZABLE(boost::archive::library_version_type)
+BOOST_IS_BITWISE_SERIALIZABLE(boost::archive::version_type)
+BOOST_IS_BITWISE_SERIALIZABLE(boost::archive::class_id_type)
+BOOST_IS_BITWISE_SERIALIZABLE(boost::archive::class_id_reference_type)
+BOOST_IS_BITWISE_SERIALIZABLE(boost::archive::class_id_optional_type)
+BOOST_IS_BITWISE_SERIALIZABLE(boost::archive::class_name_type)
+BOOST_IS_BITWISE_SERIALIZABLE(boost::archive::object_id_type)
+BOOST_IS_BITWISE_SERIALIZABLE(boost::archive::object_reference_type)
+BOOST_IS_BITWISE_SERIALIZABLE(boost::archive::tracking_type)
+
+#endif //BOOST_ARCHIVE_BASIC_ARCHIVE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/basic_binary_iarchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/basic_binary_iarchive.hpp
new file mode 100644
index 00000000000..c0cc655c997
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/archive/basic_binary_iarchive.hpp
@@ -0,0 +1,204 @@
+#ifndef BOOST_ARCHIVE_BASIC_BINARY_IARCHIVE_HPP
+#define BOOST_ARCHIVE_BASIC_BINARY_IARCHIVE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// basic_binary_iarchive.hpp
+//
+// archives stored as native binary - this should be the fastest way
+// to archive the state of a group of obects.  It makes no attempt to
+// convert to any canonical form.
+
+// IN GENERAL, ARCHIVES CREATED WITH THIS CLASS WILL NOT BE READABLE
+// ON PLATFORM APART FROM THE ONE THEY ARE CREATED ON
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+#include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
+
+#include <boost/archive/basic_archive.hpp>
+#include <boost/archive/detail/common_iarchive.hpp>
+#include <boost/serialization/collection_size_type.hpp>
+#include <boost/serialization/string.hpp>
+#include <boost/serialization/item_version_type.hpp>
+#include <boost/integer_traits.hpp>
+
+#ifdef BOOST_MSVC
+#  pragma warning(push)
+#  pragma warning(disable : 4511 4512)
+#endif
+
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+namespace boost { 
+namespace archive {
+
+namespace detail {
+    template<class Archive> class interface_iarchive;
+} // namespace detail
+
+/////////////////////////////////////////////////////////////////////////
+// class basic_binary_iarchive - read serialized objects from a input binary stream
+template<class Archive>
+class BOOST_SYMBOL_VISIBLE basic_binary_iarchive : 
+    public detail::common_iarchive<Archive>
+{
+#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
+public:
+#else
+protected:
+    #if BOOST_WORKAROUND(BOOST_MSVC, < 1500)
+        // for some inexplicable reason insertion of "class" generates compile erro
+        // on msvc 7.1
+        friend detail::interface_iarchive<Archive>;
+    #else
+        friend class detail::interface_iarchive<Archive>;
+    #endif
+#endif
+    // intermediate level to support override of operators
+    // fot templates in the absence of partial function 
+    // template ordering. If we get here pass to base class
+    // note extra nonsense to sneak it pass the borland compiers
+    typedef detail::common_iarchive<Archive> detail_common_iarchive;
+    template<class T>
+    void load_override(T & t){
+      this->detail_common_iarchive::load_override(t);
+    }
+
+    // include these to trap a change in binary format which
+    // isn't specifically handled
+    // upto 32K classes
+    BOOST_STATIC_ASSERT(sizeof(class_id_type) == sizeof(int_least16_t));
+    BOOST_STATIC_ASSERT(sizeof(class_id_reference_type) == sizeof(int_least16_t));
+    // upto 2G objects
+    BOOST_STATIC_ASSERT(sizeof(object_id_type) == sizeof(uint_least32_t));
+    BOOST_STATIC_ASSERT(sizeof(object_reference_type) == sizeof(uint_least32_t));
+
+    // binary files don't include the optional information 
+    void load_override(class_id_optional_type & /* t */){}
+
+    void load_override(tracking_type & t, int /*version*/){
+        library_version_type lvt = this->get_library_version();
+        if(boost::archive::library_version_type(6) < lvt){
+            int_least8_t x=0;
+            * this->This() >> x;
+            t = boost::archive::tracking_type(x);
+        }
+        else{
+            bool x=0;
+            * this->This() >> x;
+            t = boost::archive::tracking_type(x);
+        }
+    }
+    void load_override(class_id_type & t){
+        library_version_type lvt = this->get_library_version();
+        if(boost::archive::library_version_type(7) < lvt){
+            this->detail_common_iarchive::load_override(t);
+        }
+        else
+        if(boost::archive::library_version_type(6) < lvt){
+            int_least16_t x=0;
+            * this->This() >> x;
+            t = boost::archive::class_id_type(x);
+        }
+        else{
+            int x=0;
+            * this->This() >> x;
+            t = boost::archive::class_id_type(x);
+        }
+    }
+    void load_override(class_id_reference_type & t){
+        load_override(static_cast<class_id_type &>(t));
+    }
+
+    void load_override(version_type & t){
+        library_version_type lvt = this->get_library_version();
+        if(boost::archive::library_version_type(7) < lvt){
+            this->detail_common_iarchive::load_override(t);
+        }
+        else
+        if(boost::archive::library_version_type(6) < lvt){
+            uint_least8_t x=0;
+            * this->This() >> x;
+            t = boost::archive::version_type(x);
+        }
+        else
+        if(boost::archive::library_version_type(5) < lvt){
+            uint_least16_t x=0;
+            * this->This() >> x;
+            t = boost::archive::version_type(x);
+        }
+        else
+        if(boost::archive::library_version_type(2) < lvt){
+            // upto 255 versions
+            unsigned char x=0;
+            * this->This() >> x;
+            t = version_type(x);
+        }
+        else{
+            unsigned int x=0;
+            * this->This() >> x;
+            t = boost::archive::version_type(x);
+        }
+    }
+
+    void load_override(boost::serialization::item_version_type & t){
+        library_version_type lvt = this->get_library_version();
+//        if(boost::archive::library_version_type(7) < lvt){
+        if(boost::archive::library_version_type(6) < lvt){
+            this->detail_common_iarchive::load_override(t);
+        }
+        else
+        if(boost::archive::library_version_type(6) < lvt){
+            uint_least16_t x=0;
+            * this->This() >> x;
+            t = boost::serialization::item_version_type(x);
+        }
+        else{
+            unsigned int x=0;
+            * this->This() >> x;
+            t = boost::serialization::item_version_type(x);
+        }
+    }
+
+    void load_override(serialization::collection_size_type & t){
+        if(boost::archive::library_version_type(5) < this->get_library_version()){
+            this->detail_common_iarchive::load_override(t);
+        }
+        else{
+            unsigned int x=0;
+            * this->This() >> x;
+            t = serialization::collection_size_type(x);
+        } 
+    }
+
+    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+    load_override(class_name_type & t);
+    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+    init();
+   
+    basic_binary_iarchive(unsigned int flags) :
+        detail::common_iarchive<Archive>(flags)
+    {}
+};
+
+} // namespace archive
+} // namespace boost
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#endif // BOOST_ARCHIVE_BASIC_BINARY_IARCHIVE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/basic_binary_iprimitive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/basic_binary_iprimitive.hpp
new file mode 100644
index 00000000000..665d3e81e1f
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/archive/basic_binary_iprimitive.hpp
@@ -0,0 +1,198 @@
+#ifndef BOOST_ARCHIVE_BINARY_IPRIMITIVE_HPP
+#define BOOST_ARCHIVE_BINARY_IPRIMITIVE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+#if defined(_MSC_VER)
+#pragma warning( disable : 4800 )
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// basic_binary_iprimitive.hpp
+//
+// archives stored as native binary - this should be the fastest way
+// to archive the state of a group of obects.  It makes no attempt to
+// convert to any canonical form.
+
+// IN GENERAL, ARCHIVES CREATED WITH THIS CLASS WILL NOT BE READABLE
+// ON PLATFORM APART FROM THE ONE THEY ARE CREATED ON
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+#include <iosfwd>
+#include <boost/assert.hpp>
+#include <locale>
+#include <cstring> // std::memcpy
+#include <cstddef> // std::size_t
+#include <streambuf> // basic_streambuf
+#include <string>
+
+#include <boost/config.hpp>
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{ 
+    using ::memcpy; 
+    using ::size_t;
+} // namespace std
+#endif
+
+#include <boost/cstdint.hpp>
+#include <boost/serialization/throw_exception.hpp>
+#include <boost/integer.hpp>
+#include <boost/integer_traits.hpp>
+
+//#include <boost/mpl/placeholders.hpp>
+#include <boost/serialization/is_bitwise_serializable.hpp>
+#include <boost/serialization/array_wrapper.hpp>
+
+#include <boost/archive/basic_streambuf_locale_saver.hpp>
+#include <boost/archive/codecvt_null.hpp>
+#include <boost/archive/archive_exception.hpp>
+#include <boost/archive/detail/auto_link_archive.hpp>
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+namespace boost { 
+namespace archive {
+
+/////////////////////////////////////////////////////////////////////////////
+// class binary_iarchive - read serialized objects from a input binary stream
+template<class Archive, class Elem, class Tr>
+class BOOST_SYMBOL_VISIBLE basic_binary_iprimitive {
+#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
+    friend class load_access;
+protected:
+#else
+public:
+#endif
+    std::basic_streambuf<Elem, Tr> & m_sb;
+    // return a pointer to the most derived class
+    Archive * This(){
+        return static_cast<Archive *>(this);
+    }
+
+    #ifndef BOOST_NO_STD_LOCALE
+    // note order! - if you change this, libstd++ will fail!
+    // a) create new locale with new codecvt facet
+    // b) save current locale
+    // c) change locale to new one
+    // d) use stream buffer
+    // e) change locale back to original
+    // f) destroy new codecvt facet
+    boost::archive::codecvt_null<Elem> codecvt_null_facet;
+    basic_streambuf_locale_saver<Elem, Tr> locale_saver;
+    std::locale archive_locale;
+    #endif
+
+    // main template for serilization of primitive types
+    template<class T>
+    void load(T & t){
+        load_binary(& t, sizeof(T));
+    }
+
+    /////////////////////////////////////////////////////////
+    // fundamental types that need special treatment
+    
+    // trap usage of invalid uninitialized boolean 
+    void load(bool & t){
+        load_binary(& t, sizeof(t));
+        int i = t;
+        BOOST_ASSERT(0 == i || 1 == i);
+        (void)i; // warning suppression for release builds.
+    }
+    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+    load(std::string &s);
+    #ifndef BOOST_NO_STD_WSTRING
+    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+    load(std::wstring &ws);
+    #endif
+    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+    load(char * t);
+    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+    load(wchar_t * t);
+
+    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+    init();
+    BOOST_ARCHIVE_OR_WARCHIVE_DECL 
+    basic_binary_iprimitive(
+        std::basic_streambuf<Elem, Tr> & sb, 
+        bool no_codecvt
+    );
+    BOOST_ARCHIVE_OR_WARCHIVE_DECL 
+    ~basic_binary_iprimitive();
+public:
+    // we provide an optimized load for all fundamental types
+    // typedef serialization::is_bitwise_serializable<mpl::_1> 
+    // use_array_optimization;
+    struct use_array_optimization {  
+        template <class T>  
+        #if defined(BOOST_NO_DEPENDENT_NESTED_DERIVATIONS)  
+            struct apply {  
+                typedef typename boost::serialization::is_bitwise_serializable< T >::type type;  
+            };
+        #else
+            struct apply : public boost::serialization::is_bitwise_serializable< T > {};  
+        #endif
+    };
+
+    // the optimized load_array dispatches to load_binary 
+    template <class ValueType>
+    void load_array(serialization::array_wrapper<ValueType>& a, unsigned int)
+    {
+      load_binary(a.address(),a.count()*sizeof(ValueType));
+    }
+
+    void
+    load_binary(void *address, std::size_t count);
+};
+
+template<class Archive, class Elem, class Tr>
+inline void
+basic_binary_iprimitive<Archive, Elem, Tr>::load_binary(
+    void *address, 
+    std::size_t count
+){
+    // note: an optimizer should eliminate the following for char files
+    BOOST_ASSERT(
+        static_cast<std::streamsize>(count / sizeof(Elem)) 
+        <= boost::integer_traits<std::streamsize>::const_max
+    );
+    std::streamsize s = static_cast<std::streamsize>(count / sizeof(Elem));
+    std::streamsize scount = m_sb.sgetn(
+        static_cast<Elem *>(address), 
+        s
+    );
+    if(scount != s)
+        boost::serialization::throw_exception(
+            archive_exception(archive_exception::input_stream_error)
+        );
+    // note: an optimizer should eliminate the following for char files
+    BOOST_ASSERT(count % sizeof(Elem) <= boost::integer_traits<std::streamsize>::const_max);
+    s = static_cast<std::streamsize>(count % sizeof(Elem));
+    if(0 < s){
+//        if(is.fail())
+//            boost::serialization::throw_exception(
+//                archive_exception(archive_exception::stream_error)
+//        );
+        Elem t;
+        scount = m_sb.sgetn(& t, 1);
+        if(scount != 1)
+            boost::serialization::throw_exception(
+                archive_exception(archive_exception::input_stream_error)
+            );
+        std::memcpy(static_cast<char*>(address) + (count - s), &t, static_cast<std::size_t>(s));
+    }
+}
+
+} // namespace archive
+} // namespace boost
+
+#include <boost/archive/detail/abi_suffix.hpp> // pop pragmas
+
+#endif // BOOST_ARCHIVE_BINARY_IPRIMITIVE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/basic_binary_oarchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/basic_binary_oarchive.hpp
new file mode 100644
index 00000000000..f05f2f86d55
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/archive/basic_binary_oarchive.hpp
@@ -0,0 +1,185 @@
+#ifndef BOOST_ARCHIVE_BASIC_BINARY_OARCHIVE_HPP
+#define BOOST_ARCHIVE_BASIC_BINARY_OARCHIVE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// basic_binary_oarchive.hpp
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+// archives stored as native binary - this should be the fastest way
+// to archive the state of a group of obects.  It makes no attempt to
+// convert to any canonical form.
+
+// IN GENERAL, ARCHIVES CREATED WITH THIS CLASS WILL NOT BE READABLE
+// ON PLATFORM APART FROM THE ONE THEY ARE CREATE ON
+
+#include <boost/assert.hpp>
+#include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
+
+#include <boost/integer.hpp>
+#include <boost/integer_traits.hpp>
+
+#include <boost/archive/detail/common_oarchive.hpp>
+#include <boost/serialization/string.hpp>
+#include <boost/serialization/collection_size_type.hpp>
+#include <boost/serialization/item_version_type.hpp>
+
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+#ifdef BOOST_MSVC
+#  pragma warning(push)
+#  pragma warning(disable : 4511 4512)
+#endif
+
+namespace boost {
+namespace archive {
+
+namespace detail {
+    template<class Archive> class interface_oarchive;
+} // namespace detail
+
+//////////////////////////////////////////////////////////////////////
+// class basic_binary_oarchive - write serialized objects to a binary output stream
+// note: this archive has no pretensions to portability.  Archive format
+// may vary across machine architectures and compilers.  About the only
+// guarentee is that an archive created with this code will be readable
+// by a program built with the same tools for the same machne.  This class
+// does have the virtue of buiding the smalles archive in the minimum amount
+// of time.  So under some circumstances it may be he right choice.
+template<class Archive>
+class BOOST_SYMBOL_VISIBLE basic_binary_oarchive : 
+    public detail::common_oarchive<Archive>
+{
+#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
+public:
+#else
+protected:
+    #if BOOST_WORKAROUND(BOOST_MSVC, < 1500)
+        // for some inexplicable reason insertion of "class" generates compile erro
+        // on msvc 7.1
+        friend detail::interface_oarchive<Archive>;
+    #else
+        friend class detail::interface_oarchive<Archive>;
+    #endif
+#endif
+    // any datatype not specifed below will be handled by base class
+    typedef detail::common_oarchive<Archive> detail_common_oarchive;
+    template<class T>
+    void save_override(const T & t){
+      this->detail_common_oarchive::save_override(t);
+    }
+
+    // include these to trap a change in binary format which
+    // isn't specifically handled
+    BOOST_STATIC_ASSERT(sizeof(tracking_type) == sizeof(bool));
+    // upto 32K classes
+    BOOST_STATIC_ASSERT(sizeof(class_id_type) == sizeof(int_least16_t));
+    BOOST_STATIC_ASSERT(sizeof(class_id_reference_type) == sizeof(int_least16_t));
+    // upto 2G objects
+    BOOST_STATIC_ASSERT(sizeof(object_id_type) == sizeof(uint_least32_t));
+    BOOST_STATIC_ASSERT(sizeof(object_reference_type) == sizeof(uint_least32_t));
+
+    // binary files don't include the optional information 
+    void save_override(const class_id_optional_type & /* t */){}
+
+    // enable this if we decide to support generation of previous versions
+    #if 0
+    void save_override(const boost::archive::version_type & t){
+        library_version_type lvt = this->get_library_version();
+        if(boost::archive::library_version_type(7) < lvt){
+            this->detail_common_oarchive::save_override(t);
+        }
+        else
+        if(boost::archive::library_version_type(6) < lvt){
+            const boost::uint_least16_t x = t;
+            * this->This() << x;
+        }
+        else{
+            const unsigned int x = t;
+            * this->This() << x;
+        }
+    }
+    void save_override(const boost::serialization::item_version_type & t){
+        library_version_type lvt = this->get_library_version();
+        if(boost::archive::library_version_type(7) < lvt){
+            this->detail_common_oarchive::save_override(t);
+        }
+        else
+        if(boost::archive::library_version_type(6) < lvt){
+            const boost::uint_least16_t x = t;
+            * this->This() << x;
+        }
+        else{
+            const unsigned int x = t;
+            * this->This() << x;
+        }
+    }
+
+    void save_override(class_id_type & t){
+        library_version_type lvt = this->get_library_version();
+        if(boost::archive::library_version_type(7) < lvt){
+            this->detail_common_oarchive::save_override(t);
+        }
+        else
+        if(boost::archive::library_version_type(6) < lvt){
+            const boost::int_least16_t x = t;
+            * this->This() << x;
+        }
+        else{
+            const int x = t;
+            * this->This() << x;
+        }
+    }
+    void save_override(class_id_reference_type & t){
+        save_override(static_cast<class_id_type &>(t));
+    }
+
+    #endif
+
+    // explicitly convert to char * to avoid compile ambiguities
+    void save_override(const class_name_type & t){
+        const std::string s(t);
+        * this->This() << s;
+    }
+
+    #if 0
+    void save_override(const serialization::collection_size_type & t){
+        if (get_library_version() < boost::archive::library_version_type(6)){
+            unsigned int x=0;
+            * this->This() >> x;
+            t = serialization::collection_size_type(x);
+        } 
+        else{
+            * this->This() >> t;
+        }
+    }
+    #endif
+    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+    init();
+
+    basic_binary_oarchive(unsigned int flags) :
+        detail::common_oarchive<Archive>(flags)
+    {}
+};
+
+} // namespace archive
+} // namespace boost
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#endif // BOOST_ARCHIVE_BASIC_BINARY_OARCHIVE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/basic_binary_oprimitive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/basic_binary_oprimitive.hpp
new file mode 100644
index 00000000000..6dc770c60e8
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/archive/basic_binary_oprimitive.hpp
@@ -0,0 +1,188 @@
+#ifndef BOOST_ARCHIVE_BASIC_BINARY_OPRIMITIVE_HPP
+#define BOOST_ARCHIVE_BASIC_BINARY_OPRIMITIVE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// basic_binary_oprimitive.hpp
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+// archives stored as native binary - this should be the fastest way
+// to archive the state of a group of obects.  It makes no attempt to
+// convert to any canonical form.
+
+// IN GENERAL, ARCHIVES CREATED WITH THIS CLASS WILL NOT BE READABLE
+// ON PLATFORM APART FROM THE ONE THEY ARE CREATE ON
+
+#include <iosfwd>
+#include <boost/assert.hpp>
+#include <locale>
+#include <streambuf> // basic_streambuf
+#include <string>
+#include <cstddef> // size_t
+
+#include <boost/config.hpp>
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{ 
+    using ::size_t; 
+} // namespace std
+#endif
+
+#include <boost/cstdint.hpp>
+#include <boost/integer.hpp>
+#include <boost/integer_traits.hpp>
+#include <boost/scoped_ptr.hpp>
+#include <boost/serialization/throw_exception.hpp>
+
+//#include <boost/mpl/placeholders.hpp>
+#include <boost/serialization/is_bitwise_serializable.hpp>
+#include <boost/serialization/array_wrapper.hpp>
+
+#include <boost/archive/basic_streambuf_locale_saver.hpp>
+#include <boost/archive/codecvt_null.hpp>
+#include <boost/archive/archive_exception.hpp>
+#include <boost/archive/detail/auto_link_archive.hpp>
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+namespace boost {
+namespace archive {
+
+/////////////////////////////////////////////////////////////////////////
+// class basic_binary_oprimitive - binary output of prmitives
+
+template<class Archive, class Elem, class Tr>
+class BOOST_SYMBOL_VISIBLE basic_binary_oprimitive {
+#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
+    friend class save_access;
+protected:
+#else
+public:
+#endif
+    std::basic_streambuf<Elem, Tr> & m_sb;
+    // return a pointer to the most derived class
+    Archive * This(){
+        return static_cast<Archive *>(this);
+    }
+    #ifndef BOOST_NO_STD_LOCALE
+    // note order! - if you change this, libstd++ will fail!
+    // a) create new locale with new codecvt facet
+    // b) save current locale
+    // c) change locale to new one
+    // d) use stream buffer
+    // e) change locale back to original
+    // f) destroy new codecvt facet
+    boost::archive::codecvt_null<Elem> codecvt_null_facet;
+    basic_streambuf_locale_saver<Elem, Tr> locale_saver;
+    std::locale archive_locale;
+    #endif
+    // default saving of primitives.
+    template<class T>
+    void save(const T & t)
+    {
+        save_binary(& t, sizeof(T));
+    }
+
+    /////////////////////////////////////////////////////////
+    // fundamental types that need special treatment
+    
+    // trap usage of invalid uninitialized boolean which would
+    // otherwise crash on load.
+    void save(const bool t){
+        BOOST_ASSERT(0 == static_cast<int>(t) || 1 == static_cast<int>(t));
+        save_binary(& t, sizeof(t));
+    }
+    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+    save(const std::string &s);
+    #ifndef BOOST_NO_STD_WSTRING
+    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+    save(const std::wstring &ws);
+    #endif
+    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+    save(const char * t);
+    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+    save(const wchar_t * t);
+
+    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+    init();
+    
+    BOOST_ARCHIVE_OR_WARCHIVE_DECL 
+    basic_binary_oprimitive(
+        std::basic_streambuf<Elem, Tr> & sb, 
+        bool no_codecvt
+    );
+    BOOST_ARCHIVE_OR_WARCHIVE_DECL 
+    ~basic_binary_oprimitive();
+public:
+
+    // we provide an optimized save for all fundamental types
+    // typedef serialization::is_bitwise_serializable<mpl::_1> 
+    // use_array_optimization;
+    // workaround without using mpl lambdas
+    struct use_array_optimization {
+        template <class T>  
+        #if defined(BOOST_NO_DEPENDENT_NESTED_DERIVATIONS)  
+            struct apply {  
+                typedef typename boost::serialization::is_bitwise_serializable< T >::type type;  
+            };
+        #else
+            struct apply : public boost::serialization::is_bitwise_serializable< T > {};  
+        #endif
+    };
+
+    // the optimized save_array dispatches to save_binary 
+    template <class ValueType>
+    void save_array(boost::serialization::array_wrapper<ValueType> const& a, unsigned int)
+    {
+      save_binary(a.address(),a.count()*sizeof(ValueType));
+    }
+
+    void save_binary(const void *address, std::size_t count);
+};
+
+template<class Archive, class Elem, class Tr>
+inline void 
+basic_binary_oprimitive<Archive, Elem, Tr>::save_binary(
+    const void *address, 
+    std::size_t count
+){
+    // BOOST_ASSERT(count <= std::size_t(boost::integer_traits<std::streamsize>::const_max));
+    // note: if the following assertions fail
+    // a likely cause is that the output stream is set to "text"
+    // mode where by cr characters recieve special treatment.
+    // be sure that the output stream is opened with ios::binary
+    //if(os.fail())
+    //    boost::serialization::throw_exception(
+    //        archive_exception(archive_exception::output_stream_error)
+    //    );
+    // figure number of elements to output - round up
+    count = ( count + sizeof(Elem) - 1) / sizeof(Elem);
+    std::streamsize scount = m_sb.sputn(
+        static_cast<const Elem *>(address), 
+        static_cast<std::streamsize>(count)
+    );
+    if(count != static_cast<std::size_t>(scount))
+        boost::serialization::throw_exception(
+            archive_exception(archive_exception::output_stream_error)
+        );
+    //os.write(
+    //    static_cast<const typename OStream::char_type *>(address), 
+    //    count
+    //);
+    //BOOST_ASSERT(os.good());
+}
+
+} //namespace boost 
+} //namespace archive 
+
+#include <boost/archive/detail/abi_suffix.hpp> // pop pragmas
+
+#endif // BOOST_ARCHIVE_BASIC_BINARY_OPRIMITIVE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/basic_streambuf_locale_saver.hpp b/contrib/libboost/boost_1_65_0/boost/archive/basic_streambuf_locale_saver.hpp
new file mode 100644
index 00000000000..5cd4b36f081
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/archive/basic_streambuf_locale_saver.hpp
@@ -0,0 +1,108 @@
+#ifndef BOOST_ARCHIVE_BASIC_STREAMBUF_LOCALE_SAVER_HPP
+#define BOOST_ARCHIVE_BASIC_STREAMBUF_LOCALE_SAVER_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// basic_streambuf_locale_saver.hpp
+
+// (C) Copyright 2005 Robert Ramey - http://www.rrsd.com
+
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+// note derived from boost/io/ios_state.hpp
+// Copyright 2002, 2005 Daryle Walker.  Use, modification, and distribution
+// are subject to the Boost Software License, Version 1.0.  (See accompanying
+// file LICENSE_1_0.txt or a copy at <http://www.boost.org/LICENSE_1_0.txt>.)
+
+//  See <http://www.boost.org/libs/io/> for the library's home page.
+
+#ifndef BOOST_NO_STD_LOCALE
+
+#include <locale>     // for std::locale
+#include <ios>
+#include <streambuf>  // for std::basic_streambuf
+
+#include <boost/config.hpp>
+#include <boost/noncopyable.hpp>
+
+#ifdef BOOST_MSVC
+#  pragma warning(push)
+#  pragma warning(disable : 4511 4512)
+#endif
+
+namespace boost{
+namespace archive{
+
+template < typename Ch, class Tr >
+class basic_streambuf_locale_saver :
+    private boost::noncopyable
+{
+public:
+    explicit basic_streambuf_locale_saver(std::basic_streambuf<Ch, Tr> &s) :
+        m_streambuf(s),
+        m_locale(s.getloc())
+    {}
+    ~basic_streambuf_locale_saver(){
+        m_streambuf.pubsync();
+        m_streambuf.pubimbue(m_locale);
+    }
+private:
+    std::basic_streambuf<Ch, Tr> &       m_streambuf;
+    std::locale const  m_locale;
+};
+
+template < typename Ch, class Tr >
+class basic_istream_locale_saver :
+    private boost::noncopyable
+{
+public:
+    explicit basic_istream_locale_saver(std::basic_istream<Ch, Tr> &s) :
+        m_istream(s),
+        m_locale(s.getloc())
+    {}
+    ~basic_istream_locale_saver(){
+        // libstdc++ crashes without this
+        m_istream.sync();
+        m_istream.imbue(m_locale);
+    }
+private:
+    std::basic_istream<Ch, Tr> & m_istream;
+    std::locale const  m_locale;
+};
+
+template < typename Ch, class Tr >
+class basic_ostream_locale_saver :
+    private boost::noncopyable
+{
+public:
+    explicit basic_ostream_locale_saver(std::basic_ostream<Ch, Tr> &s) :
+        m_ostream(s),
+        m_locale(s.getloc())
+    {}
+    ~basic_ostream_locale_saver(){
+        m_ostream.flush();
+        m_ostream.imbue(m_locale);
+    }
+private:
+    std::basic_ostream<Ch, Tr> & m_ostream;
+    std::locale const  m_locale;
+};
+
+
+} // archive
+} // boost
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+#endif // BOOST_NO_STD_LOCALE
+#endif // BOOST_ARCHIVE_BASIC_STREAMBUF_LOCALE_SAVER_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/basic_text_iarchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/basic_text_iarchive.hpp
new file mode 100644
index 00000000000..48a646cc1f7
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/archive/basic_text_iarchive.hpp
@@ -0,0 +1,96 @@
+#ifndef BOOST_ARCHIVE_BASIC_TEXT_IARCHIVE_HPP
+#define BOOST_ARCHIVE_BASIC_TEXT_IARCHIVE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// basic_text_iarchive.hpp
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+// archives stored as text - note these ar templated on the basic
+// stream templates to accommodate wide (and other?) kind of characters
+//
+// note the fact that on libraries without wide characters, ostream is
+// is not a specialization of basic_ostream which in fact is not defined
+// in such cases.   So we can't use basic_istream<IStream::char_type> but rather
+// use two template parameters
+
+#include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
+
+#include <boost/archive/detail/common_iarchive.hpp>
+
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+#ifdef BOOST_MSVC
+#  pragma warning(push)
+#  pragma warning(disable : 4511 4512)
+#endif
+
+namespace boost {
+namespace archive {
+
+namespace detail {
+    template<class Archive> class interface_iarchive;
+} // namespace detail
+
+/////////////////////////////////////////////////////////////////////////
+// class basic_text_iarchive - read serialized objects from a input text stream
+template<class Archive>
+class BOOST_SYMBOL_VISIBLE basic_text_iarchive : 
+    public detail::common_iarchive<Archive>
+{
+#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
+public:
+#else
+protected:
+    #if BOOST_WORKAROUND(BOOST_MSVC, < 1500)
+        // for some inexplicable reason insertion of "class" generates compile erro
+        // on msvc 7.1
+        friend detail::interface_iarchive<Archive>;
+    #else
+        friend class detail::interface_iarchive<Archive>;
+    #endif
+#endif
+    // intermediate level to support override of operators
+    // fot templates in the absence of partial function 
+    // template ordering
+    typedef detail::common_iarchive<Archive> detail_common_iarchive;
+    template<class T>
+    void load_override(T & t){
+        this->detail_common_iarchive::load_override(t);
+    }
+    // text file don't include the optional information 
+    void load_override(class_id_optional_type & /*t*/){}
+
+    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+    load_override(class_name_type & t);
+
+    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+    init(void);
+
+    basic_text_iarchive(unsigned int flags) : 
+        detail::common_iarchive<Archive>(flags)
+    {}
+    ~basic_text_iarchive(){}
+};
+
+} // namespace archive
+} // namespace boost
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#endif // BOOST_ARCHIVE_BASIC_TEXT_IARCHIVE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/basic_text_iprimitive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/basic_text_iprimitive.hpp
new file mode 100644
index 00000000000..bf936b55546
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/archive/basic_text_iprimitive.hpp
@@ -0,0 +1,142 @@
+#ifndef BOOST_ARCHIVE_BASIC_TEXT_IPRIMITIVE_HPP
+#define BOOST_ARCHIVE_BASIC_TEXT_IPRIMITIVE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// basic_text_iprimitive.hpp
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+// archives stored as text - note these are templated on the basic
+// stream templates to accommodate wide (and other?) kind of characters
+//
+// Note the fact that on libraries without wide characters, ostream is
+// not a specialization of basic_ostream which in fact is not defined
+// in such cases.   So we can't use basic_ostream<IStream::char_type> but rather
+// use two template parameters
+
+#include <locale>
+#include <cstddef> // size_t
+
+#include <boost/config.hpp>
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{ 
+    using ::size_t; 
+    #if ! defined(BOOST_DINKUMWARE_STDLIB) && ! defined(__SGI_STL_PORT)
+        using ::locale;
+    #endif
+} // namespace std
+#endif
+
+#include <boost/io/ios_state.hpp>
+#include <boost/static_assert.hpp>
+
+#include <boost/detail/workaround.hpp>
+#if BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, == 1)
+#include <boost/archive/dinkumware.hpp>
+#endif
+#include <boost/serialization/throw_exception.hpp>
+#include <boost/archive/codecvt_null.hpp>
+#include <boost/archive/archive_exception.hpp>
+#include <boost/archive/basic_streambuf_locale_saver.hpp>
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+namespace boost {
+namespace archive {
+
+/////////////////////////////////////////////////////////////////////////
+// class basic_text_iarchive - load serialized objects from a input text stream
+#if defined(_MSC_VER)
+#pragma warning( push )
+#pragma warning( disable : 4244 4267 )
+#endif
+
+template<class IStream>
+class BOOST_SYMBOL_VISIBLE basic_text_iprimitive {
+protected:
+    IStream &is;
+    io::ios_flags_saver flags_saver;
+    io::ios_precision_saver precision_saver;
+
+    #ifndef BOOST_NO_STD_LOCALE
+    // note order! - if you change this, libstd++ will fail!
+    // a) create new locale with new codecvt facet
+    // b) save current locale
+    // c) change locale to new one
+    // d) use stream buffer
+    // e) change locale back to original
+    // f) destroy new codecvt facet
+    boost::archive::codecvt_null<typename IStream::char_type> codecvt_null_facet;
+    std::locale archive_locale;
+    basic_istream_locale_saver<
+        typename IStream::char_type,
+        typename IStream::traits_type
+    > locale_saver;
+    #endif
+
+    template<class T>
+    void load(T & t)
+    {
+        if(is >> t)
+            return;
+        boost::serialization::throw_exception(
+            archive_exception(archive_exception::input_stream_error)
+        );
+    }
+
+    void load(char & t)
+    {
+        short int i;
+        load(i);
+        t = i;
+    }
+    void load(signed char & t)
+    {
+        short int i;
+        load(i);
+        t = i;
+    }
+    void load(unsigned char & t)
+    {
+        unsigned short int i;
+        load(i);
+        t = i;
+    }
+
+    #ifndef BOOST_NO_INTRINSIC_WCHAR_T
+    void load(wchar_t & t)
+    {
+        BOOST_STATIC_ASSERT(sizeof(wchar_t) <= sizeof(int));
+        int i;
+        load(i);
+        t = i;
+    }
+    #endif
+    BOOST_ARCHIVE_OR_WARCHIVE_DECL 
+    basic_text_iprimitive(IStream  &is, bool no_codecvt);
+    BOOST_ARCHIVE_OR_WARCHIVE_DECL 
+    ~basic_text_iprimitive();
+public:
+    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+    load_binary(void *address, std::size_t count);
+};
+
+#if defined(_MSC_VER)
+#pragma warning( pop )
+#endif
+
+} // namespace archive
+} // namespace boost
+
+#include <boost/archive/detail/abi_suffix.hpp> // pop pragmas
+
+#endif // BOOST_ARCHIVE_BASIC_TEXT_IPRIMITIVE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/basic_text_oarchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/basic_text_oarchive.hpp
new file mode 100644
index 00000000000..6f7f8fb167d
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/archive/basic_text_oarchive.hpp
@@ -0,0 +1,119 @@
+#ifndef BOOST_ARCHIVE_BASIC_TEXT_OARCHIVE_HPP
+#define BOOST_ARCHIVE_BASIC_TEXT_OARCHIVE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// basic_text_oarchive.hpp
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+// archives stored as text - note these ar templated on the basic
+// stream templates to accommodate wide (and other?) kind of characters
+//
+// note the fact that on libraries without wide characters, ostream is
+// is not a specialization of basic_ostream which in fact is not defined
+// in such cases.   So we can't use basic_ostream<OStream::char_type> but rather
+// use two template parameters
+
+#include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
+#include <boost/archive/detail/common_oarchive.hpp>
+#include <boost/serialization/string.hpp>
+
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+#ifdef BOOST_MSVC
+#  pragma warning(push)
+#  pragma warning(disable : 4511 4512)
+#endif
+
+namespace boost {
+namespace archive {
+
+namespace detail {
+    template<class Archive> class interface_oarchive;
+} // namespace detail
+
+/////////////////////////////////////////////////////////////////////////
+// class basic_text_oarchive 
+template<class Archive>
+class BOOST_SYMBOL_VISIBLE basic_text_oarchive : 
+    public detail::common_oarchive<Archive>
+{
+#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
+public:
+#else
+protected:
+    #if BOOST_WORKAROUND(BOOST_MSVC, < 1500)
+        // for some inexplicable reason insertion of "class" generates compile erro
+        // on msvc 7.1
+        friend detail::interface_oarchive<Archive>;
+    #else
+        friend class detail::interface_oarchive<Archive>;
+    #endif
+#endif
+
+    enum {
+        none,
+        eol,
+        space
+    } delimiter;
+
+    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+    newtoken();
+
+    void newline(){
+        delimiter = eol;
+    }
+
+    // default processing - kick back to base class.  Note the
+    // extra stuff to get it passed borland compilers
+    typedef detail::common_oarchive<Archive> detail_common_oarchive;
+    template<class T>
+    void save_override(T & t){
+        this->detail_common_oarchive::save_override(t);
+    }
+
+    // start new objects on a new line
+    void save_override(const object_id_type & t){
+        this->This()->newline();
+        this->detail_common_oarchive::save_override(t);
+    }
+
+    // text file don't include the optional information 
+    void save_override(const class_id_optional_type & /* t */){}
+
+    void save_override(const class_name_type & t){
+        const std::string s(t);
+        * this->This() << s;
+    }
+
+    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+    init();
+
+    basic_text_oarchive(unsigned int flags) :
+        detail::common_oarchive<Archive>(flags),
+        delimiter(none)
+    {}
+    ~basic_text_oarchive(){}
+};
+
+} // namespace archive
+} // namespace boost
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#endif // BOOST_ARCHIVE_BASIC_TEXT_OARCHIVE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/basic_text_oprimitive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/basic_text_oprimitive.hpp
new file mode 100644
index 00000000000..45f09358ece
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/archive/basic_text_oprimitive.hpp
@@ -0,0 +1,209 @@
+#ifndef BOOST_ARCHIVE_BASIC_TEXT_OPRIMITIVE_HPP
+#define BOOST_ARCHIVE_BASIC_TEXT_OPRIMITIVE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// basic_text_oprimitive.hpp
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+// archives stored as text - note these ar templated on the basic
+// stream templates to accommodate wide (and other?) kind of characters
+//
+// note the fact that on libraries without wide characters, ostream is
+// is not a specialization of basic_ostream which in fact is not defined
+// in such cases.   So we can't use basic_ostream<OStream::char_type> but rather
+// use two template parameters
+
+#include <iomanip>
+#include <locale>
+#include <cstddef> // size_t
+
+#include <boost/config.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/io/ios_state.hpp>
+
+#include <boost/detail/workaround.hpp>
+#if BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, == 1)
+#include <boost/archive/dinkumware.hpp>
+#endif
+
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{ 
+    using ::size_t;
+    #if ! defined(BOOST_DINKUMWARE_STDLIB) && ! defined(__SGI_STL_PORT)
+        using ::locale;
+    #endif
+} // namespace std
+#endif
+
+#include <boost/type_traits/is_floating_point.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/limits.hpp>
+#include <boost/integer.hpp>
+#include <boost/io/ios_state.hpp>
+#include <boost/serialization/throw_exception.hpp>
+#include <boost/archive/basic_streambuf_locale_saver.hpp>
+#include <boost/archive/codecvt_null.hpp>
+#include <boost/archive/archive_exception.hpp>
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+namespace boost {
+namespace archive {
+
+/////////////////////////////////////////////////////////////////////////
+// class basic_text_oprimitive - output of prmitives to stream
+template<class OStream>
+class BOOST_SYMBOL_VISIBLE basic_text_oprimitive
+{
+protected:
+    OStream &os;
+    io::ios_flags_saver flags_saver;
+    io::ios_precision_saver precision_saver;
+
+    #ifndef BOOST_NO_STD_LOCALE
+    // note order! - if you change this, libstd++ will fail!
+    // a) create new locale with new codecvt facet
+    // b) save current locale
+    // c) change locale to new one
+    // d) use stream buffer
+    // e) change locale back to original
+    // f) destroy new codecvt facet
+    boost::archive::codecvt_null<typename OStream::char_type> codecvt_null_facet;
+    std::locale archive_locale;
+    basic_ostream_locale_saver<
+        typename OStream::char_type,
+        typename OStream::traits_type
+    > locale_saver;
+    #endif
+
+    /////////////////////////////////////////////////////////
+    // fundamental types that need special treatment
+    void save(const bool t){
+        // trap usage of invalid uninitialized boolean which would
+        // otherwise crash on load.
+        BOOST_ASSERT(0 == static_cast<int>(t) || 1 == static_cast<int>(t));
+        if(os.fail())
+            boost::serialization::throw_exception(
+                archive_exception(archive_exception::output_stream_error)
+            );
+        os << t;
+    }
+    void save(const signed char t)
+    {
+        save(static_cast<short int>(t));
+    }
+    void save(const unsigned char t)
+    {
+        save(static_cast<short unsigned int>(t));
+    }
+    void save(const char t)
+    {
+        save(static_cast<short int>(t));
+    }
+    #ifndef BOOST_NO_INTRINSIC_WCHAR_T
+    void save(const wchar_t t)
+    {
+        BOOST_STATIC_ASSERT(sizeof(wchar_t) <= sizeof(int));
+        save(static_cast<int>(t));
+    }
+    #endif
+
+    /////////////////////////////////////////////////////////
+    // saving of any types not listed above
+
+    template<class T>
+    void save_impl(const T &t, boost::mpl::bool_<false> &){
+        if(os.fail())
+            boost::serialization::throw_exception(
+                archive_exception(archive_exception::output_stream_error)
+            );
+        os << t;
+    }
+
+    /////////////////////////////////////////////////////////
+    // floating point types need even more special treatment
+    // the following determines whether the type T is some sort
+    // of floating point type.  Note that we then assume that
+    // the stream << operator is defined on that type - if not
+    // we'll get a compile time error. This is meant to automatically
+    // support synthesized types which support floating point
+    // operations. Also it should handle compiler dependent types
+    // such long double.  Due to John Maddock.
+
+    template<class T>
+    struct is_float {
+        typedef typename mpl::bool_< 
+            boost::is_floating_point<T>::value 
+            || (std::numeric_limits<T>::is_specialized
+            && !std::numeric_limits<T>::is_integer
+            && !std::numeric_limits<T>::is_exact
+            && std::numeric_limits<T>::max_exponent) 
+        >::type type;
+    };
+
+    template<class T>
+    void save_impl(const T &t, boost::mpl::bool_<true> &){
+        // must be a user mistake - can't serialize un-initialized data
+        if(os.fail())
+            boost::serialization::throw_exception(
+                archive_exception(archive_exception::output_stream_error)
+            );
+        // The formulae for the number of decimla digits required is given in
+        // http://www2.open-std.org/JTC1/SC22/WG21/docs/papers/2005/n1822.pdf
+        // which is derived from Kahan's paper:
+        // www.eecs.berkeley.edu/~wkahan/ieee754status/ieee754.ps
+        // const unsigned int digits = (std::numeric_limits<T>::digits * 3010) / 10000;
+        // note: I've commented out the above because I didn't get good results.  e.g.
+        // in one case I got a difference of 19 units.
+        #ifndef BOOST_NO_CXX11_NUMERIC_LIMITS
+            const unsigned int digits = std::numeric_limits<T>::max_digits10;
+        #else
+            const unsigned int digits = std::numeric_limits<T>::digits10 + 2;
+        #endif
+        os << std::setprecision(digits) << std::scientific << t;
+    }
+
+    template<class T>
+    void save(const T & t){
+        typename is_float<T>::type tf;
+        save_impl(t, tf);
+    }
+
+    BOOST_ARCHIVE_OR_WARCHIVE_DECL
+    basic_text_oprimitive(OStream & os, bool no_codecvt);
+    BOOST_ARCHIVE_OR_WARCHIVE_DECL 
+    ~basic_text_oprimitive();
+public:
+    // unformatted append of one character
+    void put(typename OStream::char_type c){
+        if(os.fail())
+            boost::serialization::throw_exception(
+                archive_exception(archive_exception::output_stream_error)
+            );
+        os.put(c);
+    }
+    // unformatted append of null terminated string
+    void put(const char * s){
+        while('\0' != *s)
+            os.put(*s++);
+    }
+    BOOST_ARCHIVE_OR_WARCHIVE_DECL void 
+    save_binary(const void *address, std::size_t count);
+};
+
+} //namespace boost 
+} //namespace archive 
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#endif // BOOST_ARCHIVE_BASIC_TEXT_OPRIMITIVE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/basic_xml_archive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/basic_xml_archive.hpp
new file mode 100644
index 00000000000..bef368b973b
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/archive/basic_xml_archive.hpp
@@ -0,0 +1,67 @@
+#ifndef BOOST_ARCHIVE_BASIC_XML_TEXT_ARCHIVE_HPP
+#define BOOST_ARCHIVE_BASIC_XML_TEXT_ARCHIVE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// basic_xml_archive.hpp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+#include <boost/archive/archive_exception.hpp>
+
+#include <boost/archive/detail/auto_link_archive.hpp>
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+namespace boost { 
+namespace archive {
+
+// constant strings used in xml i/o
+
+extern 
+BOOST_ARCHIVE_DECL const char *
+BOOST_ARCHIVE_XML_OBJECT_ID();
+
+extern 
+BOOST_ARCHIVE_DECL const char *
+BOOST_ARCHIVE_XML_OBJECT_REFERENCE();
+
+extern 
+BOOST_ARCHIVE_DECL const char *
+BOOST_ARCHIVE_XML_CLASS_ID();
+
+extern 
+BOOST_ARCHIVE_DECL const char *
+BOOST_ARCHIVE_XML_CLASS_ID_REFERENCE();
+
+extern 
+BOOST_ARCHIVE_DECL const char *
+BOOST_ARCHIVE_XML_CLASS_NAME();
+
+extern 
+BOOST_ARCHIVE_DECL const char *
+BOOST_ARCHIVE_XML_TRACKING();
+
+extern 
+BOOST_ARCHIVE_DECL const char *
+BOOST_ARCHIVE_XML_VERSION();
+
+extern 
+BOOST_ARCHIVE_DECL const char *
+BOOST_ARCHIVE_XML_SIGNATURE();
+
+}// namespace archive
+}// namespace boost
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#endif // BOOST_ARCHIVE_BASIC_XML_TEXT_ARCHIVE_HPP
+
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/basic_xml_iarchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/basic_xml_iarchive.hpp
new file mode 100644
index 00000000000..e9f7482f744
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/archive/basic_xml_iarchive.hpp
@@ -0,0 +1,119 @@
+#ifndef BOOST_ARCHIVE_BASIC_XML_IARCHIVE_HPP
+#define BOOST_ARCHIVE_BASIC_XML_IARCHIVE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// basic_xml_iarchive.hpp
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+#include <boost/config.hpp>
+#include <boost/mpl/assert.hpp>
+
+#include <boost/archive/detail/common_iarchive.hpp>
+#include <boost/serialization/nvp.hpp>
+#include <boost/serialization/string.hpp>
+
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+#ifdef BOOST_MSVC
+#  pragma warning(push)
+#  pragma warning(disable : 4511 4512)
+#endif
+
+namespace boost {
+namespace archive {
+
+namespace detail {
+    template<class Archive> class interface_iarchive;
+} // namespace detail
+
+/////////////////////////////////////////////////////////////////////////
+// class basic_xml_iarchive - read serialized objects from a input text stream
+template<class Archive>
+class BOOST_SYMBOL_VISIBLE basic_xml_iarchive :
+    public detail::common_iarchive<Archive>
+{
+    unsigned int depth;
+#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
+public:
+#else
+protected:
+    friend class detail::interface_iarchive<Archive>;
+#endif
+    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+    load_start(const char *name);
+    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+    load_end(const char *name);
+
+    // Anything not an attribute and not a name-value pair is an
+    // should be trapped here.
+    template<class T>
+    void load_override(T & t)
+    {
+        // If your program fails to compile here, its most likely due to
+        // not specifying an nvp wrapper around the variable to
+        // be serialized.
+        BOOST_MPL_ASSERT((serialization::is_wrapper< T >));
+        this->detail_common_iarchive::load_override(t);
+    }
+
+    // Anything not an attribute - see below - should be a name value
+    // pair and be processed here
+    typedef detail::common_iarchive<Archive> detail_common_iarchive;
+    template<class T>
+    void load_override(
+        const boost::serialization::nvp< T > & t
+    ){
+        this->This()->load_start(t.name());
+        this->detail_common_iarchive::load_override(t.value());
+        this->This()->load_end(t.name());
+    }
+
+    // specific overrides for attributes - handle as
+    // primitives. These are not name-value pairs
+    // so they have to be intercepted here and passed on to load.
+    // although the class_id is included in the xml text file in order
+    // to make the file self describing, it isn't used when loading
+    // an xml archive.  So we can skip it here.  Note: we MUST override
+    // it otherwise it will be loaded as a normal primitive w/o tag and
+    // leaving the archive in an undetermined state
+    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+    load_override(class_id_type & t);
+    void load_override(class_id_optional_type & /* t */){}
+    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+    load_override(object_id_type & t);
+    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+    load_override(version_type & t);
+    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+    load_override(tracking_type & t);
+    // class_name_type can't be handled here as it depends upon the
+    // char type used by the stream.  So require the derived implementation
+    // handle this.
+    // void load_override(class_name_type & t);
+
+    BOOST_ARCHIVE_OR_WARCHIVE_DECL
+    basic_xml_iarchive(unsigned int flags);
+    BOOST_ARCHIVE_OR_WARCHIVE_DECL
+    ~basic_xml_iarchive();
+};
+
+} // namespace archive
+} // namespace boost
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#endif // BOOST_ARCHIVE_BASIC_XML_IARCHIVE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/basic_xml_oarchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/basic_xml_oarchive.hpp
new file mode 100644
index 00000000000..107fca4ec65
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/archive/basic_xml_oarchive.hpp
@@ -0,0 +1,138 @@
+#ifndef BOOST_ARCHIVE_BASIC_XML_OARCHIVE_HPP
+#define BOOST_ARCHIVE_BASIC_XML_OARCHIVE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// basic_xml_oarchive.hpp
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+#include <boost/config.hpp>
+#include <boost/mpl/assert.hpp>
+
+#include <boost/archive/detail/common_oarchive.hpp>
+#include <boost/serialization/nvp.hpp>
+#include <boost/serialization/string.hpp>
+
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+#ifdef BOOST_MSVC
+#  pragma warning(push)
+#  pragma warning(disable : 4511 4512)
+#endif
+
+namespace boost {
+namespace archive {
+
+namespace detail {
+    template<class Archive> class interface_oarchive;
+} // namespace detail
+
+//////////////////////////////////////////////////////////////////////
+// class basic_xml_oarchive - write serialized objects to a xml output stream
+template<class Archive>
+class BOOST_SYMBOL_VISIBLE basic_xml_oarchive :
+    public detail::common_oarchive<Archive>
+{
+    // special stuff for xml output
+    unsigned int depth;
+    bool pending_preamble;
+#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
+public:
+#else
+protected:
+    friend class detail::interface_oarchive<Archive>;
+#endif
+    bool indent_next;
+    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+    indent();
+    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+    init();
+    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+    windup();
+    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+    write_attribute(
+        const char *attribute_name,
+        int t,
+        const char *conjunction = "=\""
+    );
+    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+    write_attribute(
+        const char *attribute_name,
+        const char *key
+    );
+    // helpers used below
+    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+    save_start(const char *name);
+    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+    save_end(const char *name);
+    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+    end_preamble();
+
+    // Anything not an attribute and not a name-value pair is an
+    // error and should be trapped here.
+    template<class T>
+    void save_override(T & t)
+    {
+        // If your program fails to compile here, its most likely due to
+        // not specifying an nvp wrapper around the variable to
+        // be serialized.
+        BOOST_MPL_ASSERT((serialization::is_wrapper< T >));
+        this->detail_common_oarchive::save_override(t);
+    }
+
+    // special treatment for name-value pairs.
+    typedef detail::common_oarchive<Archive> detail_common_oarchive;
+    template<class T>
+    void save_override(
+        const ::boost::serialization::nvp< T > & t
+    ){
+        this->This()->save_start(t.name());
+        this->detail_common_oarchive::save_override(t.const_value());
+        this->This()->save_end(t.name());
+    }
+
+    // specific overrides for attributes - not name value pairs so we
+    // want to trap them before the above "fall through"
+    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+    save_override(const class_id_type & t);
+    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+    save_override(const class_id_optional_type & t);
+    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+    save_override(const class_id_reference_type & t);
+    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+    save_override(const object_id_type & t);
+    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+    save_override(const object_reference_type & t);
+    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+    save_override(const version_type & t);
+    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+    save_override(const class_name_type & t);
+    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+    save_override(const tracking_type & t);
+
+    BOOST_ARCHIVE_OR_WARCHIVE_DECL
+    basic_xml_oarchive(unsigned int flags);
+    BOOST_ARCHIVE_OR_WARCHIVE_DECL
+    ~basic_xml_oarchive();
+};
+
+} // namespace archive
+} // namespace boost
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#endif // BOOST_ARCHIVE_BASIC_XML_OARCHIVE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/binary_iarchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/binary_iarchive.hpp
new file mode 100644
index 00000000000..785ce7610b1
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/archive/binary_iarchive.hpp
@@ -0,0 +1,64 @@
+#ifndef BOOST_ARCHIVE_BINARY_IARCHIVE_HPP
+#define BOOST_ARCHIVE_BINARY_IARCHIVE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// binary_iarchive.hpp
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+#include <istream>
+#include <boost/archive/binary_iarchive_impl.hpp>
+#include <boost/archive/detail/register_archive.hpp>
+
+#ifdef BOOST_MSVC
+#  pragma warning(push)
+#  pragma warning(disable : 4511 4512)
+#endif
+
+namespace boost {
+namespace archive {
+
+// do not derive from this class.  If you want to extend this functionality
+// via inhertance, derived from binary_iarchive_impl instead.  This will
+// preserve correct static polymorphism.
+class BOOST_SYMBOL_VISIBLE binary_iarchive :
+    public binary_iarchive_impl<
+        boost::archive::binary_iarchive, 
+        std::istream::char_type, 
+        std::istream::traits_type
+    >{
+public:
+    binary_iarchive(std::istream & is, unsigned int flags = 0) :
+        binary_iarchive_impl<
+            binary_iarchive, std::istream::char_type, std::istream::traits_type
+        >(is, flags)
+    {}
+    binary_iarchive(std::streambuf & bsb, unsigned int flags = 0) :
+        binary_iarchive_impl<
+            binary_iarchive, std::istream::char_type, std::istream::traits_type
+        >(bsb, flags)
+    {}
+};
+
+} // namespace archive
+} // namespace boost
+
+// required by export
+BOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::binary_iarchive)
+BOOST_SERIALIZATION_USE_ARRAY_OPTIMIZATION(boost::archive::binary_iarchive)
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+#endif // BOOST_ARCHIVE_BINARY_IARCHIVE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/binary_iarchive_impl.hpp b/contrib/libboost/boost_1_65_0/boost/archive/binary_iarchive_impl.hpp
new file mode 100644
index 00000000000..b4747c98ece
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/archive/binary_iarchive_impl.hpp
@@ -0,0 +1,105 @@
+#ifndef BOOST_ARCHIVE_BINARY_IARCHIVE_IMPL_HPP
+#define BOOST_ARCHIVE_BINARY_IARCHIVE_IMPL_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// binary_iarchive_impl.hpp
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+#include <istream>
+#include <boost/archive/basic_binary_iprimitive.hpp>
+#include <boost/archive/basic_binary_iarchive.hpp>
+
+#ifdef BOOST_MSVC
+#  pragma warning(push)
+#  pragma warning(disable : 4511 4512)
+#endif
+
+namespace boost { 
+namespace archive {
+
+namespace detail {
+    template<class Archive> class interface_iarchive;
+} // namespace detail
+
+template<class Archive, class Elem, class Tr>
+class BOOST_SYMBOL_VISIBLE binary_iarchive_impl : 
+    public basic_binary_iprimitive<Archive, Elem, Tr>,
+    public basic_binary_iarchive<Archive>
+{
+#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
+public:
+#else
+protected:
+    #if BOOST_WORKAROUND(BOOST_MSVC, < 1500)
+        // for some inexplicable reason insertion of "class" generates compile erro
+        // on msvc 7.1
+        friend detail::interface_iarchive<Archive>;
+        friend basic_binary_iarchive<Archive>;
+        friend load_access;
+    #else
+        friend class detail::interface_iarchive<Archive>;
+        friend class basic_binary_iarchive<Archive>;
+        friend class load_access;
+    #endif
+#endif
+    template<class T>
+    void load_override(T & t){
+        this->basic_binary_iarchive<Archive>::load_override(t);
+    }
+    void init(unsigned int flags){
+        if(0 != (flags & no_header)){
+            return;
+        }
+        #if ! defined(__MWERKS__)
+            this->basic_binary_iarchive<Archive>::init();
+            this->basic_binary_iprimitive<Archive, Elem, Tr>::init();
+        #else
+            basic_binary_iarchive<Archive>::init();
+            basic_binary_iprimitive<Archive, Elem, Tr>::init();
+        #endif
+    }
+    binary_iarchive_impl(
+        std::basic_streambuf<Elem, Tr> & bsb, 
+        unsigned int flags
+    ) :
+        basic_binary_iprimitive<Archive, Elem, Tr>(
+            bsb, 
+            0 != (flags & no_codecvt)
+        ),
+        basic_binary_iarchive<Archive>(flags)
+    {
+        init(flags);
+    }
+    binary_iarchive_impl(
+        std::basic_istream<Elem, Tr> & is, 
+        unsigned int flags
+    ) :
+        basic_binary_iprimitive<Archive, Elem, Tr>(
+            * is.rdbuf(), 
+            0 != (flags & no_codecvt)
+        ),
+        basic_binary_iarchive<Archive>(flags)
+    {
+        init(flags);
+    }
+};
+
+} // namespace archive
+} // namespace boost
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+#endif // BOOST_ARCHIVE_BINARY_IARCHIVE_IMPL_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/binary_oarchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/binary_oarchive.hpp
new file mode 100644
index 00000000000..e8313fd7c95
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/archive/binary_oarchive.hpp
@@ -0,0 +1,64 @@
+#ifndef BOOST_ARCHIVE_BINARY_OARCHIVE_HPP
+#define BOOST_ARCHIVE_BINARY_OARCHIVE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// binary_oarchive.hpp
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+#include <ostream>
+#include <boost/config.hpp>
+#include <boost/archive/binary_oarchive_impl.hpp>
+#include <boost/archive/detail/register_archive.hpp>
+
+#ifdef BOOST_MSVC
+#  pragma warning(push)
+#  pragma warning(disable : 4511 4512)
+#endif
+
+namespace boost { 
+namespace archive {
+
+// do not derive from this class.  If you want to extend this functionality
+// via inhertance, derived from binary_oarchive_impl instead.  This will
+// preserve correct static polymorphism.
+class BOOST_SYMBOL_VISIBLE binary_oarchive : 
+    public binary_oarchive_impl<
+        binary_oarchive, std::ostream::char_type, std::ostream::traits_type
+    >
+{
+public:
+    binary_oarchive(std::ostream & os, unsigned int flags = 0) :
+        binary_oarchive_impl<
+            binary_oarchive, std::ostream::char_type, std::ostream::traits_type
+        >(os, flags)
+    {}
+    binary_oarchive(std::streambuf & bsb, unsigned int flags = 0) :
+        binary_oarchive_impl<
+            binary_oarchive, std::ostream::char_type, std::ostream::traits_type
+        >(bsb, flags)
+    {}
+};
+
+} // namespace archive
+} // namespace boost
+
+// required by export
+BOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::binary_oarchive)
+BOOST_SERIALIZATION_USE_ARRAY_OPTIMIZATION(boost::archive::binary_oarchive)
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+#endif // BOOST_ARCHIVE_BINARY_OARCHIVE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/binary_oarchive_impl.hpp b/contrib/libboost/boost_1_65_0/boost/archive/binary_oarchive_impl.hpp
new file mode 100644
index 00000000000..6b4d018a564
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/archive/binary_oarchive_impl.hpp
@@ -0,0 +1,106 @@
+#ifndef BOOST_ARCHIVE_BINARY_OARCHIVE_IMPL_HPP
+#define BOOST_ARCHIVE_BINARY_OARCHIVE_IMPL_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// binary_oarchive_impl.hpp
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+#include <ostream>
+#include <boost/config.hpp>
+#include <boost/archive/basic_binary_oprimitive.hpp>
+#include <boost/archive/basic_binary_oarchive.hpp>
+
+#ifdef BOOST_MSVC
+#  pragma warning(push)
+#  pragma warning(disable : 4511 4512)
+#endif
+
+namespace boost { 
+namespace archive {
+
+namespace detail {
+    template<class Archive> class interface_oarchive;
+} // namespace detail
+
+template<class Archive, class Elem, class Tr>
+class BOOST_SYMBOL_VISIBLE binary_oarchive_impl : 
+    public basic_binary_oprimitive<Archive, Elem, Tr>,
+    public basic_binary_oarchive<Archive>
+{
+#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
+public:
+#else
+protected:
+    #if BOOST_WORKAROUND(BOOST_MSVC, < 1500)
+        // for some inexplicable reason insertion of "class" generates compile erro
+        // on msvc 7.1
+        friend detail::interface_oarchive<Archive>;
+        friend basic_binary_oarchive<Archive>;
+        friend save_access;
+    #else
+        friend class detail::interface_oarchive<Archive>;
+        friend class basic_binary_oarchive<Archive>;
+        friend class save_access;
+    #endif
+#endif
+    template<class T>
+    void save_override(T & t){
+        this->basic_binary_oarchive<Archive>::save_override(t);
+    }
+    void init(unsigned int flags) {
+        if(0 != (flags & no_header)){
+            return;
+        }
+        #if ! defined(__MWERKS__)
+            this->basic_binary_oarchive<Archive>::init();
+            this->basic_binary_oprimitive<Archive, Elem, Tr>::init();
+        #else
+            basic_binary_oarchive<Archive>::init();
+            basic_binary_oprimitive<Archive, Elem, Tr>::init();
+        #endif
+    }
+    binary_oarchive_impl(
+        std::basic_streambuf<Elem, Tr> & bsb, 
+        unsigned int flags
+    ) :
+        basic_binary_oprimitive<Archive, Elem, Tr>(
+            bsb, 
+            0 != (flags & no_codecvt)
+        ),
+        basic_binary_oarchive<Archive>(flags)
+    {
+        init(flags);
+    }
+    binary_oarchive_impl(
+        std::basic_ostream<Elem, Tr> & os, 
+        unsigned int flags
+    ) :
+        basic_binary_oprimitive<Archive, Elem, Tr>(
+            * os.rdbuf(), 
+            0 != (flags & no_codecvt)
+        ),
+        basic_binary_oarchive<Archive>(flags)
+    {
+        init(flags);
+    }
+};
+
+} // namespace archive
+} // namespace boost
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+#endif // BOOST_ARCHIVE_BINARY_OARCHIVE_IMPL_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/binary_wiarchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/binary_wiarchive.hpp
new file mode 100644
index 00000000000..775d8f82726
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/archive/binary_wiarchive.hpp
@@ -0,0 +1,56 @@
+#ifndef BOOST_ARCHIVE_BINARY_WIARCHIVE_HPP
+#define BOOST_ARCHIVE_BINARY_WIARCHIVE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// binary_wiarchive.hpp
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+#include <boost/config.hpp>
+#ifdef BOOST_NO_STD_WSTREAMBUF
+#error "wide char i/o not supported on this platform"
+#else
+
+#include <istream> // wistream
+#include <boost/archive/binary_iarchive_impl.hpp>
+#include <boost/archive/detail/register_archive.hpp>
+
+namespace boost { 
+namespace archive {
+
+class binary_wiarchive : 
+    public binary_iarchive_impl<
+        binary_wiarchive, std::wistream::char_type, std::wistream::traits_type
+    >
+{
+public:
+    binary_wiarchive(std::wistream & is, unsigned int flags = 0) :
+        binary_iarchive_impl<
+            binary_wiarchive, std::wistream::char_type, std::wistream::traits_type
+        >(is, flags)
+    {}
+    binary_wiarchive(std::wstreambuf & bsb, unsigned int flags = 0) :
+        binary_iarchive_impl<
+            binary_wiarchive, std::wistream::char_type, std::wistream::traits_type
+        >(bsb, flags)
+    {}
+};
+
+} // namespace archive
+} // namespace boost
+
+// required by export
+BOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::binary_wiarchive)
+
+#endif // BOOST_NO_STD_WSTREAMBUF
+#endif // BOOST_ARCHIVE_BINARY_WIARCHIVE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/binary_woarchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/binary_woarchive.hpp
new file mode 100644
index 00000000000..a8817d6f8b4
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/archive/binary_woarchive.hpp
@@ -0,0 +1,59 @@
+#ifndef BOOST_ARCHIVE_BINARY_WOARCHIVE_HPP
+#define BOOST_ARCHIVE_BINARY_WOARCHIVE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// binary_woarchive.hpp
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+#include <boost/config.hpp>
+#ifdef BOOST_NO_STD_WSTREAMBUF
+#error "wide char i/o not supported on this platform"
+#else
+
+#include <ostream>
+#include <boost/archive/binary_oarchive_impl.hpp>
+#include <boost/archive/detail/register_archive.hpp>
+
+namespace boost { 
+namespace archive {
+
+// do not derive from this class.  If you want to extend this functionality
+// via inhertance, derived from binary_oarchive_impl instead.  This will
+// preserve correct static polymorphism.
+class binary_woarchive : 
+    public binary_oarchive_impl<
+            binary_woarchive, std::wostream::char_type, std::wostream::traits_type
+        >
+{
+public:
+    binary_woarchive(std::wostream & os, unsigned int flags = 0) :
+        binary_oarchive_impl<
+            binary_woarchive, std::wostream::char_type, std::wostream::traits_type
+        >(os, flags)
+    {}
+    binary_woarchive(std::wstreambuf & bsb, unsigned int flags = 0) :
+        binary_oarchive_impl<
+            binary_woarchive, std::wostream::char_type, std::wostream::traits_type
+        >(bsb, flags)
+    {}
+};
+
+} // namespace archive
+} // namespace boost
+
+// required by export
+BOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::binary_woarchive)
+
+#endif // BOOST_NO_STD_WSTREAMBUF
+#endif // BOOST_ARCHIVE_BINARY_WOARCHIVE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/codecvt_null.hpp b/contrib/libboost/boost_1_65_0/boost/archive/codecvt_null.hpp
new file mode 100644
index 00000000000..7bce2b9b329
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/archive/codecvt_null.hpp
@@ -0,0 +1,109 @@
+#ifndef BOOST_ARCHIVE_CODECVT_NULL_HPP
+#define BOOST_ARCHIVE_CODECVT_NULL_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// codecvt_null.hpp:
+
+// (C) Copyright 2004 Robert Ramey - http://www.rrsd.com .
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+#include <locale>
+#include <cstddef> // NULL, size_t
+#ifndef BOOST_NO_CWCHAR
+#include <cwchar>   // for mbstate_t
+#endif
+#include <boost/config.hpp>
+#include <boost/serialization/force_include.hpp>
+#include <boost/archive/detail/auto_link_archive.hpp>
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std {
+// For STLport on WinCE, BOOST_NO_STDC_NAMESPACE can get defined if STLport is putting symbols in its own namespace.
+// In the case of codecvt, however, this does not mean that codecvt is in the global namespace (it will be in STLport's namespace)
+#  if !defined(__SGI_STL_PORT) && !defined(_STLPORT_VERSION)
+    using ::codecvt;
+#  endif
+    using ::mbstate_t;
+    using ::size_t;
+} // namespace
+#endif
+
+#ifdef BOOST_MSVC
+#  pragma warning(push)
+#  pragma warning(disable : 4511 4512)
+#endif
+
+namespace boost {
+namespace archive {
+
+template<class Ch>
+class codecvt_null;
+
+template<>
+class codecvt_null<char> : public std::codecvt<char, char, std::mbstate_t>
+{
+    virtual bool do_always_noconv() const throw() {
+        return true;
+    }
+public:
+    explicit codecvt_null(std::size_t no_locale_manage = 0) :
+        std::codecvt<char, char, std::mbstate_t>(no_locale_manage)
+    {}
+    virtual ~codecvt_null(){};
+};
+
+template<>
+class BOOST_SYMBOL_VISIBLE codecvt_null<wchar_t> : public std::codecvt<wchar_t, char, std::mbstate_t>
+{
+    virtual BOOST_WARCHIVE_DECL BOOST_DLLEXPORT std::codecvt_base::result
+    do_out(
+        std::mbstate_t & state,
+        const wchar_t * first1,
+        const wchar_t * last1,
+        const wchar_t * & next1,
+        char * first2,
+        char * last2,
+        char * & next2
+    ) const BOOST_USED;
+    virtual BOOST_WARCHIVE_DECL BOOST_DLLEXPORT std::codecvt_base::result
+    do_in(
+        std::mbstate_t & state,
+        const char * first1,
+        const char * last1,
+        const char * & next1,
+        wchar_t * first2,
+        wchar_t * last2,
+        wchar_t * & next2
+    ) const BOOST_USED;
+    virtual int do_encoding( ) const throw( ){
+        return sizeof(wchar_t) / sizeof(char);
+    }
+    virtual int do_max_length( ) const throw( ){
+        return do_encoding();
+    }
+public:
+    BOOST_DLLEXPORT explicit codecvt_null(std::size_t no_locale_manage = 0) :
+        std::codecvt<wchar_t, char, std::mbstate_t>(no_locale_manage)
+    {}
+    virtual ~codecvt_null(){};
+};
+
+} // namespace archive
+} // namespace boost
+
+#ifdef BOOST_MSVC
+#  pragma warning(pop)
+#endif
+#include <boost/archive/detail/abi_suffix.hpp> // pop pragmas
+
+#endif //BOOST_ARCHIVE_CODECVT_NULL_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/detail/abi_prefix.hpp b/contrib/libboost/boost_1_65_0/boost/archive/detail/abi_prefix.hpp
new file mode 100644
index 00000000000..debf79e9f0b
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/archive/detail/abi_prefix.hpp
@@ -0,0 +1,16 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// abi_prefix.hpp
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+#include <boost/config/abi_prefix.hpp> // must be the last header
+#ifdef BOOST_MSVC
+#  pragma warning(push)
+#  pragma warning(disable : 4251 4231 4660 4275)
+#endif
+
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/detail/abi_suffix.hpp b/contrib/libboost/boost_1_65_0/boost/archive/detail/abi_suffix.hpp
new file mode 100644
index 00000000000..4e054d66214
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/archive/detail/abi_suffix.hpp
@@ -0,0 +1,15 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// abi_suffix.hpp
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+#include <boost/config/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/detail/archive_serializer_map.hpp b/contrib/libboost/boost_1_65_0/boost/archive/detail/archive_serializer_map.hpp
new file mode 100644
index 00000000000..5432bfc73e7
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/archive/detail/archive_serializer_map.hpp
@@ -0,0 +1,54 @@
+#ifndef BOOST_ARCHIVE_SERIALIZER_MAP_HPP
+#define BOOST_ARCHIVE_SERIALIZER_MAP_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// archive_serializer_map.hpp: extenstion of type_info required for 
+// serialization.
+
+// (C) Copyright 2009 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+// note: this is nothing more than the thinest of wrappers around
+// basic_serializer_map so we can have a one map / archive type. 
+
+#include <boost/config.hpp>
+#include <boost/archive/detail/auto_link_archive.hpp>
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+namespace boost {
+
+namespace serialization {
+    class extended_type_info;
+} // namespace serialization
+
+namespace archive {
+namespace detail {
+
+class basic_serializer;
+
+template<class Archive>
+class BOOST_SYMBOL_VISIBLE archive_serializer_map {
+public:
+    static BOOST_ARCHIVE_OR_WARCHIVE_DECL bool insert(const basic_serializer * bs);
+    static BOOST_ARCHIVE_OR_WARCHIVE_DECL void erase(const basic_serializer * bs);
+    static BOOST_ARCHIVE_OR_WARCHIVE_DECL const basic_serializer * find(
+        const boost::serialization::extended_type_info & type_
+    );
+};
+
+} // namespace detail
+} // namespace archive
+} // namespace boost
+
+#include <boost/archive/detail/abi_suffix.hpp> // must be the last header
+
+#endif //BOOST_ARCHIVE_SERIALIZER_MAP_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/detail/auto_link_archive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/detail/auto_link_archive.hpp
new file mode 100644
index 00000000000..79b0e490d65
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/archive/detail/auto_link_archive.hpp
@@ -0,0 +1,48 @@
+#ifndef BOOST_ARCHIVE_DETAIL_AUTO_LINK_ARCHIVE_HPP
+#define BOOST_ARCHIVE_DETAIL_AUTO_LINK_ARCHIVE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+//  auto_link_archive.hpp
+//
+//  (c) Copyright Robert Ramey 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)
+
+//  See library home page at http://www.boost.org/libs/serialization
+
+//----------------------------------------------------------------------------// 
+
+// This header implements separate compilation features as described in
+// http://www.boost.org/more/separate_compilation.html
+
+//  enable automatic library variant selection  ------------------------------// 
+
+#include <boost/archive/detail/decl.hpp>
+
+#if !defined(BOOST_ALL_NO_LIB) && !defined(BOOST_SERIALIZATION_NO_LIB) \
+&&  !defined(BOOST_ARCHIVE_SOURCE) && !defined(BOOST_WARCHIVE_SOURCE)  \
+&&  !defined(BOOST_SERIALIZATION_SOURCE)
+
+    // Set the name of our library, this will get undef'ed by auto_link.hpp
+    // once it's done with it:
+    //
+    #define BOOST_LIB_NAME boost_serialization
+    //
+    // If we're importing code from a dll, then tell auto_link.hpp about it:
+    //
+    #if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_SERIALIZATION_DYN_LINK)
+    #  define BOOST_DYN_LINK
+    #endif
+    //
+    // And include the header that does the work:
+    //
+    #include <boost/config/auto_link.hpp>
+#endif  // auto-linking disabled
+
+#endif // BOOST_ARCHIVE_DETAIL_AUTO_LINK_ARCHIVE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/detail/auto_link_warchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/detail/auto_link_warchive.hpp
new file mode 100644
index 00000000000..683d191c20d
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/archive/detail/auto_link_warchive.hpp
@@ -0,0 +1,47 @@
+#ifndef BOOST_ARCHIVE_DETAIL_AUTO_LINK_WARCHIVE_HPP
+#define BOOST_ARCHIVE_DETAIL_AUTO_LINK_WARCHIVE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+//  auto_link_warchive.hpp
+//
+//  (c) Copyright Robert Ramey 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)
+
+//  See library home page at http://www.boost.org/libs/serialization
+
+//----------------------------------------------------------------------------// 
+
+// This header implements separate compilation features as described in
+// http://www.boost.org/more/separate_compilation.html
+
+//  enable automatic library variant selection  ------------------------------// 
+
+#include <boost/archive/detail/decl.hpp>
+
+#if !defined(BOOST_WARCHIVE_SOURCE) \
+&& !defined(BOOST_ALL_NO_LIB) && !defined(BOOST_SERIALIZATION_NO_LIB)
+
+// Set the name of our library, this will get undef'ed by auto_link.hpp
+// once it's done with it:
+//
+#define BOOST_LIB_NAME boost_wserialization
+//
+// If we're importing code from a dll, then tell auto_link.hpp about it:
+//
+#if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_SERIALIZATION_DYN_LINK)
+#  define BOOST_DYN_LINK
+#endif
+//
+// And include the header that does the work:
+//
+#include <boost/config/auto_link.hpp>
+#endif  // auto-linking disabled
+
+#endif // ARCHIVE_DETAIL_AUTO_LINK_ARCHIVE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/detail/basic_iarchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/detail/basic_iarchive.hpp
new file mode 100644
index 00000000000..1f5a8bf63bf
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/archive/detail/basic_iarchive.hpp
@@ -0,0 +1,105 @@
+#ifndef BOOST_ARCHIVE_DETAIL_BASIC_IARCHIVE_HPP
+#define BOOST_ARCHIVE_DETAIL_BASIC_IARCHIVE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// basic_iarchive.hpp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+// can't use this - much as I'd like to as borland doesn't support it
+
+#include <boost/config.hpp>
+#include <boost/noncopyable.hpp>
+#include <boost/scoped_ptr.hpp>
+
+#include <boost/serialization/tracking_enum.hpp>
+#include <boost/archive/basic_archive.hpp>
+#include <boost/archive/detail/decl.hpp>
+#include <boost/archive/detail/helper_collection.hpp>
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+namespace boost {
+namespace serialization {
+    class extended_type_info;
+} // namespace serialization
+
+namespace archive {
+namespace detail {
+
+class basic_iarchive_impl;
+class basic_iserializer;
+class basic_pointer_iserializer;
+
+//////////////////////////////////////////////////////////////////////
+// class basic_iarchive - read serialized objects from a input stream
+class BOOST_SYMBOL_VISIBLE basic_iarchive :
+    private boost::noncopyable,
+    public boost::archive::detail::helper_collection
+{
+    friend class basic_iarchive_impl;
+    // hide implementation of this class to minimize header conclusion
+    boost::scoped_ptr<basic_iarchive_impl> pimpl;
+
+    virtual void vload(version_type &t) =  0;
+    virtual void vload(object_id_type &t) =  0;
+    virtual void vload(class_id_type &t) =  0;
+    virtual void vload(class_id_optional_type &t) = 0;
+    virtual void vload(class_name_type &t) = 0;
+    virtual void vload(tracking_type &t) = 0;
+protected:
+    BOOST_ARCHIVE_DECL basic_iarchive(unsigned int flags);
+    boost::archive::detail::helper_collection &
+    get_helper_collection(){
+        return *this;
+    }
+public:
+    // some msvc versions require that the following function be public
+    // otherwise it should really protected.
+    virtual BOOST_ARCHIVE_DECL ~basic_iarchive();
+    // note: NOT part of the public API.
+    BOOST_ARCHIVE_DECL void next_object_pointer(void *t);
+    BOOST_ARCHIVE_DECL void register_basic_serializer(
+        const basic_iserializer & bis
+    );
+    BOOST_ARCHIVE_DECL void load_object(
+        void *t, 
+        const basic_iserializer & bis
+    );
+    BOOST_ARCHIVE_DECL const basic_pointer_iserializer * 
+    load_pointer(
+        void * & t, 
+        const basic_pointer_iserializer * bpis_ptr,
+        const basic_pointer_iserializer * (*finder)(
+            const boost::serialization::extended_type_info & eti
+        )
+    );
+    // real public API starts here
+    BOOST_ARCHIVE_DECL void 
+    set_library_version(library_version_type archive_library_version);
+    BOOST_ARCHIVE_DECL library_version_type 
+    get_library_version() const;
+    BOOST_ARCHIVE_DECL unsigned int
+    get_flags() const;
+    BOOST_ARCHIVE_DECL void 
+    reset_object_address(const void * new_address, const void * old_address);
+    BOOST_ARCHIVE_DECL void 
+    delete_created_pointers();
+};
+
+} // namespace detail
+} // namespace archive
+} // namespace boost
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#endif //BOOST_ARCHIVE_DETAIL_BASIC_IARCHIVE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/detail/basic_iserializer.hpp b/contrib/libboost/boost_1_65_0/boost/archive/detail/basic_iserializer.hpp
new file mode 100644
index 00000000000..0d66674c349
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/archive/detail/basic_iserializer.hpp
@@ -0,0 +1,91 @@
+#ifndef BOOST_ARCHIVE_DETAIL_BASIC_ISERIALIZER_HPP
+#define BOOST_ARCHIVE_DETAIL_BASIC_ISERIALIZER_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// basic_iserializer.hpp: extenstion of type_info required for serialization.
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+#include <cstdlib> // NULL
+#include <boost/config.hpp>
+
+#include <boost/archive/basic_archive.hpp>
+#include <boost/archive/detail/decl.hpp>
+#include <boost/archive/detail/basic_serializer.hpp>
+#include <boost/archive/detail/auto_link_archive.hpp>
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+#ifdef BOOST_MSVC
+#  pragma warning(push)
+#  pragma warning(disable : 4511 4512)
+#endif
+
+namespace boost {
+namespace serialization {
+    class extended_type_info;
+} // namespace serialization
+
+// forward declarations
+namespace archive {
+namespace detail {
+
+class basic_iarchive;
+class basic_pointer_iserializer;
+
+class BOOST_SYMBOL_VISIBLE basic_iserializer : 
+    public basic_serializer
+{
+private:
+    basic_pointer_iserializer *m_bpis;
+protected:
+    explicit BOOST_ARCHIVE_DECL basic_iserializer(
+        const boost::serialization::extended_type_info & type
+    );
+    virtual BOOST_ARCHIVE_DECL ~basic_iserializer();
+public:
+    bool serialized_as_pointer() const {
+        return m_bpis != NULL;
+    }
+    void set_bpis(basic_pointer_iserializer *bpis){
+        m_bpis = bpis;
+    }
+    const basic_pointer_iserializer * get_bpis_ptr() const {
+        return m_bpis;
+    }
+    virtual void load_object_data(
+        basic_iarchive & ar, 
+        void *x,
+        const unsigned int file_version
+    ) const = 0;
+    // returns true if class_info should be saved
+    virtual bool class_info() const = 0 ;
+    // returns true if objects should be tracked
+    virtual bool tracking(const unsigned int) const = 0 ;
+    // returns class version
+    virtual version_type version() const = 0 ;
+    // returns true if this class is polymorphic
+    virtual bool is_polymorphic() const = 0;
+    virtual void destroy(/*const*/ void *address) const = 0 ;
+};
+
+} // namespae detail
+} // namespace archive
+} // namespace boost
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#endif // BOOST_ARCHIVE_DETAIL_BASIC_ISERIALIZER_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/detail/basic_oarchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/detail/basic_oarchive.hpp
new file mode 100644
index 00000000000..c379108d584
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/archive/detail/basic_oarchive.hpp
@@ -0,0 +1,94 @@
+#ifndef BOOST_ARCHIVE_BASIC_OARCHIVE_HPP
+#define BOOST_ARCHIVE_BASIC_OARCHIVE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// basic_oarchive.hpp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+#include <cstddef> // NULL
+#include <boost/config.hpp>
+#include <boost/noncopyable.hpp>
+#include <boost/scoped_ptr.hpp>
+
+#include <boost/archive/basic_archive.hpp>
+#include <boost/serialization/tracking_enum.hpp>
+#include <boost/archive/detail/helper_collection.hpp>
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+namespace boost {
+namespace serialization {
+    class extended_type_info;
+} // namespace serialization
+
+namespace archive {
+namespace detail {
+
+class basic_oarchive_impl;
+class basic_oserializer;
+class basic_pointer_oserializer;
+
+//////////////////////////////////////////////////////////////////////
+// class basic_oarchive - write serialized objects to an output stream
+class BOOST_SYMBOL_VISIBLE basic_oarchive :
+    private boost::noncopyable,
+    public boost::archive::detail::helper_collection
+{
+    friend class basic_oarchive_impl;
+    // hide implementation of this class to minimize header conclusion
+    boost::scoped_ptr<basic_oarchive_impl> pimpl;
+
+    // overload these to bracket object attributes. Used to implement
+    // xml archives
+    virtual void vsave(const version_type t) =  0;
+    virtual void vsave(const object_id_type t) =  0;
+    virtual void vsave(const object_reference_type t) =  0;
+    virtual void vsave(const class_id_type t) =  0;
+    virtual void vsave(const class_id_optional_type t) = 0;
+    virtual void vsave(const class_id_reference_type t) =  0;
+    virtual void vsave(const class_name_type & t) = 0;
+    virtual void vsave(const tracking_type t) = 0;
+protected:
+    BOOST_ARCHIVE_DECL basic_oarchive(unsigned int flags = 0);
+    BOOST_ARCHIVE_DECL boost::archive::detail::helper_collection &
+    get_helper_collection();
+    virtual BOOST_ARCHIVE_DECL ~basic_oarchive();
+public:
+    // note: NOT part of the public interface
+    BOOST_ARCHIVE_DECL void register_basic_serializer(
+        const basic_oserializer & bos
+    );
+    BOOST_ARCHIVE_DECL void save_object(
+        const void *x, 
+        const basic_oserializer & bos
+    );
+    BOOST_ARCHIVE_DECL void save_pointer(
+        const void * t, 
+        const basic_pointer_oserializer * bpos_ptr
+    );
+    void save_null_pointer(){
+        vsave(NULL_POINTER_TAG);
+    }
+    // real public interface starts here
+    BOOST_ARCHIVE_DECL void end_preamble(); // default implementation does nothing
+    BOOST_ARCHIVE_DECL library_version_type get_library_version() const;
+    BOOST_ARCHIVE_DECL unsigned int get_flags() const;
+};
+
+} // namespace detail
+} // namespace archive
+} // namespace boost
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#endif //BOOST_ARCHIVE_BASIC_OARCHIVE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/detail/basic_oserializer.hpp b/contrib/libboost/boost_1_65_0/boost/archive/detail/basic_oserializer.hpp
new file mode 100644
index 00000000000..94247e90056
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/archive/detail/basic_oserializer.hpp
@@ -0,0 +1,89 @@
+#ifndef BOOST_SERIALIZATION_BASIC_OSERIALIZER_HPP
+#define BOOST_SERIALIZATION_BASIC_OSERIALIZER_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// basic_oserializer.hpp: extenstion of type_info required for serialization.
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+#include <cstddef> // NULL
+#include <boost/config.hpp>
+#include <boost/noncopyable.hpp>
+
+#include <boost/archive/basic_archive.hpp>
+#include <boost/archive/detail/auto_link_archive.hpp>
+#include <boost/archive/detail/basic_serializer.hpp>
+
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+#ifdef BOOST_MSVC
+#  pragma warning(push)
+#  pragma warning(disable : 4511 4512)
+#endif
+
+namespace boost {
+namespace serialization {
+    class extended_type_info;
+} // namespace serialization
+
+// forward declarations
+namespace archive {
+namespace detail {
+
+class basic_oarchive;
+class basic_pointer_oserializer;
+
+class BOOST_SYMBOL_VISIBLE basic_oserializer :
+    public basic_serializer
+{
+private:
+    basic_pointer_oserializer *m_bpos;
+protected:
+    explicit BOOST_ARCHIVE_DECL basic_oserializer(
+        const boost::serialization::extended_type_info & type_
+    );
+    virtual BOOST_ARCHIVE_DECL ~basic_oserializer();
+public:
+    bool serialized_as_pointer() const {
+        return m_bpos != NULL;
+    }
+    void set_bpos(basic_pointer_oserializer *bpos){
+        m_bpos = bpos;
+    }
+    const basic_pointer_oserializer * get_bpos() const {
+        return m_bpos;
+    }
+    virtual void save_object_data(
+        basic_oarchive & ar, const void * x
+    ) const = 0;
+    // returns true if class_info should be saved
+    virtual bool class_info() const = 0;
+    // returns true if objects should be tracked
+    virtual bool tracking(const unsigned int flags) const = 0;
+    // returns class version
+    virtual version_type version() const = 0;
+    // returns true if this class is polymorphic
+    virtual bool is_polymorphic() const = 0;
+};
+
+} // namespace detail
+} // namespace serialization
+} // namespace boost
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#endif // BOOST_SERIALIZATION_BASIC_OSERIALIZER_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/detail/basic_pointer_iserializer.hpp b/contrib/libboost/boost_1_65_0/boost/archive/detail/basic_pointer_iserializer.hpp
new file mode 100644
index 00000000000..1fc4b14d6e9
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/archive/detail/basic_pointer_iserializer.hpp
@@ -0,0 +1,70 @@
+#ifndef BOOST_ARCHIVE_BASIC_POINTER_ISERIALIZER_HPP
+#define BOOST_ARCHIVE_BASIC_POINTER_ISERIALIZER_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// basic_pointer_oserializer.hpp: extenstion of type_info required for 
+// serialization.
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+#include <boost/config.hpp>
+#include <boost/noncopyable.hpp>
+#include <boost/archive/detail/auto_link_archive.hpp>
+#include <boost/archive/detail/basic_serializer.hpp>
+
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+#ifdef BOOST_MSVC
+#  pragma warning(push)
+#  pragma warning(disable : 4511 4512)
+#endif
+
+namespace boost {
+namespace serialization {
+    class extended_type_info;
+} // namespace serialization
+
+// forward declarations
+namespace archive {
+namespace detail {
+
+class basic_iarchive;
+class basic_iserializer;
+
+class BOOST_SYMBOL_VISIBLE basic_pointer_iserializer
+    : public basic_serializer {
+protected:
+    explicit BOOST_ARCHIVE_DECL basic_pointer_iserializer(
+        const boost::serialization::extended_type_info & type_
+    );
+    virtual BOOST_ARCHIVE_DECL ~basic_pointer_iserializer();
+public:
+    virtual void * heap_allocation() const = 0;
+    virtual const basic_iserializer & get_basic_serializer() const = 0;
+    virtual void load_object_ptr(
+        basic_iarchive & ar, 
+        void * x,
+        const unsigned int file_version
+    ) const = 0;
+};
+
+} // namespace detail
+} // namespace archive
+} // namespace boost
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#endif // BOOST_ARCHIVE_BASIC_POINTER_ISERIALIZER_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/detail/basic_pointer_oserializer.hpp b/contrib/libboost/boost_1_65_0/boost/archive/detail/basic_pointer_oserializer.hpp
new file mode 100644
index 00000000000..1a5d9549eab
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/archive/detail/basic_pointer_oserializer.hpp
@@ -0,0 +1,68 @@
+#ifndef BOOST_ARCHIVE_BASIC_POINTER_OSERIALIZER_HPP
+#define BOOST_ARCHIVE_BASIC_POINTER_OSERIALIZER_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// basic_pointer_oserializer.hpp: extenstion of type_info required for 
+// serialization.
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+#include <boost/config.hpp>
+#include <boost/noncopyable.hpp>
+#include <boost/archive/detail/auto_link_archive.hpp>
+#include <boost/archive/detail/basic_serializer.hpp>
+
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+#ifdef BOOST_MSVC
+#  pragma warning(push)
+#  pragma warning(disable : 4511 4512)
+#endif
+
+namespace boost {
+namespace serialization {
+    class extended_type_info;
+} // namespace serialization
+
+namespace archive {
+namespace detail {
+
+class basic_oarchive;
+class basic_oserializer;
+
+class BOOST_SYMBOL_VISIBLE basic_pointer_oserializer : 
+    public basic_serializer
+{
+protected:
+    explicit BOOST_ARCHIVE_DECL basic_pointer_oserializer(
+        const boost::serialization::extended_type_info & type_
+    );
+public:
+    virtual BOOST_ARCHIVE_DECL ~basic_pointer_oserializer();
+    virtual const basic_oserializer & get_basic_serializer() const = 0;
+    virtual void save_object_ptr(
+        basic_oarchive & ar,
+        const void * x
+    ) const = 0;
+};
+
+} // namespace detail
+} // namespace archive
+} // namespace boost
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#endif // BOOST_ARCHIVE_BASIC_POINTER_OSERIALIZER_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/detail/basic_serializer.hpp b/contrib/libboost/boost_1_65_0/boost/archive/detail/basic_serializer.hpp
new file mode 100644
index 00000000000..f9c4203f862
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/archive/detail/basic_serializer.hpp
@@ -0,0 +1,77 @@
+#ifndef  BOOST_ARCHIVE_BASIC_SERIALIZER_HPP
+#define BOOST_ARCHIVE_BASIC_SERIALIZER_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// basic_serializer.hpp: extenstion of type_info required for serialization.
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+#include <boost/assert.hpp>
+#include <cstddef> // NULL
+
+#include <boost/noncopyable.hpp>
+#include <boost/config.hpp>
+#include <boost/serialization/extended_type_info.hpp>
+
+#ifdef BOOST_MSVC
+#  pragma warning(push)
+#  pragma warning(disable : 4511 4512)
+#endif
+
+namespace boost {
+namespace archive {
+namespace detail {
+
+class basic_serializer : 
+    private boost::noncopyable
+{
+    const boost::serialization::extended_type_info * m_eti;
+protected:
+    explicit basic_serializer(
+        const boost::serialization::extended_type_info & eti
+    ) : 
+        m_eti(& eti)
+    {}
+public:
+    inline bool 
+    operator<(const basic_serializer & rhs) const {
+        // can't compare address since there can be multiple eti records
+        // for the same type in different execution modules (that is, DLLS)
+        // leave this here as a reminder not to do this!
+        // return & lhs.get_eti() < & rhs.get_eti();
+        return get_eti() < rhs.get_eti();
+    }
+    const char * get_debug_info() const {
+        return m_eti->get_debug_info();
+    }
+    const boost::serialization::extended_type_info & get_eti() const {
+        return * m_eti;
+    }
+};
+
+class basic_serializer_arg : public basic_serializer {
+public:
+    basic_serializer_arg(const serialization::extended_type_info & eti) :
+        basic_serializer(eti)
+    {}
+};
+
+} // namespace detail
+} // namespace archive
+} // namespace boost
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+#endif // BOOST_ARCHIVE_BASIC_SERIALIZER_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/detail/basic_serializer_map.hpp b/contrib/libboost/boost_1_65_0/boost/archive/detail/basic_serializer_map.hpp
new file mode 100644
index 00000000000..79341803367
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/archive/detail/basic_serializer_map.hpp
@@ -0,0 +1,69 @@
+#ifndef  BOOST_SERIALIZER_MAP_HPP
+#define BOOST_SERIALIZER_MAP_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// basic_serializer_map.hpp: extenstion of type_info required for serialization.
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+#include <set>
+
+#include <boost/config.hpp>
+#include <boost/noncopyable.hpp>
+#include <boost/archive/detail/auto_link_archive.hpp>
+
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+namespace boost { 
+namespace serialization {
+    class extended_type_info;
+}
+
+namespace archive {
+namespace detail {
+
+class basic_serializer;
+
+class BOOST_SYMBOL_VISIBLE
+basic_serializer_map : public
+    boost::noncopyable
+{
+    struct type_info_pointer_compare
+    {
+        bool operator()(
+            const basic_serializer * lhs, const basic_serializer * rhs
+        ) const ;
+    };
+    typedef std::set<
+        const basic_serializer *, 
+        type_info_pointer_compare
+    > map_type;
+    map_type m_map;
+public:
+    BOOST_ARCHIVE_DECL bool insert(const basic_serializer * bs);
+    BOOST_ARCHIVE_DECL void erase(const basic_serializer * bs);
+    BOOST_ARCHIVE_DECL const basic_serializer * find(
+        const boost::serialization::extended_type_info & type_
+    ) const;
+private:
+    // cw 8.3 requires this
+    basic_serializer_map& operator=(basic_serializer_map const&);
+};
+
+} // namespace detail
+} // namespace archive
+} // namespace boost
+
+#include <boost/archive/detail/abi_suffix.hpp> // must be the last header
+
+#endif // BOOST_SERIALIZER_MAP_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/detail/check.hpp b/contrib/libboost/boost_1_65_0/boost/archive/detail/check.hpp
new file mode 100644
index 00000000000..10034e7d101
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/archive/detail/check.hpp
@@ -0,0 +1,169 @@
+#ifndef BOOST_ARCHIVE_DETAIL_CHECK_HPP
+#define BOOST_ARCHIVE_DETAIL_CHECK_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#pragma inline_depth(511)
+#pragma inline_recursion(on)
+#endif
+
+#if defined(__MWERKS__)
+#pragma inline_depth(511)
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// check.hpp: interface for serialization system.
+
+// (C) Copyright 2009 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+#include <boost/config.hpp>
+
+#include <boost/static_assert.hpp>
+#include <boost/type_traits/is_const.hpp>
+
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/or.hpp>
+#include <boost/mpl/equal_to.hpp>
+#include <boost/mpl/int.hpp>
+#include <boost/mpl/not.hpp>
+#include <boost/mpl/greater.hpp>
+#include <boost/mpl/assert.hpp>
+
+#include <boost/serialization/static_warning.hpp>
+#include <boost/serialization/version.hpp>
+#include <boost/serialization/level.hpp>
+#include <boost/serialization/tracking.hpp>
+#include <boost/serialization/wrapper.hpp>
+
+namespace boost {
+namespace archive {
+namespace detail {
+
+// checks for objects
+
+template<class T>
+inline void check_object_level(){
+    typedef 
+        typename mpl::greater_equal<
+            serialization::implementation_level< T >,
+            mpl::int_<serialization::primitive_type>
+        >::type typex;
+
+    // trap attempts to serialize objects marked
+    // not_serializable
+    BOOST_STATIC_ASSERT(typex::value);
+}
+
+template<class T>
+inline void check_object_versioning(){
+    typedef 
+        typename mpl::or_<
+            typename mpl::greater<
+                serialization::implementation_level< T >,
+                mpl::int_<serialization::object_serializable>
+            >,
+            typename mpl::equal_to<
+                serialization::version< T >,
+                mpl::int_<0>
+            >
+        > typex;
+    // trap attempts to serialize with objects that don't
+    // save class information in the archive with versioning.
+    BOOST_STATIC_ASSERT(typex::value);
+}
+
+template<class T>
+inline void check_object_tracking(){
+    // presume it has already been determined that
+    // T is not a const
+    BOOST_STATIC_ASSERT(! boost::is_const< T >::value);
+    typedef typename mpl::equal_to<
+        serialization::tracking_level< T >,
+        mpl::int_<serialization::track_never>
+    >::type typex;
+    // saving an non-const object of a type not marked "track_never)
+
+    // may be an indicator of an error usage of the
+    // serialization library and should be double checked.  
+    // See documentation on object tracking.  Also, see the 
+    // "rationale" section of the documenation
+    // for motivation for this checking.
+
+    BOOST_STATIC_WARNING(typex::value);
+}
+
+// checks for pointers
+
+template<class T>
+inline void check_pointer_level(){
+    // we should only invoke this once we KNOW that T
+    // has been used as a pointer!!
+    typedef 
+        typename mpl::or_<
+            typename mpl::greater<
+                serialization::implementation_level< T >,
+                mpl::int_<serialization::object_serializable>
+            >,
+            typename mpl::not_<
+                typename mpl::equal_to<
+                    serialization::tracking_level< T >,
+                    mpl::int_<serialization::track_selectively>
+                >
+            >
+        > typex;
+    // Address the following when serializing to a pointer:
+
+    // a) This type doesn't save class information in the
+    // archive. That is, the serialization trait implementation
+    // level <= object_serializable.
+    // b) Tracking for this type is set to "track selectively"
+
+    // in this case, indication that an object is tracked is
+    // not stored in the archive itself - see level == object_serializable
+    // but rather the existence of the operation ar >> T * is used to 
+    // infer that an object of this type should be tracked.  So, if
+    // you save via a pointer but don't load via a pointer the operation
+    // will fail on load without given any valid reason for the failure.
+
+    // So if your program traps here, consider changing the 
+    // tracking or implementation level traits - or not
+    // serializing via a pointer.
+    BOOST_STATIC_WARNING(typex::value);
+}
+
+template<class T>
+void inline check_pointer_tracking(){
+    typedef typename mpl::greater<
+        serialization::tracking_level< T >,
+        mpl::int_<serialization::track_never>
+    >::type typex;
+    // serializing an object of a type marked "track_never" through a pointer
+    // could result in creating more objects than were saved!
+    BOOST_STATIC_WARNING(typex::value);
+}
+
+template<class T>
+inline void check_const_loading(){
+    typedef
+        typename mpl::or_<
+            typename boost::serialization::is_wrapper< T >,
+            typename mpl::not_<
+                typename boost::is_const< T >
+            >
+        >::type typex;
+    // cannot load data into a "const" object unless it's a
+    // wrapper around some other non-const object.
+    BOOST_STATIC_ASSERT(typex::value);
+}
+
+} // detail
+} // archive
+} // boost
+
+#endif // BOOST_ARCHIVE_DETAIL_CHECK_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/detail/common_iarchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/detail/common_iarchive.hpp
new file mode 100644
index 00000000000..82304f1e5ac
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/archive/detail/common_iarchive.hpp
@@ -0,0 +1,88 @@
+#ifndef BOOST_ARCHIVE_DETAIL_COMMON_IARCHIVE_HPP
+#define BOOST_ARCHIVE_DETAIL_COMMON_IARCHIVE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// common_iarchive.hpp
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+#include <boost/config.hpp>
+
+#include <boost/archive/detail/basic_iarchive.hpp>
+#include <boost/archive/detail/basic_pointer_iserializer.hpp>
+#include <boost/archive/detail/interface_iarchive.hpp>
+
+#ifdef BOOST_MSVC
+#  pragma warning(push)
+#  pragma warning(disable : 4511 4512)
+#endif
+
+namespace boost {
+namespace archive {
+namespace detail {
+
+class extended_type_info;
+
+// note: referred to as Curiously Recurring Template Patter (CRTP)
+template<class Archive>
+class BOOST_SYMBOL_VISIBLE common_iarchive : 
+    public basic_iarchive,
+    public interface_iarchive<Archive>
+{
+    friend class interface_iarchive<Archive>;
+private:
+    virtual void vload(version_type & t){
+        * this->This() >> t; 
+    }
+    virtual void vload(object_id_type & t){
+        * this->This() >> t;
+    }
+    virtual void vload(class_id_type & t){
+        * this->This() >> t;
+    }
+    virtual void vload(class_id_optional_type & t){
+        * this->This() >> t;
+    }
+    virtual void vload(tracking_type & t){
+        * this->This() >> t;
+    }
+    virtual void vload(class_name_type &s){
+        * this->This() >> s;
+    }
+protected:
+    // default processing - invoke serialization library
+    template<class T>
+    void load_override(T & t){
+        archive::load(* this->This(), t);
+    }
+    // default implementations of functions which emit start/end tags for
+    // archive types that require them.
+    void load_start(const char * /*name*/){}
+    void load_end(const char * /*name*/){}
+    // default archive initialization
+    common_iarchive(unsigned int flags = 0) : 
+        basic_iarchive(flags),
+        interface_iarchive<Archive>()
+    {}
+};
+
+} // namespace detail
+} // namespace archive
+} // namespace boost
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+#endif // BOOST_ARCHIVE_DETAIL_COMMON_IARCHIVE_HPP
+
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/detail/common_oarchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/detail/common_oarchive.hpp
new file mode 100644
index 00000000000..ee42bbe5976
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/archive/detail/common_oarchive.hpp
@@ -0,0 +1,88 @@
+#ifndef BOOST_ARCHIVE_DETAIL_COMMON_OARCHIVE_HPP
+#define BOOST_ARCHIVE_DETAIL_COMMON_OARCHIVE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// common_oarchive.hpp
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+#include <boost/config.hpp>
+
+#include <boost/archive/detail/basic_oarchive.hpp>
+#include <boost/archive/detail/interface_oarchive.hpp>
+
+#ifdef BOOST_MSVC
+#  pragma warning(push)
+#  pragma warning(disable : 4511 4512)
+#endif
+
+namespace boost {
+namespace archive {
+namespace detail {
+
+// note: referred to as Curiously Recurring Template Patter (CRTP)
+template<class Archive>
+
+class BOOST_SYMBOL_VISIBLE common_oarchive :
+    public basic_oarchive,
+    public interface_oarchive<Archive>
+{
+    friend class interface_oarchive<Archive>;
+private:
+    virtual void vsave(const version_type t){
+        * this->This() << t;
+    }
+    virtual void vsave(const object_id_type t){
+        * this->This() << t;
+    }
+    virtual void vsave(const object_reference_type t){
+        * this->This() << t;
+    }
+    virtual void vsave(const class_id_type t){
+        * this->This() << t;
+    }
+    virtual void vsave(const class_id_reference_type t){
+        * this->This() << t;
+    }
+    virtual void vsave(const class_id_optional_type t){
+        * this->This() << t;
+    }
+    virtual void vsave(const class_name_type & t){
+        * this->This() << t;
+    }
+    virtual void vsave(const tracking_type t){
+        * this->This() << t;
+    }
+protected:
+    // default processing - invoke serialization library
+    template<class T>
+    void save_override(T & t){
+        archive::save(* this->This(), t);
+    }
+    void save_start(const char * /*name*/){}
+    void save_end(const char * /*name*/){}
+    common_oarchive(unsigned int flags = 0) : 
+        basic_oarchive(flags),
+        interface_oarchive<Archive>()
+    {}
+};
+
+} // namespace detail
+} // namespace archive
+} // namespace boost
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+#endif // BOOST_ARCHIVE_DETAIL_COMMON_OARCHIVE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/detail/decl.hpp b/contrib/libboost/boost_1_65_0/boost/archive/detail/decl.hpp
new file mode 100644
index 00000000000..4f731cded37
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/archive/detail/decl.hpp
@@ -0,0 +1,57 @@
+#ifndef BOOST_ARCHIVE_DETAIL_DECL_HPP
+#define BOOST_ARCHIVE_DETAIL_DECL_HPP 
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif 
+
+/////////1/////////2///////// 3/////////4/////////5/////////6/////////7/////////8
+//  decl.hpp
+//
+//  (c) Copyright Robert Ramey 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)
+
+//  See library home page at http://www.boost.org/libs/serialization
+
+//----------------------------------------------------------------------------// 
+
+// This header implements separate compilation features as described in
+// http://www.boost.org/more/separate_compilation.html
+
+#include <boost/config.hpp>
+
+#if (defined(BOOST_ALL_DYN_LINK) || defined(BOOST_SERIALIZATION_DYN_LINK))
+    #if defined(BOOST_ARCHIVE_SOURCE)
+        #define BOOST_ARCHIVE_DECL BOOST_SYMBOL_EXPORT
+    #else
+        #define BOOST_ARCHIVE_DECL BOOST_SYMBOL_IMPORT
+    #endif
+
+    #if defined(BOOST_WARCHIVE_SOURCE)
+        #define BOOST_WARCHIVE_DECL BOOST_SYMBOL_EXPORT
+    #else
+        #define BOOST_WARCHIVE_DECL BOOST_SYMBOL_IMPORT
+    #endif
+
+    #if defined(BOOST_WARCHIVE_SOURCE) || defined(BOOST_ARCHIVE_SOURCE)
+        #define BOOST_ARCHIVE_OR_WARCHIVE_DECL BOOST_SYMBOL_EXPORT
+    #else
+        #define BOOST_ARCHIVE_OR_WARCHIVE_DECL BOOST_SYMBOL_IMPORT
+    #endif
+
+#endif
+
+#if ! defined(BOOST_ARCHIVE_DECL)
+    #define BOOST_ARCHIVE_DECL
+#endif
+#if ! defined(BOOST_WARCHIVE_DECL)
+    #define BOOST_WARCHIVE_DECL
+#endif
+#if ! defined(BOOST_ARCHIVE_OR_WARCHIVE_DECL)
+    #define BOOST_ARCHIVE_OR_WARCHIVE_DECL
+#endif
+
+#endif // BOOST_ARCHIVE_DETAIL_DECL_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/detail/helper_collection.hpp b/contrib/libboost/boost_1_65_0/boost/archive/detail/helper_collection.hpp
new file mode 100644
index 00000000000..edb4125e308
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/archive/detail/helper_collection.hpp
@@ -0,0 +1,99 @@
+#ifndef BOOST_ARCHIVE_DETAIL_HELPER_COLLECTION_HPP
+#define BOOST_ARCHIVE_DETAIL_HELPER_COLLECTION_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// helper_collection.hpp: archive support for run-time helpers
+
+// (C) Copyright 2002-2008 Robert Ramey and Joaquin M Lopez Munoz
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+#include <cstddef> // NULL
+#include <vector>
+#include <utility>
+#include <memory>
+#include <algorithm>
+
+#include <boost/config.hpp>
+
+#include <boost/smart_ptr/shared_ptr.hpp>
+#include <boost/smart_ptr/make_shared.hpp>
+
+namespace boost {
+
+namespace archive {
+namespace detail {
+
+class helper_collection
+{
+    helper_collection(const helper_collection&);              // non-copyable
+    helper_collection& operator = (const helper_collection&); // non-copyable
+
+    // note: we dont' actually "share" the function object pointer
+    // we only use shared_ptr to make sure that it get's deleted
+
+    typedef std::pair<
+        const void *,
+        boost::shared_ptr<void>
+    > helper_value_type;
+    template<class T>
+    boost::shared_ptr<void> make_helper_ptr(){
+        // use boost::shared_ptr rather than std::shared_ptr to maintain
+        // c++03 compatibility
+        return boost::make_shared<T>();
+    }
+
+    typedef std::vector<helper_value_type> collection;
+    collection m_collection;
+
+    struct predicate {
+        BOOST_DELETED_FUNCTION(predicate & operator=(const predicate & rhs))
+    public:
+        const void * const m_ti;
+        bool operator()(helper_value_type const &rhs) const {
+            return m_ti == rhs.first;
+        }
+        predicate(const void * ti) :
+            m_ti(ti)
+        {}
+    };
+protected:
+    helper_collection(){}
+    ~helper_collection(){}
+public:
+    template<typename Helper>
+    Helper& find_helper(void * const id = 0) {
+        collection::const_iterator it =
+            std::find_if(
+                m_collection.begin(),
+                m_collection.end(),
+                predicate(id)
+            );
+
+        void * rval = 0;
+        if(it == m_collection.end()){
+            m_collection.push_back(
+                std::make_pair(id, make_helper_ptr<Helper>())
+            );
+            rval = m_collection.back().second.get();
+        }
+        else{
+            rval = it->second.get();
+        }
+        return *static_cast<Helper *>(rval);
+    }
+};
+
+} // namespace detail
+} // namespace serialization
+} // namespace boost
+
+#endif // BOOST_ARCHIVE_DETAIL_HELPER_COLLECTION_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/detail/interface_iarchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/detail/interface_iarchive.hpp
new file mode 100644
index 00000000000..4a99e28b59f
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/archive/detail/interface_iarchive.hpp
@@ -0,0 +1,85 @@
+#ifndef BOOST_ARCHIVE_DETAIL_INTERFACE_IARCHIVE_HPP
+#define BOOST_ARCHIVE_DETAIL_INTERFACE_IARCHIVE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// interface_iarchive.hpp
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+#include <cstddef> // NULL
+#include <boost/cstdint.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/archive/detail/auto_link_archive.hpp>
+#include <boost/archive/detail/iserializer.hpp>
+#include <boost/archive/detail/helper_collection.hpp>
+#include <boost/serialization/singleton.hpp>
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+namespace boost {
+namespace archive {
+namespace detail {
+
+class basic_pointer_iserializer;
+
+template<class Archive>
+class interface_iarchive 
+{
+protected:
+    interface_iarchive(){};
+public:
+    /////////////////////////////////////////////////////////
+    // archive public interface
+    typedef mpl::bool_<true> is_loading;
+    typedef mpl::bool_<false> is_saving;
+
+    // return a pointer to the most derived class
+    Archive * This(){
+        return static_cast<Archive *>(this);
+    }
+
+    template<class T>
+    const basic_pointer_iserializer * 
+    register_type(T * = NULL){
+        const basic_pointer_iserializer & bpis =
+            boost::serialization::singleton<
+                pointer_iserializer<Archive, T> 
+            >::get_const_instance();
+        this->This()->register_basic_serializer(bpis.get_basic_serializer());
+        return & bpis;
+    }
+    template<class Helper>
+    Helper &
+    get_helper(void * const id = 0){
+        helper_collection & hc = this->This()->get_helper_collection();
+        return hc.template find_helper<Helper>(id);
+    }
+    
+    template<class T>
+    Archive & operator>>(T & t){
+        this->This()->load_override(t);
+        return * this->This();
+    }
+
+    // the & operator 
+    template<class T>
+    Archive & operator&(T & t){
+        return *(this->This()) >> t;
+    }
+};
+
+} // namespace detail
+} // namespace archive
+} // namespace boost
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#endif // BOOST_ARCHIVE_DETAIL_INTERFACE_IARCHIVE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/detail/interface_oarchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/detail/interface_oarchive.hpp
new file mode 100644
index 00000000000..359463ed9d8
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/archive/detail/interface_oarchive.hpp
@@ -0,0 +1,87 @@
+#ifndef BOOST_ARCHIVE_DETAIL_INTERFACE_OARCHIVE_HPP
+#define BOOST_ARCHIVE_DETAIL_INTERFACE_OARCHIVE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// interface_oarchive.hpp
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+#include <cstddef> // NULL
+#include <boost/cstdint.hpp>
+#include <boost/mpl/bool.hpp>
+
+#include <boost/archive/detail/auto_link_archive.hpp>
+#include <boost/archive/detail/oserializer.hpp>
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+#include <boost/serialization/singleton.hpp>
+
+namespace boost {
+namespace archive {
+namespace detail {
+
+class basic_pointer_oserializer;
+
+template<class Archive>
+class interface_oarchive 
+{
+protected:
+    interface_oarchive(){};
+public:
+    /////////////////////////////////////////////////////////
+    // archive public interface
+    typedef mpl::bool_<false> is_loading;
+    typedef mpl::bool_<true> is_saving;
+
+    // return a pointer to the most derived class
+    Archive * This(){
+        return static_cast<Archive *>(this);
+    }
+
+    template<class T>
+    const basic_pointer_oserializer * 
+    register_type(const T * = NULL){
+        const basic_pointer_oserializer & bpos =
+            boost::serialization::singleton<
+                pointer_oserializer<Archive, T>
+            >::get_const_instance();
+        this->This()->register_basic_serializer(bpos.get_basic_serializer());
+        return & bpos;
+    }
+    
+    template<class Helper>
+    Helper &
+    get_helper(void * const id = 0){
+        helper_collection & hc = this->This()->get_helper_collection();
+        return hc.template find_helper<Helper>(id);
+    }
+
+    template<class T>
+    Archive & operator<<(const T & t){
+        this->This()->save_override(t);
+        return * this->This();
+    }
+    
+    // the & operator 
+    template<class T>
+    Archive & operator&(const T & t){
+        return * this ->This() << t;
+    }
+};
+
+} // namespace detail
+} // namespace archive
+} // namespace boost
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#endif // BOOST_ARCHIVE_DETAIL_INTERFACE_IARCHIVE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/detail/iserializer.hpp b/contrib/libboost/boost_1_65_0/boost/archive/detail/iserializer.hpp
new file mode 100644
index 00000000000..193e98a82e4
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/archive/detail/iserializer.hpp
@@ -0,0 +1,631 @@
+#ifndef BOOST_ARCHIVE_DETAIL_ISERIALIZER_HPP
+#define BOOST_ARCHIVE_DETAIL_ISERIALIZER_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#pragma inline_depth(511)
+#pragma inline_recursion(on)
+#endif
+
+#if defined(__MWERKS__)
+#pragma inline_depth(511)
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// iserializer.hpp: interface for serialization system.
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+#include <new>     // for placement new
+#include <cstddef> // size_t, NULL
+
+#include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{ 
+    using ::size_t; 
+} // namespace std
+#endif
+
+#include <boost/static_assert.hpp>
+
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/identity.hpp>
+#include <boost/mpl/greater_equal.hpp>
+#include <boost/mpl/equal_to.hpp>
+#include <boost/core/no_exceptions_support.hpp>
+
+#ifndef BOOST_SERIALIZATION_DEFAULT_TYPE_INFO   
+    #include <boost/serialization/extended_type_info_typeid.hpp>   
+#endif
+#include <boost/serialization/throw_exception.hpp>
+#include <boost/serialization/smart_cast.hpp>
+#include <boost/serialization/static_warning.hpp>
+
+#include <boost/type_traits/is_pointer.hpp>
+#include <boost/type_traits/is_enum.hpp>
+#include <boost/type_traits/is_const.hpp>
+#include <boost/type_traits/remove_const.hpp>
+#include <boost/type_traits/remove_extent.hpp>
+#include <boost/type_traits/is_polymorphic.hpp>
+
+#include <boost/serialization/assume_abstract.hpp>
+
+#ifndef BOOST_MSVC
+    #define DONT_USE_HAS_NEW_OPERATOR (                    \
+           BOOST_WORKAROUND(__IBMCPP__, < 1210)            \
+        || defined(__SUNPRO_CC) && (__SUNPRO_CC < 0x590)   \
+    )
+#else
+    #define DONT_USE_HAS_NEW_OPERATOR 0
+#endif
+
+#if ! DONT_USE_HAS_NEW_OPERATOR
+#include <boost/type_traits/has_new_operator.hpp>
+#endif
+
+#include <boost/serialization/serialization.hpp>
+#include <boost/serialization/version.hpp>
+#include <boost/serialization/level.hpp>
+#include <boost/serialization/tracking.hpp>
+#include <boost/serialization/type_info_implementation.hpp>
+#include <boost/serialization/nvp.hpp>
+#include <boost/serialization/void_cast.hpp>
+#include <boost/serialization/collection_size_type.hpp>
+#include <boost/serialization/singleton.hpp>
+#include <boost/serialization/wrapper.hpp>
+#include <boost/serialization/array_wrapper.hpp>
+
+// the following is need only for dynamic cast of polymorphic pointers
+#include <boost/archive/archive_exception.hpp>
+#include <boost/archive/detail/basic_iarchive.hpp>
+#include <boost/archive/detail/basic_iserializer.hpp>
+#include <boost/archive/detail/basic_pointer_iserializer.hpp>
+#include <boost/archive/detail/archive_serializer_map.hpp>
+#include <boost/archive/detail/check.hpp>
+
+namespace boost {
+
+namespace serialization {
+    class extended_type_info;
+} // namespace serialization
+
+namespace archive {
+
+// an accessor to permit friend access to archives.  Needed because
+// some compilers don't handle friend templates completely
+class load_access {
+public:
+    template<class Archive, class T>
+    static void load_primitive(Archive &ar, T &t){
+        ar.load(t);
+    }
+};
+
+namespace detail {
+
+#ifdef BOOST_MSVC
+#  pragma warning(push)
+#  pragma warning(disable : 4511 4512)
+#endif
+
+template<class Archive, class T>
+class iserializer : public basic_iserializer
+{
+private:
+    virtual void destroy(/*const*/ void *address) const {
+        boost::serialization::access::destroy(static_cast<T *>(address));
+    }
+protected:
+    // protected constructor since it's always created by singleton
+    explicit iserializer() :
+        basic_iserializer(
+            boost::serialization::singleton<
+                typename 
+                boost::serialization::type_info_implementation< T >::type
+            >::get_const_instance()
+        )
+    {}
+public:
+    virtual BOOST_DLLEXPORT void load_object_data(
+        basic_iarchive & ar,
+        void *x, 
+        const unsigned int file_version
+    ) const BOOST_USED;
+    virtual bool class_info() const {
+        return boost::serialization::implementation_level< T >::value 
+            >= boost::serialization::object_class_info;
+    }
+    virtual bool tracking(const unsigned int /* flags */) const {
+        return boost::serialization::tracking_level< T >::value 
+                == boost::serialization::track_always
+            || ( boost::serialization::tracking_level< T >::value 
+                == boost::serialization::track_selectively
+                && serialized_as_pointer());
+    }
+    virtual version_type version() const {
+        return version_type(::boost::serialization::version< T >::value);
+    }
+    virtual bool is_polymorphic() const {
+        return boost::is_polymorphic< T >::value;
+    }
+    virtual ~iserializer(){};
+};
+
+#ifdef BOOST_MSVC
+#  pragma warning(pop)
+#endif
+
+template<class Archive, class T>
+BOOST_DLLEXPORT void iserializer<Archive, T>::load_object_data(
+    basic_iarchive & ar,
+    void *x, 
+    const unsigned int file_version
+) const {
+    // note: we now comment this out. Before we permited archive
+    // version # to be very large.  Now we don't.  To permit
+    // readers of these old archives, we have to suppress this 
+    // code.  Perhaps in the future we might re-enable it but
+    // permit its suppression with a runtime switch.
+    #if 0
+    // trap case where the program cannot handle the current version
+    if(file_version > static_cast<const unsigned int>(version()))
+        boost::serialization::throw_exception(
+            archive::archive_exception(
+                boost::archive::archive_exception::unsupported_class_version,
+                get_debug_info()
+            )
+        );
+    #endif
+    // make sure call is routed through the higest interface that might
+    // be specialized by the user.
+    boost::serialization::serialize_adl(
+        boost::serialization::smart_cast_reference<Archive &>(ar),
+        * static_cast<T *>(x), 
+        file_version
+    );
+}
+
+#ifdef BOOST_MSVC
+#  pragma warning(push)
+#  pragma warning(disable : 4511 4512)
+#endif
+
+// the purpose of this code is to allocate memory for an object
+// without requiring the constructor to be called.  Presumably
+// the allocated object will be subsequently initialized with
+// "placement new". 
+// note: we have the boost type trait has_new_operator but we
+// have no corresponding has_delete_operator.  So we presume
+// that the former being true would imply that the a delete
+// operator is also defined for the class T.
+
+template<class T>
+struct heap_allocation {
+    // boost::has_new_operator< T > doesn't work on these compilers
+    #if DONT_USE_HAS_NEW_OPERATOR
+        // This doesn't handle operator new overload for class T
+        static T * invoke_new(){
+            return static_cast<T *>(operator new(sizeof(T)));
+        }
+        static void invoke_delete(T *t){
+            (operator delete(t));
+        }
+    #else
+        // note: we presume that a true value for has_new_operator
+        // implies the existence of a class specific delete operator as well
+        // as a class specific new operator.
+        struct has_new_operator {
+            static T * invoke_new() {
+                return static_cast<T *>((T::operator new)(sizeof(T)));
+            }
+            static void invoke_delete(T * t) {
+                // if compilation fails here, the likely cause that the class
+                // T has a class specific new operator but no class specific
+                // delete operator which matches the following signature.
+                // note that this solution addresses the issue that two
+                // possible signatures.  But it doesn't address the possibility
+                // that the class might have class specific new with NO
+                // class specific delete at all.  Patches (compatible with
+                // C++03) welcome!
+                delete t;
+            }
+        };
+        struct doesnt_have_new_operator {
+            static T* invoke_new() {
+                return static_cast<T *>(operator new(sizeof(T)));
+            }
+            static void invoke_delete(T * t) {
+                // Note: I'm reliance upon automatic conversion from T * to void * here
+                delete t;
+            }
+        };
+        static T * invoke_new() {
+            typedef typename
+                mpl::eval_if<
+                    boost::has_new_operator< T >,
+                    mpl::identity<has_new_operator >,
+                    mpl::identity<doesnt_have_new_operator >    
+                >::type typex;
+            return typex::invoke_new();
+        }
+        static void invoke_delete(T *t) {
+            typedef typename
+                mpl::eval_if<
+                    boost::has_new_operator< T >,
+                    mpl::identity<has_new_operator >,
+                    mpl::identity<doesnt_have_new_operator >    
+                >::type typex;
+            typex::invoke_delete(t);
+        }
+    #endif
+    explicit heap_allocation(){
+        m_p = invoke_new();
+    }
+    ~heap_allocation(){
+        if (0 != m_p)
+            invoke_delete(m_p);
+    }
+    T* get() const {
+        return m_p;
+    }
+
+    T* release() {
+        T* p = m_p;
+        m_p = 0;
+        return p;
+    }
+private:
+    T* m_p;
+};
+
+template<class Archive, class T>
+class pointer_iserializer :
+    public basic_pointer_iserializer
+{
+private:
+    virtual void * heap_allocation() const {
+        detail::heap_allocation<T> h;
+        T * t = h.get();
+        h.release();
+        return t;
+    }
+    virtual const basic_iserializer & get_basic_serializer() const {
+        return boost::serialization::singleton<
+            iserializer<Archive, T>
+        >::get_const_instance();
+    }
+    BOOST_DLLEXPORT virtual void load_object_ptr(
+        basic_iarchive & ar, 
+        void * x,
+        const unsigned int file_version
+    ) const BOOST_USED;
+protected:
+    // this should alway be a singleton so make the constructor protected
+    pointer_iserializer();
+    ~pointer_iserializer();
+};
+
+#ifdef BOOST_MSVC
+#  pragma warning(pop)
+#endif
+
+// note: BOOST_DLLEXPORT is so that code for polymorphic class
+// serialized only through base class won't get optimized out
+template<class Archive, class T>
+BOOST_DLLEXPORT void pointer_iserializer<Archive, T>::load_object_ptr(
+    basic_iarchive & ar, 
+    void * t,
+    const unsigned int file_version
+) const
+{
+    Archive & ar_impl = 
+        boost::serialization::smart_cast_reference<Archive &>(ar);
+
+    // note that the above will throw std::bad_alloc if the allocation
+    // fails so we don't have to address this contingency here.
+
+    // catch exception during load_construct_data so that we don't
+    // automatically delete the t which is most likely not fully
+    // constructed
+    BOOST_TRY {
+        // this addresses an obscure situation that occurs when 
+        // load_constructor de-serializes something through a pointer.
+        ar.next_object_pointer(t);
+        boost::serialization::load_construct_data_adl<Archive, T>(
+            ar_impl,
+            static_cast<T *>(t),
+            file_version
+        );
+    }
+    BOOST_CATCH(...){
+        // if we get here the load_construct failed.  The heap_allocation
+        // will be automatically deleted so we don't have to do anything
+        // special here.
+        BOOST_RETHROW;
+    }
+    BOOST_CATCH_END
+
+    ar_impl >> boost::serialization::make_nvp(NULL, * static_cast<T *>(t));
+}
+
+template<class Archive, class T>
+pointer_iserializer<Archive, T>::pointer_iserializer() :
+    basic_pointer_iserializer(
+        boost::serialization::singleton<
+            typename 
+            boost::serialization::type_info_implementation< T >::type
+        >::get_const_instance()
+    )
+{
+    boost::serialization::singleton<
+        iserializer<Archive, T>
+    >::get_mutable_instance().set_bpis(this);
+    archive_serializer_map<Archive>::insert(this);
+}
+
+template<class Archive, class T>
+pointer_iserializer<Archive, T>::~pointer_iserializer(){
+    archive_serializer_map<Archive>::erase(this);
+}
+
+template<class Archive>
+struct load_non_pointer_type {
+    // note this bounces the call right back to the archive
+    // with no runtime overhead
+    struct load_primitive {
+        template<class T>
+        static void invoke(Archive & ar, T & t){
+            load_access::load_primitive(ar, t);
+        }
+    };
+    // note this bounces the call right back to the archive
+    // with no runtime overhead
+    struct load_only {
+        template<class T>
+        static void invoke(Archive & ar, const T & t){
+            // short cut to user's serializer
+            // make sure call is routed through the higest interface that might
+            // be specialized by the user.
+            boost::serialization::serialize_adl(
+                ar, 
+                const_cast<T &>(t), 
+                boost::serialization::version< T >::value
+            );
+        }
+    };
+
+    // note this save class information including version
+    // and serialization level to the archive
+    struct load_standard {
+        template<class T>
+        static void invoke(Archive &ar, const T & t){
+            void * x = & const_cast<T &>(t);
+            ar.load_object(
+                x, 
+                boost::serialization::singleton<
+                    iserializer<Archive, T>
+                >::get_const_instance()
+            );
+        }
+    };
+
+    struct load_conditional {
+        template<class T>
+        static void invoke(Archive &ar, T &t){
+            //if(0 == (ar.get_flags() & no_tracking))
+                load_standard::invoke(ar, t);
+            //else
+            //    load_only::invoke(ar, t);
+        }
+    };
+
+    template<class T>
+    static void invoke(Archive & ar, T &t){
+        typedef typename mpl::eval_if<
+                // if its primitive
+                mpl::equal_to<
+                    boost::serialization::implementation_level< T >,
+                    mpl::int_<boost::serialization::primitive_type>
+                >,
+                mpl::identity<load_primitive>,
+            // else
+            typename mpl::eval_if<
+            // class info / version
+            mpl::greater_equal<
+                        boost::serialization::implementation_level< T >,
+                        mpl::int_<boost::serialization::object_class_info>
+                    >,
+            // do standard load
+            mpl::identity<load_standard>,
+        // else
+        typename mpl::eval_if<
+            // no tracking
+                    mpl::equal_to<
+                        boost::serialization::tracking_level< T >,
+                        mpl::int_<boost::serialization::track_never>
+                >,
+                // do a fast load
+                mpl::identity<load_only>,
+            // else
+            // do a fast load only tracking is turned off
+            mpl::identity<load_conditional>
+        > > >::type typex;
+        check_object_versioning< T >();
+        check_object_level< T >();
+        typex::invoke(ar, t);
+    }
+};
+
+template<class Archive>
+struct load_pointer_type {
+    struct abstract
+    {
+        template<class T>
+        static const basic_pointer_iserializer * register_type(Archive & /* ar */){
+            // it has? to be polymorphic
+            BOOST_STATIC_ASSERT(boost::is_polymorphic< T >::value);
+            return static_cast<basic_pointer_iserializer *>(NULL);
+         }
+    };
+
+    struct non_abstract
+    {
+        template<class T>
+        static const basic_pointer_iserializer * register_type(Archive & ar){
+            return ar.register_type(static_cast<T *>(NULL));
+        }
+    };
+
+    template<class T>
+    static const basic_pointer_iserializer * register_type(Archive &ar, const T & /*t*/){
+        // there should never be any need to load an abstract polymorphic 
+        // class pointer.  Inhibiting code generation for this
+        // permits abstract base classes to be used - note: exception
+        // virtual serialize functions used for plug-ins
+        typedef typename
+            mpl::eval_if<
+                boost::serialization::is_abstract<const T>,
+                boost::mpl::identity<abstract>,
+                boost::mpl::identity<non_abstract>  
+            >::type typex;
+        return typex::template register_type< T >(ar);
+    }
+
+    template<class T>
+    static T * pointer_tweak(
+        const boost::serialization::extended_type_info & eti,
+        void const * const t,
+        const T &
+    ) {
+        // tweak the pointer back to the base class
+        void * upcast = const_cast<void *>(
+            boost::serialization::void_upcast(
+                eti,
+                boost::serialization::singleton<
+                    typename 
+                    boost::serialization::type_info_implementation< T >::type
+                >::get_const_instance(),
+                t
+            )
+        );
+        if(NULL == upcast)
+            boost::serialization::throw_exception(
+                archive_exception(archive_exception::unregistered_class)
+            );
+        return static_cast<T *>(upcast);
+    }
+
+    template<class T>
+    static void check_load(T & /* t */){
+        check_pointer_level< T >();
+        check_pointer_tracking< T >();
+    }
+
+    static const basic_pointer_iserializer *
+    find(const boost::serialization::extended_type_info & type){
+        return static_cast<const basic_pointer_iserializer *>(
+            archive_serializer_map<Archive>::find(type)
+        );
+    }
+
+    template<class Tptr>
+    static void invoke(Archive & ar, Tptr & t){
+        check_load(*t);
+        const basic_pointer_iserializer * bpis_ptr = register_type(ar, *t);
+        const basic_pointer_iserializer * newbpis_ptr = ar.load_pointer(
+            // note major hack here !!!
+            // I tried every way to convert Tptr &t (where Tptr might
+            // include const) to void * &.  This is the only way
+            // I could make it work. RR
+            (void * & )t,
+            bpis_ptr,
+            find
+        );
+        // if the pointer isn't that of the base class
+        if(newbpis_ptr != bpis_ptr){
+            t = pointer_tweak(newbpis_ptr->get_eti(), t, *t);
+        }
+    }
+};
+
+template<class Archive>
+struct load_enum_type {
+    template<class T>
+    static void invoke(Archive &ar, T &t){
+        // convert integers to correct enum to load
+        int i;
+        ar >> boost::serialization::make_nvp(NULL, i);
+        t = static_cast< T >(i);
+    }
+};
+
+template<class Archive>
+struct load_array_type {
+    template<class T>
+    static void invoke(Archive &ar, T &t){
+        typedef typename remove_extent< T >::type value_type;
+        
+        // convert integers to correct enum to load
+        // determine number of elements in the array. Consider the
+        // fact that some machines will align elements on boundries
+        // other than characters.
+        std::size_t current_count = sizeof(t) / (
+            static_cast<char *>(static_cast<void *>(&t[1])) 
+            - static_cast<char *>(static_cast<void *>(&t[0]))
+        );
+        boost::serialization::collection_size_type count;
+        ar >> BOOST_SERIALIZATION_NVP(count);
+        if(static_cast<std::size_t>(count) > current_count)
+            boost::serialization::throw_exception(
+                archive::archive_exception(
+                    boost::archive::archive_exception::array_size_too_short
+                )
+            );
+        // explict template arguments to pass intel C++ compiler
+        ar >> serialization::make_array<
+            value_type,
+            boost::serialization::collection_size_type
+        >(
+            static_cast<value_type *>(&t[0]),
+            count
+        );
+    }
+};
+
+} // detail
+
+template<class Archive, class T>
+inline void load(Archive & ar, T &t){
+    // if this assertion trips. It means we're trying to load a
+    // const object with a compiler that doesn't have correct
+    // function template ordering.  On other compilers, this is
+    // handled below.
+    detail::check_const_loading< T >();
+    typedef
+        typename mpl::eval_if<is_pointer< T >,
+            mpl::identity<detail::load_pointer_type<Archive> >
+        ,//else
+        typename mpl::eval_if<is_array< T >,
+            mpl::identity<detail::load_array_type<Archive> >
+        ,//else
+        typename mpl::eval_if<is_enum< T >,
+            mpl::identity<detail::load_enum_type<Archive> >
+        ,//else
+            mpl::identity<detail::load_non_pointer_type<Archive> >
+        >
+        >
+        >::type typex;
+    typex::invoke(ar, t);
+}
+
+} // namespace archive
+} // namespace boost
+
+#endif // BOOST_ARCHIVE_DETAIL_ISERIALIZER_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/detail/oserializer.hpp b/contrib/libboost/boost_1_65_0/boost/archive/detail/oserializer.hpp
new file mode 100644
index 00000000000..c120ec55073
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/archive/detail/oserializer.hpp
@@ -0,0 +1,540 @@
+#ifndef BOOST_ARCHIVE_OSERIALIZER_HPP
+#define BOOST_ARCHIVE_OSERIALIZER_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#pragma inline_depth(511)
+#pragma inline_recursion(on)
+#endif
+
+#if defined(__MWERKS__)
+#pragma inline_depth(511)
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// oserializer.hpp: interface for serialization system.
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+#include <boost/assert.hpp>
+#include <cstddef> // NULL
+
+#include <boost/config.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/detail/workaround.hpp>
+
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/equal_to.hpp>
+#include <boost/mpl/greater_equal.hpp>
+#include <boost/mpl/identity.hpp>
+#include <boost/mpl/bool_fwd.hpp>
+
+#ifndef BOOST_SERIALIZATION_DEFAULT_TYPE_INFO   
+    #include <boost/serialization/extended_type_info_typeid.hpp>   
+#endif
+#include <boost/serialization/throw_exception.hpp>
+#include <boost/serialization/smart_cast.hpp>
+#include <boost/serialization/assume_abstract.hpp>
+#include <boost/serialization/static_warning.hpp>
+
+#include <boost/type_traits/is_pointer.hpp>
+#include <boost/type_traits/is_enum.hpp>
+#include <boost/type_traits/is_const.hpp>
+#include <boost/type_traits/is_polymorphic.hpp>
+#include <boost/type_traits/remove_extent.hpp>
+
+#include <boost/serialization/serialization.hpp>
+#include <boost/serialization/version.hpp>
+#include <boost/serialization/level.hpp>
+#include <boost/serialization/tracking.hpp>
+#include <boost/serialization/type_info_implementation.hpp>
+#include <boost/serialization/nvp.hpp>
+#include <boost/serialization/void_cast.hpp>
+#include <boost/serialization/collection_size_type.hpp>
+#include <boost/serialization/array_wrapper.hpp>
+
+#include <boost/serialization/singleton.hpp>
+
+#include <boost/archive/archive_exception.hpp>
+#include <boost/archive/detail/basic_oarchive.hpp>
+#include <boost/archive/detail/basic_oserializer.hpp>
+#include <boost/archive/detail/basic_pointer_oserializer.hpp>
+#include <boost/archive/detail/archive_serializer_map.hpp>
+#include <boost/archive/detail/check.hpp>
+
+namespace boost {
+
+namespace serialization {
+    class extended_type_info;
+} // namespace serialization
+
+namespace archive {
+
+// an accessor to permit friend access to archives.  Needed because
+// some compilers don't handle friend templates completely
+class save_access {
+public:
+    template<class Archive>
+    static void end_preamble(Archive & ar){
+        ar.end_preamble();
+    }
+    template<class Archive, class T>
+    static void save_primitive(Archive & ar, const  T & t){
+        ar.end_preamble();
+        ar.save(t);
+    }
+};
+
+namespace detail {
+
+#ifdef BOOST_MSVC
+#  pragma warning(push)
+#  pragma warning(disable : 4511 4512)
+#endif
+
+template<class Archive, class T>
+class oserializer : public basic_oserializer
+{
+private:
+    // private constructor to inhibit any existence other than the 
+    // static one
+public:
+    explicit BOOST_DLLEXPORT oserializer() :
+        basic_oserializer(
+            boost::serialization::singleton<
+                typename 
+                boost::serialization::type_info_implementation< T >::type
+            >::get_const_instance()
+        )
+    {}
+    virtual BOOST_DLLEXPORT void save_object_data(
+        basic_oarchive & ar,    
+        const void *x
+    ) const BOOST_USED;
+    virtual bool class_info() const {
+        return boost::serialization::implementation_level< T >::value 
+            >= boost::serialization::object_class_info;
+    }
+    virtual bool tracking(const unsigned int /* flags */) const {
+        return boost::serialization::tracking_level< T >::value == boost::serialization::track_always
+            || (boost::serialization::tracking_level< T >::value == boost::serialization::track_selectively
+                && serialized_as_pointer());
+    }
+    virtual version_type version() const {
+        return version_type(::boost::serialization::version< T >::value);
+    }
+    virtual bool is_polymorphic() const {
+        return boost::is_polymorphic< T >::value;
+    }
+    virtual ~oserializer(){}
+};
+
+#ifdef BOOST_MSVC
+#  pragma warning(pop)
+#endif
+
+template<class Archive, class T>
+BOOST_DLLEXPORT void oserializer<Archive, T>::save_object_data(
+    basic_oarchive & ar,    
+    const void *x
+) const {
+    // make sure call is routed through the highest interface that might
+    // be specialized by the user.
+    BOOST_STATIC_ASSERT(boost::is_const< T >::value == false);
+    boost::serialization::serialize_adl(
+        boost::serialization::smart_cast_reference<Archive &>(ar),
+        * static_cast<T *>(const_cast<void *>(x)),
+        version()
+    );
+}
+
+#ifdef BOOST_MSVC
+#  pragma warning(push)
+#  pragma warning(disable : 4511 4512)
+#endif
+
+template<class Archive, class T>
+class pointer_oserializer :
+    public basic_pointer_oserializer
+{
+private:
+    const basic_oserializer & 
+    get_basic_serializer() const {
+        return boost::serialization::singleton<
+            oserializer<Archive, T>
+        >::get_const_instance();
+    }
+    virtual BOOST_DLLEXPORT void save_object_ptr(
+        basic_oarchive & ar,
+        const void * x
+    ) const BOOST_USED;
+public:
+    pointer_oserializer();
+    ~pointer_oserializer();
+};
+
+#ifdef BOOST_MSVC
+#  pragma warning(pop)
+#endif
+
+template<class Archive, class T>
+BOOST_DLLEXPORT void pointer_oserializer<Archive, T>::save_object_ptr(
+    basic_oarchive & ar,
+    const void * x
+) const {
+    BOOST_ASSERT(NULL != x);
+    // make sure call is routed through the highest interface that might
+    // be specialized by the user.
+    T * t = static_cast<T *>(const_cast<void *>(x));
+    const unsigned int file_version = boost::serialization::version< T >::value;
+    Archive & ar_impl 
+        = boost::serialization::smart_cast_reference<Archive &>(ar);
+    boost::serialization::save_construct_data_adl<Archive, T>(
+        ar_impl, 
+        t, 
+        file_version
+    );
+    ar_impl << boost::serialization::make_nvp(NULL, * t);
+}
+
+template<class Archive, class T>
+pointer_oserializer<Archive, T>::pointer_oserializer() :
+    basic_pointer_oserializer(
+        boost::serialization::singleton<
+            typename 
+            boost::serialization::type_info_implementation< T >::type
+        >::get_const_instance()
+    )
+{
+    // make sure appropriate member function is instantiated
+    boost::serialization::singleton<
+        oserializer<Archive, T> 
+    >::get_mutable_instance().set_bpos(this);
+    archive_serializer_map<Archive>::insert(this);
+}
+
+template<class Archive, class T>
+pointer_oserializer<Archive, T>::~pointer_oserializer(){
+    archive_serializer_map<Archive>::erase(this);
+}
+
+template<class Archive>
+struct save_non_pointer_type {
+    // note this bounces the call right back to the archive
+    // with no runtime overhead
+    struct save_primitive {
+        template<class T>
+        static void invoke(Archive & ar, const T & t){
+            save_access::save_primitive(ar, t);
+        }
+    };
+    // same as above but passes through serialization
+    struct save_only {
+        template<class T>
+        static void invoke(Archive & ar, const T & t){
+            // make sure call is routed through the highest interface that might
+            // be specialized by the user.
+            boost::serialization::serialize_adl(
+                ar, 
+                const_cast<T &>(t), 
+                ::boost::serialization::version< T >::value
+            );
+        }
+    };
+    // adds class information to the archive. This includes
+    // serialization level and class version
+    struct save_standard {
+        template<class T>
+        static void invoke(Archive &ar, const T & t){
+            ar.save_object(
+                & t, 
+                boost::serialization::singleton<
+                    oserializer<Archive, T>
+                >::get_const_instance()
+            );
+        }
+    };
+
+    // adds class information to the archive. This includes
+    // serialization level and class version
+    struct save_conditional {
+        template<class T>
+        static void invoke(Archive &ar, const T &t){
+            //if(0 == (ar.get_flags() & no_tracking))
+                save_standard::invoke(ar, t);
+            //else
+            //   save_only::invoke(ar, t);
+        }
+    };
+
+
+    template<class T>
+    static void invoke(Archive & ar, const T & t){
+        typedef 
+            typename mpl::eval_if<
+            // if its primitive
+                mpl::equal_to<
+                    boost::serialization::implementation_level< T >,
+                    mpl::int_<boost::serialization::primitive_type>
+                >,
+                mpl::identity<save_primitive>,
+            // else
+            typename mpl::eval_if<
+                // class info / version
+                mpl::greater_equal<
+                    boost::serialization::implementation_level< T >,
+                    mpl::int_<boost::serialization::object_class_info>
+                >,
+                // do standard save
+                mpl::identity<save_standard>,
+            // else
+            typename mpl::eval_if<
+                    // no tracking
+                mpl::equal_to<
+                    boost::serialization::tracking_level< T >,
+                    mpl::int_<boost::serialization::track_never>
+                >,
+                // do a fast save
+                mpl::identity<save_only>,
+            // else
+                // do a fast save only tracking is turned off
+                mpl::identity<save_conditional>
+            > > >::type typex; 
+        check_object_versioning< T >();
+        typex::invoke(ar, t);
+    }
+    template<class T>
+    static void invoke(Archive & ar, T & t){
+        check_object_level< T >();
+        check_object_tracking< T >();
+        invoke(ar, const_cast<const T &>(t));
+    }
+};
+
+template<class Archive>
+struct save_pointer_type {
+    struct abstract
+    {
+        template<class T>
+        static const basic_pointer_oserializer * register_type(Archive & /* ar */){
+            // it has? to be polymorphic
+            BOOST_STATIC_ASSERT(boost::is_polymorphic< T >::value);
+            return NULL;
+        }
+    };
+
+    struct non_abstract
+    {
+        template<class T>
+        static const basic_pointer_oserializer * register_type(Archive & ar){
+            return ar.register_type(static_cast<T *>(NULL));
+        }
+    };
+
+    template<class T>
+    static const basic_pointer_oserializer * register_type(Archive &ar, T & /*t*/){
+        // there should never be any need to save an abstract polymorphic 
+        // class pointer.  Inhibiting code generation for this
+        // permits abstract base classes to be used - note: exception
+        // virtual serialize functions used for plug-ins
+        typedef 
+            typename mpl::eval_if<
+                boost::serialization::is_abstract< T >,
+                mpl::identity<abstract>,
+                mpl::identity<non_abstract>       
+            >::type typex;
+        return typex::template register_type< T >(ar);
+    }
+
+    struct non_polymorphic
+    {
+        template<class T>
+        static void save(
+            Archive &ar, 
+            T & t
+        ){
+            const basic_pointer_oserializer & bpos = 
+                boost::serialization::singleton<
+                    pointer_oserializer<Archive, T>
+                >::get_const_instance();
+            // save the requested pointer type
+            ar.save_pointer(& t, & bpos);
+        }
+    };
+
+    struct polymorphic
+    {
+        template<class T>
+        static void save(
+            Archive &ar, 
+            T & t
+        ){
+            typename 
+            boost::serialization::type_info_implementation< T >::type const
+            & i = boost::serialization::singleton<
+                typename 
+                boost::serialization::type_info_implementation< T >::type
+            >::get_const_instance();
+
+            boost::serialization::extended_type_info const * const this_type = & i;
+
+            // retrieve the true type of the object pointed to
+            // if this assertion fails its an error in this library
+            BOOST_ASSERT(NULL != this_type);
+
+            const boost::serialization::extended_type_info * true_type =
+                i.get_derived_extended_type_info(t);
+
+            // note:if this exception is thrown, be sure that derived pointer
+            // is either registered or exported.
+            if(NULL == true_type){
+                boost::serialization::throw_exception(
+                    archive_exception(
+                        archive_exception::unregistered_class,
+                        "derived class not registered or exported"
+                    )
+                );
+            }
+
+            // if its not a pointer to a more derived type
+            const void *vp = static_cast<const void *>(&t);
+            if(*this_type == *true_type){
+                const basic_pointer_oserializer * bpos = register_type(ar, t);
+                ar.save_pointer(vp, bpos);
+                return;
+            }
+            // convert pointer to more derived type. if this is thrown
+            // it means that the base/derived relationship hasn't be registered
+            vp = serialization::void_downcast(
+                *true_type, 
+                *this_type, 
+                static_cast<const void *>(&t)
+            );
+            if(NULL == vp){
+                boost::serialization::throw_exception(
+                    archive_exception(
+                        archive_exception::unregistered_cast,
+                        true_type->get_debug_info(),
+                        this_type->get_debug_info()
+                    )
+                );
+            }
+
+            // since true_type is valid, and this only gets made if the 
+            // pointer oserializer object has been created, this should never
+            // fail
+            const basic_pointer_oserializer * bpos
+                = static_cast<const basic_pointer_oserializer *>(
+                    boost::serialization::singleton<
+                        archive_serializer_map<Archive>
+                    >::get_const_instance().find(*true_type)
+                );
+            BOOST_ASSERT(NULL != bpos);
+            if(NULL == bpos)
+                boost::serialization::throw_exception(
+                    archive_exception(
+                        archive_exception::unregistered_class,
+                        "derived class not registered or exported"
+                    )
+                );
+            ar.save_pointer(vp, bpos);
+        }
+    };
+
+    template<class T>
+    static void save(
+        Archive & ar, 
+        const T & t
+    ){
+        check_pointer_level< T >();
+        check_pointer_tracking< T >();
+        typedef typename mpl::eval_if<
+            is_polymorphic< T >,
+            mpl::identity<polymorphic>,
+            mpl::identity<non_polymorphic>
+        >::type type;
+        type::save(ar, const_cast<T &>(t));
+    }
+
+    template<class TPtr>
+    static void invoke(Archive &ar, const TPtr t){
+        register_type(ar, * t);
+        if(NULL == t){
+            basic_oarchive & boa 
+                = boost::serialization::smart_cast_reference<basic_oarchive &>(ar);
+            boa.save_null_pointer();
+            save_access::end_preamble(ar);
+            return;
+        }
+        save(ar, * t);
+    }
+};
+
+template<class Archive>
+struct save_enum_type
+{
+    template<class T>
+    static void invoke(Archive &ar, const T &t){
+        // convert enum to integers on save
+        const int i = static_cast<int>(t);
+        ar << boost::serialization::make_nvp(NULL, i);
+    }
+};
+
+template<class Archive>
+struct save_array_type
+{
+    template<class T>
+    static void invoke(Archive &ar, const T &t){
+        typedef typename boost::remove_extent< T >::type value_type;
+        
+        save_access::end_preamble(ar);
+        // consider alignment
+        std::size_t c = sizeof(t) / (
+            static_cast<const char *>(static_cast<const void *>(&t[1])) 
+            - static_cast<const char *>(static_cast<const void *>(&t[0]))
+        );
+        boost::serialization::collection_size_type count(c);
+        ar << BOOST_SERIALIZATION_NVP(count);
+        // explict template arguments to pass intel C++ compiler
+        ar << serialization::make_array<
+            const value_type,
+            boost::serialization::collection_size_type
+        >(
+            static_cast<const value_type *>(&t[0]),
+            count
+        );
+    }
+};
+
+} // detail
+
+template<class Archive, class T>
+inline void save(Archive & ar, /*const*/ T &t){
+    typedef 
+        typename mpl::eval_if<is_pointer< T >,
+            mpl::identity<detail::save_pointer_type<Archive> >,
+        //else
+        typename mpl::eval_if<is_enum< T >,
+            mpl::identity<detail::save_enum_type<Archive> >,
+        //else
+        typename mpl::eval_if<is_array< T >,
+            mpl::identity<detail::save_array_type<Archive> >,
+        //else
+            mpl::identity<detail::save_non_pointer_type<Archive> >
+        >
+        >
+        >::type typex;
+    typex::invoke(ar, t);
+}
+
+} // namespace archive
+} // namespace boost
+
+#endif // BOOST_ARCHIVE_OSERIALIZER_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/detail/polymorphic_iarchive_route.hpp b/contrib/libboost/boost_1_65_0/boost/archive/detail/polymorphic_iarchive_route.hpp
new file mode 100644
index 00000000000..105685ebbd8
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/archive/detail/polymorphic_iarchive_route.hpp
@@ -0,0 +1,218 @@
+#ifndef BOOST_ARCHIVE_DETAIL_POLYMORPHIC_IARCHIVE_ROUTE_HPP
+#define BOOST_ARCHIVE_DETAIL_POLYMORPHIC_IARCHIVE_ROUTE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// polymorphic_iarchive_route.hpp
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+#include <string>
+#include <ostream>
+#include <cstddef>
+
+#include <boost/config.hpp>
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{
+    using ::size_t;
+} // namespace std
+#endif
+
+#include <boost/cstdint.hpp>
+#include <boost/integer_traits.hpp>
+#include <boost/archive/polymorphic_iarchive.hpp>
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+namespace boost {
+namespace serialization {
+    class extended_type_info;
+} // namespace serialization
+namespace archive {
+namespace detail{
+
+class basic_iserializer;
+class basic_pointer_iserializer;
+
+#ifdef BOOST_MSVC
+#  pragma warning(push)
+#  pragma warning(disable : 4511 4512)
+#endif
+
+template<class ArchiveImplementation>
+class polymorphic_iarchive_route :
+    public polymorphic_iarchive,
+    // note: gcc dynamic cross cast fails if the the derivation below is
+    // not public.  I think this is a mistake.
+    public /*protected*/ ArchiveImplementation
+{
+private:
+    // these are used by the serialization library.
+    virtual void load_object(
+        void *t,
+        const basic_iserializer & bis
+    ){
+        ArchiveImplementation::load_object(t, bis);
+    }
+    virtual const basic_pointer_iserializer * load_pointer(
+        void * & t,
+        const basic_pointer_iserializer * bpis_ptr,
+        const basic_pointer_iserializer * (*finder)(
+            const boost::serialization::extended_type_info & type
+        )
+    ){
+        return ArchiveImplementation::load_pointer(t, bpis_ptr, finder);
+    }
+    virtual void set_library_version(library_version_type archive_library_version){
+        ArchiveImplementation::set_library_version(archive_library_version);
+    }
+    virtual library_version_type get_library_version() const{
+        return ArchiveImplementation::get_library_version();
+    }
+    virtual unsigned int get_flags() const {
+        return ArchiveImplementation::get_flags();
+    }
+    virtual void delete_created_pointers(){
+        ArchiveImplementation::delete_created_pointers();
+    }
+    virtual void reset_object_address(
+        const void * new_address,
+        const void * old_address
+    ){
+        ArchiveImplementation::reset_object_address(new_address, old_address);
+    }
+    virtual void load_binary(void * t, std::size_t size){
+        ArchiveImplementation::load_binary(t, size);
+    }
+    // primitive types the only ones permitted by polymorphic archives
+    virtual void load(bool & t){
+        ArchiveImplementation::load(t);
+    }
+    virtual void load(char & t){
+        ArchiveImplementation::load(t);
+    }
+    virtual void load(signed char & t){
+        ArchiveImplementation::load(t);
+    }
+    virtual void load(unsigned char & t){
+        ArchiveImplementation::load(t);
+    }
+    #ifndef BOOST_NO_CWCHAR
+    #ifndef BOOST_NO_INTRINSIC_WCHAR_T
+    virtual void load(wchar_t & t){
+        ArchiveImplementation::load(t);
+    }
+    #endif
+    #endif
+    virtual void load(short & t){
+        ArchiveImplementation::load(t);
+    }
+    virtual void load(unsigned short & t){
+        ArchiveImplementation::load(t);
+    }
+    virtual void load(int & t){
+        ArchiveImplementation::load(t);
+    }
+    virtual void load(unsigned int & t){
+        ArchiveImplementation::load(t);
+    }
+    virtual void load(long & t){
+        ArchiveImplementation::load(t);
+    }
+    virtual void load(unsigned long & t){
+        ArchiveImplementation::load(t);
+    }
+    #if defined(BOOST_HAS_LONG_LONG)
+    virtual void load(boost::long_long_type & t){
+        ArchiveImplementation::load(t);
+    }
+    virtual void load(boost::ulong_long_type & t){
+        ArchiveImplementation::load(t);
+    }
+    #elif defined(BOOST_HAS_MS_INT64)
+    virtual void load(__int64 & t){
+        ArchiveImplementation::load(t);
+    }
+    virtual void load(unsigned __int64 & t){
+        ArchiveImplementation::load(t);
+    }
+    #endif
+    virtual void load(float & t){
+        ArchiveImplementation::load(t);
+    }
+    virtual void load(double & t){
+        ArchiveImplementation::load(t);
+    }
+    virtual void load(std::string & t){
+        ArchiveImplementation::load(t);
+    }
+    #ifndef BOOST_NO_STD_WSTRING
+    virtual void load(std::wstring & t){
+        ArchiveImplementation::load(t);
+    }
+    #endif
+    // used for xml and other tagged formats default does nothing
+    virtual void load_start(const char * name){
+        ArchiveImplementation::load_start(name);
+    }
+    virtual void load_end(const char * name){
+        ArchiveImplementation::load_end(name);
+    }
+    virtual void register_basic_serializer(const basic_iserializer & bis){
+        ArchiveImplementation::register_basic_serializer(bis);
+    }
+    virtual helper_collection &
+    get_helper_collection(){
+        return ArchiveImplementation::get_helper_collection();
+    }
+public:
+    // this can't be inheriteded because they appear in mulitple
+    // parents
+    typedef mpl::bool_<true> is_loading;
+    typedef mpl::bool_<false> is_saving;
+    // the >> operator
+    template<class T>
+    polymorphic_iarchive & operator>>(T & t){
+        return polymorphic_iarchive::operator>>(t);
+    }
+    // the & operator
+    template<class T>
+    polymorphic_iarchive & operator&(T & t){
+        return polymorphic_iarchive::operator&(t);
+    }
+    // register type function
+    template<class T>
+    const basic_pointer_iserializer * 
+    register_type(T * t = NULL){
+        return ArchiveImplementation::register_type(t);
+    }
+    // all current archives take a stream as constructor argument
+    template <class _Elem, class _Tr>
+    polymorphic_iarchive_route(
+        std::basic_istream<_Elem, _Tr> & is,
+        unsigned int flags = 0
+    ) :
+        ArchiveImplementation(is, flags)
+    {}
+    virtual ~polymorphic_iarchive_route(){};
+};
+
+} // namespace detail
+} // namespace archive
+} // namespace boost
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#endif // BOOST_ARCHIVE_DETAIL_POLYMORPHIC_IARCHIVE_DISPATCH_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/detail/polymorphic_oarchive_route.hpp b/contrib/libboost/boost_1_65_0/boost/archive/detail/polymorphic_oarchive_route.hpp
new file mode 100644
index 00000000000..b23fd6bf39d
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/archive/detail/polymorphic_oarchive_route.hpp
@@ -0,0 +1,209 @@
+#ifndef BOOST_ARCHIVE_DETAIL_POLYMORPHIC_OARCHIVE_ROUTE_HPP
+#define BOOST_ARCHIVE_DETAIL_POLYMORPHIC_OARCHIVE_ROUTE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// polymorphic_oarchive_route.hpp
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+#include <string>
+#include <ostream>
+#include <cstddef> // size_t
+
+#include <boost/config.hpp>
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{
+    using ::size_t;
+} // namespace std
+#endif
+
+#include <boost/cstdint.hpp>
+#include <boost/integer_traits.hpp>
+#include <boost/archive/polymorphic_oarchive.hpp>
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+namespace boost {
+namespace serialization {
+    class extended_type_info;
+} // namespace serialization
+namespace archive {
+namespace detail{
+
+class basic_oserializer;
+class basic_pointer_oserializer;
+
+#ifdef BOOST_MSVC
+#  pragma warning(push)
+#  pragma warning(disable : 4511 4512)
+#endif
+
+template<class ArchiveImplementation>
+class polymorphic_oarchive_route :
+    public polymorphic_oarchive,
+    // note: gcc dynamic cross cast fails if the the derivation below is
+    // not public.  I think this is a mistake.
+    public /*protected*/ ArchiveImplementation
+{
+private:
+    // these are used by the serialization library.
+    virtual void save_object(
+        const void *x,
+        const detail::basic_oserializer & bos
+    ){
+        ArchiveImplementation::save_object(x, bos);
+    }
+    virtual void save_pointer(
+        const void * t,
+        const detail::basic_pointer_oserializer * bpos_ptr
+    ){
+        ArchiveImplementation::save_pointer(t, bpos_ptr);
+    }
+    virtual void save_null_pointer(){
+        ArchiveImplementation::save_null_pointer();
+    }
+    // primitive types the only ones permitted by polymorphic archives
+    virtual void save(const bool t){
+        ArchiveImplementation::save(t);
+    }
+    virtual void save(const char t){
+        ArchiveImplementation::save(t);
+    }
+    virtual void save(const signed char t){
+        ArchiveImplementation::save(t);
+    }
+    virtual void save(const unsigned char t){
+        ArchiveImplementation::save(t);
+    }
+    #ifndef BOOST_NO_CWCHAR
+    #ifndef BOOST_NO_INTRINSIC_WCHAR_T
+    virtual void save(const wchar_t t){
+        ArchiveImplementation::save(t);
+    }
+    #endif
+    #endif
+    virtual void save(const short t){
+        ArchiveImplementation::save(t);
+    }
+    virtual void save(const unsigned short t){
+        ArchiveImplementation::save(t);
+    }
+    virtual void save(const int t){
+        ArchiveImplementation::save(t);
+    }
+    virtual void save(const unsigned int t){
+        ArchiveImplementation::save(t);
+    }
+    virtual void save(const long t){
+        ArchiveImplementation::save(t);
+    }
+    virtual void save(const unsigned long t){
+        ArchiveImplementation::save(t);
+    }
+    #if defined(BOOST_HAS_LONG_LONG)
+    virtual void save(const boost::long_long_type t){
+        ArchiveImplementation::save(t);
+    }
+    virtual void save(const boost::ulong_long_type t){
+        ArchiveImplementation::save(t);
+    }
+    #elif defined(BOOST_HAS_MS_INT64)
+    virtual void save(const boost::int64_t t){
+        ArchiveImplementation::save(t);
+    }
+    virtual void save(const boost::uint64_t t){
+        ArchiveImplementation::save(t);
+    }
+    #endif
+    virtual void save(const float t){
+        ArchiveImplementation::save(t);
+    }
+    virtual void save(const double t){
+        ArchiveImplementation::save(t);
+    }
+    virtual void save(const std::string & t){
+        ArchiveImplementation::save(t);
+    }
+    #ifndef BOOST_NO_STD_WSTRING
+    virtual void save(const std::wstring & t){
+        ArchiveImplementation::save(t);
+    }
+    #endif
+    virtual library_version_type get_library_version() const{
+        return ArchiveImplementation::get_library_version();
+    }
+    virtual unsigned int get_flags() const {
+        return ArchiveImplementation::get_flags();
+    }
+    virtual void save_binary(const void * t, std::size_t size){
+        ArchiveImplementation::save_binary(t, size);
+    }
+    // used for xml and other tagged formats default does nothing
+    virtual void save_start(const char * name){
+        ArchiveImplementation::save_start(name);
+    }
+    virtual void save_end(const char * name){
+        ArchiveImplementation::save_end(name);
+    }
+    virtual void end_preamble(){
+        ArchiveImplementation::end_preamble();
+    }
+    virtual void register_basic_serializer(const detail::basic_oserializer & bos){
+        ArchiveImplementation::register_basic_serializer(bos);
+    }
+    virtual helper_collection &
+    get_helper_collection(){
+        return ArchiveImplementation::get_helper_collection();
+    }
+public:
+    // this can't be inheriteded because they appear in mulitple
+    // parents
+    typedef mpl::bool_<false> is_loading;
+    typedef mpl::bool_<true> is_saving;
+    // the << operator
+    template<class T>
+    polymorphic_oarchive & operator<<(T & t){
+        return polymorphic_oarchive::operator<<(t);
+    }
+    // the & operator
+    template<class T>
+    polymorphic_oarchive & operator&(T & t){
+        return polymorphic_oarchive::operator&(t);
+    }
+    // register type function
+    template<class T>
+    const basic_pointer_oserializer * 
+    register_type(T * t = NULL){
+        return ArchiveImplementation::register_type(t);
+    }
+    // all current archives take a stream as constructor argument
+    template <class _Elem, class _Tr>
+    polymorphic_oarchive_route(
+        std::basic_ostream<_Elem, _Tr> & os,
+        unsigned int flags = 0
+    ) :
+        ArchiveImplementation(os, flags)
+    {}
+    virtual ~polymorphic_oarchive_route(){};
+};
+
+} // namespace detail
+} // namespace archive
+} // namespace boost
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#endif // BOOST_ARCHIVE_DETAIL_POLYMORPHIC_OARCHIVE_DISPATCH_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/detail/register_archive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/detail/register_archive.hpp
new file mode 100644
index 00000000000..5ffecc702ce
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/archive/detail/register_archive.hpp
@@ -0,0 +1,91 @@
+// Copyright David Abrahams 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)
+#ifndef BOOST_ARCHIVE_DETAIL_REGISTER_ARCHIVE_DWA2006521_HPP
+# define BOOST_ARCHIVE_DETAIL_REGISTER_ARCHIVE_DWA2006521_HPP
+
+namespace boost { namespace archive { namespace detail { 
+
+// No instantiate_ptr_serialization overloads generated by
+// BOOST_SERIALIZATION_REGISTER_ARCHIVE that lexically follow the call
+// will be seen *unless* they are in an associated namespace of one of
+// the arguments, so we pass one of these along to make sure this
+// namespace is considered.  See temp.dep.candidate (14.6.4.2) in the
+// standard.
+struct adl_tag {};
+
+template <class Archive, class Serializable>
+struct ptr_serialization_support;
+
+// We could've just used ptr_serialization_support, above, but using
+// it with only a forward declaration causes vc6/7 to complain about a
+// missing instantiate member, even if it has one.  This is just a
+// friendly layer of indirection.
+template <class Archive, class Serializable>
+struct _ptr_serialization_support
+  : ptr_serialization_support<Archive,Serializable>
+{
+    typedef int type;
+};
+
+#if defined(__SUNPRO_CC) && (__SUNPRO_CC < 0x5130)
+
+template<int N>
+struct counter : counter<N-1> {};
+template<>
+struct counter<0> {};
+
+template<class Serializable>
+void instantiate_ptr_serialization(Serializable* s, int, adl_tag) {
+    instantiate_ptr_serialization(s, counter<20>());
+}
+
+template<class Archive>
+struct get_counter {
+    static const int value = sizeof(adjust_counter(counter<20>()));
+    typedef counter<value> type;
+    typedef counter<value - 1> prior;
+    typedef char (&next)[value+1];
+};
+
+char adjust_counter(counter<0>);
+template<class Serializable>
+void instantiate_ptr_serialization(Serializable*, counter<0>) {}
+
+#define BOOST_SERIALIZATION_REGISTER_ARCHIVE(Archive)                     \
+namespace boost { namespace archive { namespace detail {                  \
+    get_counter<Archive >::next adjust_counter(get_counter<Archive >::type);\
+    template<class Serializable>                                          \
+    void instantiate_ptr_serialization(Serializable* s,                   \
+        get_counter<Archive >::type) {                                    \
+        ptr_serialization_support<Archive, Serializable> x;               \
+        instantiate_ptr_serialization(s, get_counter<Archive >::prior()); \
+    }\
+}}}
+
+
+#else
+
+// This function gets called, but its only purpose is to participate
+// in overload resolution with the functions declared by
+// BOOST_SERIALIZATION_REGISTER_ARCHIVE, below.
+template <class Serializable>
+void instantiate_ptr_serialization(Serializable*, int, adl_tag ) {}
+
+// The function declaration generated by this macro never actually
+// gets called, but its return type gets instantiated, and that's
+// enough to cause registration of serialization functions between
+// Archive and any exported Serializable type.  See also:
+// boost/serialization/export.hpp
+# define BOOST_SERIALIZATION_REGISTER_ARCHIVE(Archive)                  \
+namespace boost { namespace archive { namespace detail {                \
+                                                                        \
+template <class Serializable>                                           \
+typename _ptr_serialization_support<Archive, Serializable>::type  \
+instantiate_ptr_serialization( Serializable*, Archive*, adl_tag );              \
+                                                                        \
+}}}
+#endif
+}}} // namespace boost::archive::detail
+
+#endif // BOOST_ARCHIVE_DETAIL_INSTANTIATE_SERIALIZE_DWA2006521_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/detail/utf8_codecvt_facet.hpp b/contrib/libboost/boost_1_65_0/boost/archive/detail/utf8_codecvt_facet.hpp
new file mode 100644
index 00000000000..a40104abea6
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/archive/detail/utf8_codecvt_facet.hpp
@@ -0,0 +1,39 @@
+// Copyright (c) 2001 Ronald Garcia, Indiana University (garcia@osl.iu.edu)
+// Andrew Lumsdaine, Indiana University (lums@osl.iu.edu).
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_ARCHIVE_DETAIL_UTF8_CODECVT_FACET_HPP
+#define BOOST_ARCHIVE_DETAIL_UTF8_CODECVT_FACET_HPP
+
+#include <boost/config.hpp>
+
+#ifdef BOOST_NO_STD_WSTREAMBUF
+#error "wide char i/o not supported on this platform"
+#endif
+
+// std::codecvt_utf8 doesn't seem to work for any versions of msvc
+
+#if defined(_MSC_VER) || defined(BOOST_NO_CXX11_HDR_CODECVT)
+    // use boost's utf8 codecvt facet
+    #include <boost/archive/detail/decl.hpp>
+    #define BOOST_UTF8_BEGIN_NAMESPACE \
+         namespace boost { namespace archive { namespace detail {
+    #define BOOST_UTF8_DECL BOOST_ARCHIVE_DECL
+    #define BOOST_UTF8_END_NAMESPACE }}}
+
+    #include <boost/detail/utf8_codecvt_facet.hpp>
+
+    #undef BOOST_UTF8_END_NAMESPACE
+    #undef BOOST_UTF8_DECL
+    #undef BOOST_UTF8_BEGIN_NAMESPACE
+#else
+    // use the standard vendor supplied facet
+    #include <codecvt>
+    namespace boost { namespace archive { namespace detail {
+        typedef std::codecvt_utf8<wchar_t> utf8_codecvt_facet;
+    } } }
+#endif
+
+#endif // BOOST_ARCHIVE_DETAIL_UTF8_CODECVT_FACET_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/dinkumware.hpp b/contrib/libboost/boost_1_65_0/boost/archive/dinkumware.hpp
new file mode 100644
index 00000000000..90ba6271cdd
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/archive/dinkumware.hpp
@@ -0,0 +1,224 @@
+#ifndef BOOST_ARCHIVE_DINKUMWARE_HPP
+#define BOOST_ARCHIVE_DINKUMWARE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// dinkumware.hpp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+// this file adds a couple of things that are missing from the dinkumware
+// implementation of the standard library.
+
+#include <iterator>
+#include <string>
+
+#include <boost/config.hpp>
+#include <boost/cstdint.hpp>
+
+namespace std {
+
+// define i/o operators for 64 bit integers
+template<class CharType>
+basic_ostream<CharType> & 
+operator<<(basic_ostream<CharType> & os, boost::uint64_t t){
+    // octal rendering of 64 bit number would be 22 octets + eos
+    CharType d[23];
+    unsigned int radix;
+
+    if(os.flags() & (int)std::ios_base::hex)
+        radix = 16;
+    else
+    if(os.flags() & (int)std::ios_base::oct)
+        radix = 8;
+    else
+    //if(s.flags() & (int)std::ios_base::dec)
+        radix =  10;
+    unsigned int i = 0;
+    do{
+        unsigned int j = t % radix;
+        d[i++] = j + ((j < 10) ? '0' : ('a' - 10));
+        t /= radix;
+    }
+    while(t > 0);
+    d[i--] = '\0';
+
+    // reverse digits
+    unsigned int j = 0;
+    while(j < i){
+        CharType k = d[i];
+        d[i] = d[j];
+        d[j] = k;
+        --i;++j;
+    }
+    os << d;
+    return os;
+
+}
+
+template<class CharType>
+basic_ostream<CharType> & 
+operator<<(basic_ostream<CharType> &os, boost::int64_t t){
+    if(0 <= t){
+        os << static_cast<boost::uint64_t>(t);
+    }
+    else{
+        os.put('-');
+        os << -t;
+    }
+    return os;
+}
+
+template<class CharType>
+basic_istream<CharType> & 
+operator>>(basic_istream<CharType> &is, boost::int64_t & t){
+    CharType d;
+    do{
+        d = is.get();
+    }
+    while(::isspace(d));
+    bool negative = (d == '-');
+    if(negative)
+        d = is.get();
+    unsigned int radix;
+    if(is.flags() & (int)std::ios_base::hex)
+        radix = 16;
+    else
+    if(is.flags() & (int)std::ios_base::oct)
+        radix = 8;
+    else
+    //if(s.flags() & (int)std::ios_base::dec)
+        radix =  10;
+    t = 0;
+    do{
+        if('0' <= d && d <= '9')
+            t = t * radix + (d - '0');
+        else
+        if('a' <= d && d <= 'f')
+            t = t * radix + (d - 'a' + 10);
+        else
+            break;
+        d = is.get();
+    }
+    while(!is.fail());
+    // restore the delimiter
+    is.putback(d);
+    is.clear();
+    if(negative)
+        t = -t;
+    return is;
+}
+
+template<class CharType>
+basic_istream<CharType> & 
+operator>>(basic_istream<CharType> &is, boost::uint64_t & t){
+    boost::int64_t it;
+    is >> it;
+    t = it;
+    return is;
+}
+
+//#endif
+
+template<>
+class back_insert_iterator<basic_string<char> > : public 
+    iterator<output_iterator_tag, char>
+{
+public:
+    typedef basic_string<char> container_type;
+    typedef container_type::reference reference;
+
+    explicit back_insert_iterator(container_type & s)
+        : container(& s)
+    {}    // construct with container
+    
+    back_insert_iterator<container_type> & operator=(
+        container_type::const_reference Val_
+    ){    // push value into container
+        //container->push_back(Val_);
+        *container += Val_;
+        return (*this);
+    }
+
+    back_insert_iterator<container_type> & operator*(){
+        return (*this);
+    }
+
+    back_insert_iterator<container_type> & operator++(){
+        // pretend to preincrement
+        return (*this);
+    }
+
+    back_insert_iterator<container_type> operator++(int){
+        // pretend to postincrement
+        return (*this);
+    }
+
+protected:
+    container_type *container;    // pointer to container
+};
+
+template<char> 
+inline back_insert_iterator<basic_string<char> > back_inserter(
+    basic_string<char> & s
+){
+    return (std::back_insert_iterator<basic_string<char> >(s));
+}
+
+template<>
+class back_insert_iterator<basic_string<wchar_t> > : public 
+    iterator<output_iterator_tag, wchar_t>
+{
+public:
+    typedef basic_string<wchar_t> container_type;
+    typedef container_type::reference reference;
+
+    explicit back_insert_iterator(container_type & s)
+        : container(& s)
+    {}    // construct with container
+    
+    back_insert_iterator<container_type> & operator=(
+        container_type::const_reference Val_
+    ){    // push value into container
+        //container->push_back(Val_);
+        *container += Val_;
+        return (*this);
+    }
+
+    back_insert_iterator<container_type> & operator*(){
+        return (*this);
+    }
+
+    back_insert_iterator<container_type> & operator++(){
+        // pretend to preincrement
+        return (*this);
+    }
+
+    back_insert_iterator<container_type> operator++(int){
+        // pretend to postincrement
+        return (*this);
+    }
+
+protected:
+    container_type *container;    // pointer to container
+};
+
+template<wchar_t> 
+inline back_insert_iterator<basic_string<wchar_t> > back_inserter(
+    basic_string<wchar_t> & s
+){
+    return (std::back_insert_iterator<basic_string<wchar_t> >(s));
+}
+
+} // namespace std
+
+#endif //BOOST_ARCHIVE_DINKUMWARE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/impl/archive_serializer_map.ipp b/contrib/libboost/boost_1_65_0/boost/archive/impl/archive_serializer_map.ipp
new file mode 100644
index 00000000000..7f163ec4076
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/archive/impl/archive_serializer_map.ipp
@@ -0,0 +1,75 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// archive_serializer_map.ipp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org for updates, documentation, and revision history.
+
+//////////////////////////////////////////////////////////////////////
+// implementation of basic_text_iprimitive overrides for the combination
+// of template parameters used to implement a text_iprimitive
+
+#include <boost/config.hpp>
+#include <boost/archive/detail/archive_serializer_map.hpp>
+#include <boost/archive/detail/basic_serializer_map.hpp>
+#include <boost/serialization/singleton.hpp>
+
+namespace boost {
+namespace archive {
+namespace detail {
+
+#ifdef BOOST_MSVC
+#  pragma warning(push)
+#  pragma warning(disable : 4511 4512)
+#endif
+
+namespace extra_detail { // anon
+    template<class Archive>
+    class map : public basic_serializer_map 
+    {};
+}
+
+#ifdef BOOST_MSVC
+#  pragma warning(pop)
+#endif
+
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL bool
+archive_serializer_map<Archive>::insert(const basic_serializer * bs){
+    return boost::serialization::singleton<
+        extra_detail::map<Archive>
+    >::get_mutable_instance().insert(bs);
+}
+
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+archive_serializer_map<Archive>::erase(const basic_serializer * bs){
+    BOOST_ASSERT(! boost::serialization::singleton<
+            extra_detail::map<Archive>
+        >::is_destroyed()
+    );
+    if(boost::serialization::singleton<
+        extra_detail::map<Archive>
+    >::is_destroyed())
+        return;
+    boost::serialization::singleton<
+        extra_detail::map<Archive>
+    >::get_mutable_instance().erase(bs);
+}
+
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL const basic_serializer *
+archive_serializer_map<Archive>::find(
+    const boost::serialization::extended_type_info & eti
+) {
+    return boost::serialization::singleton<
+        extra_detail::map<Archive>
+    >::get_const_instance().find(eti);
+}
+
+} // namespace detail
+} // namespace archive
+} // namespace boost
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/impl/basic_binary_iarchive.ipp b/contrib/libboost/boost_1_65_0/boost/archive/impl/basic_binary_iarchive.ipp
new file mode 100644
index 00000000000..d5619ab6cf3
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/archive/impl/basic_binary_iarchive.ipp
@@ -0,0 +1,134 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// basic_binary_iarchive.ipp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+#include <string>
+#include <boost/assert.hpp>
+#include <algorithm>
+#include <cstring>
+
+#include <boost/config.hpp>
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{ 
+    using ::memcpy; 
+    using ::strlen;
+    using ::size_t;
+}
+#endif
+
+#include <boost/detail/workaround.hpp>
+#include <boost/detail/endian.hpp>
+
+#include <boost/archive/basic_binary_iarchive.hpp>
+
+namespace boost {
+namespace archive {
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// implementation of binary_binary_archive
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+basic_binary_iarchive<Archive>::load_override(class_name_type & t){
+    std::string cn;
+    cn.reserve(BOOST_SERIALIZATION_MAX_KEY_SIZE);
+    load_override(cn);
+    if(cn.size() > (BOOST_SERIALIZATION_MAX_KEY_SIZE - 1))
+        boost::serialization::throw_exception(
+            archive_exception(archive_exception::invalid_class_name)
+        );
+    std::memcpy(t, cn.data(), cn.size());
+    // borland tweak
+    t.t[cn.size()] = '\0';
+}
+
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+basic_binary_iarchive<Archive>::init(void){
+    // read signature in an archive version independent manner
+    std::string file_signature;
+    
+    #if 0 // commented out since it interfers with derivation
+    BOOST_TRY {
+        std::size_t l;
+        this->This()->load(l);
+        if(l == std::strlen(BOOST_ARCHIVE_SIGNATURE())) {
+            // borland de-allocator fixup
+            #if BOOST_WORKAROUND(_RWSTD_VER, BOOST_TESTED_AT(20101))
+            if(NULL != file_signature.data())
+            #endif
+                file_signature.resize(l);
+            // note breaking a rule here - could be a problem on some platform
+            if(0 < l)
+                this->This()->load_binary(&(*file_signature.begin()), l);
+        }
+    }
+    BOOST_CATCH(archive_exception const &) {  // catch stream_error archive exceptions
+        // will cause invalid_signature archive exception to be thrown below
+        file_signature = "";   
+    }
+    BOOST_CATCH_END
+    #else
+    // https://svn.boost.org/trac/boost/ticket/7301
+    * this->This() >> file_signature;
+    #endif
+
+    if(file_signature != BOOST_ARCHIVE_SIGNATURE())
+        boost::serialization::throw_exception(
+            archive_exception(archive_exception::invalid_signature)
+        );
+
+    // make sure the version of the reading archive library can
+    // support the format of the archive being read
+    library_version_type input_library_version;
+    //* this->This() >> input_library_version;
+    {
+        int v = 0;
+        v = this->This()->m_sb.sbumpc();
+        #if defined(BOOST_LITTLE_ENDIAN)
+        if(v < 6){
+            ;
+        }
+        else
+        if(v < 7){
+            // version 6 - next byte should be zero
+            this->This()->m_sb.sbumpc();
+        }
+        else
+        if(v < 8){
+            int x1;
+            // version 7 = might be followed by zero or some other byte
+            x1 = this->This()->m_sb.sgetc();
+            // it's =a zero, push it back
+            if(0 == x1)
+                this->This()->m_sb.sbumpc();
+        }
+        else{
+            // version 8+ followed by a zero
+            this->This()->m_sb.sbumpc();
+        }
+        #elif defined(BOOST_BIG_ENDIAN)
+        if(v == 0)
+            v = this->This()->m_sb.sbumpc();
+        #endif
+        input_library_version = static_cast<library_version_type>(v);
+    }
+    
+    #if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3205))
+    this->set_library_version(input_library_version);
+    #else
+    detail::basic_iarchive::set_library_version(input_library_version);
+    #endif
+    
+    if(BOOST_ARCHIVE_VERSION() < input_library_version)
+        boost::serialization::throw_exception(
+            archive_exception(archive_exception::unsupported_version)
+        );
+}
+
+} // namespace archive
+} // namespace boost
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/impl/basic_binary_iprimitive.ipp b/contrib/libboost/boost_1_65_0/boost/archive/impl/basic_binary_iprimitive.ipp
new file mode 100644
index 00000000000..bbe933ccf63
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/archive/impl/basic_binary_iprimitive.ipp
@@ -0,0 +1,171 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// basic_binary_iprimitive.ipp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+#include <boost/assert.hpp>
+#include <cstddef> // size_t, NULL
+#include <cstring> // memcpy
+
+#include <boost/config.hpp>
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{ 
+    using ::size_t;
+    using ::memcpy;
+} // namespace std
+#endif
+
+#include <boost/serialization/throw_exception.hpp>
+#include <boost/core/no_exceptions_support.hpp>
+#include <boost/archive/archive_exception.hpp>
+#include <boost/archive/basic_binary_iprimitive.hpp> 
+
+namespace boost {
+namespace archive {
+
+//////////////////////////////////////////////////////////////////////
+// implementation of basic_binary_iprimitive
+
+template<class Archive, class Elem, class Tr>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+basic_binary_iprimitive<Archive, Elem, Tr>::init()
+{
+    // Detect  attempts to pass native binary archives across
+    // incompatible platforms. This is not fool proof but its
+    // better than nothing.
+    unsigned char size;
+    this->This()->load(size);
+    if(sizeof(int) != size)
+        boost::serialization::throw_exception(
+            archive_exception(
+                archive_exception::incompatible_native_format,
+                "size of int"
+            )
+        );
+    this->This()->load(size);
+    if(sizeof(long) != size)
+        boost::serialization::throw_exception(
+            archive_exception(
+                archive_exception::incompatible_native_format,
+                "size of long"
+            )
+        );
+    this->This()->load(size);
+    if(sizeof(float) != size)
+        boost::serialization::throw_exception(
+            archive_exception(
+                archive_exception::incompatible_native_format,
+                "size of float"
+            )
+        );
+    this->This()->load(size);
+    if(sizeof(double) != size)
+        boost::serialization::throw_exception(
+            archive_exception(
+                archive_exception::incompatible_native_format,
+                "size of double"
+            )
+        );
+
+    // for checking endian
+    int i;
+    this->This()->load(i);
+    if(1 != i)
+        boost::serialization::throw_exception(
+            archive_exception(
+                archive_exception::incompatible_native_format,
+                "endian setting"
+            )
+        );
+}
+
+#ifndef BOOST_NO_CWCHAR
+template<class Archive, class Elem, class Tr>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+basic_binary_iprimitive<Archive, Elem, Tr>::load(wchar_t * ws)
+{
+    std::size_t l; // number of wchar_t !!!
+    this->This()->load(l);
+    load_binary(ws, l * sizeof(wchar_t) / sizeof(char));
+    ws[l] = L'\0';
+}
+#endif
+
+template<class Archive, class Elem, class Tr>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+basic_binary_iprimitive<Archive, Elem, Tr>::load(std::string & s)
+{
+    std::size_t l;
+    this->This()->load(l);
+    // borland de-allocator fixup
+    #if BOOST_WORKAROUND(_RWSTD_VER, BOOST_TESTED_AT(20101))
+    if(NULL != s.data())
+    #endif
+        s.resize(l);
+    // note breaking a rule here - could be a problem on some platform
+    if(0 < l)
+        load_binary(&(*s.begin()), l);
+}
+
+template<class Archive, class Elem, class Tr>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+basic_binary_iprimitive<Archive, Elem, Tr>::load(char * s)
+{
+    std::size_t l;
+    this->This()->load(l);
+    load_binary(s, l);
+    s[l] = '\0';
+}
+
+#ifndef BOOST_NO_STD_WSTRING
+template<class Archive, class Elem, class Tr>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+basic_binary_iprimitive<Archive, Elem, Tr>::load(std::wstring & ws)
+{
+    std::size_t l;
+    this->This()->load(l);
+    // borland de-allocator fixup
+    #if BOOST_WORKAROUND(_RWSTD_VER, BOOST_TESTED_AT(20101))
+    if(NULL != ws.data())
+    #endif
+        ws.resize(l);
+    // note breaking a rule here - is could be a problem on some platform
+    load_binary(const_cast<wchar_t *>(ws.data()), l * sizeof(wchar_t) / sizeof(char));
+}
+#endif
+
+template<class Archive, class Elem, class Tr>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL
+basic_binary_iprimitive<Archive, Elem, Tr>::basic_binary_iprimitive(
+    std::basic_streambuf<Elem, Tr> & sb, 
+    bool no_codecvt
+) :
+#ifndef BOOST_NO_STD_LOCALE
+    m_sb(sb),
+    codecvt_null_facet(1),
+    locale_saver(m_sb),
+    archive_locale(sb.getloc(), & codecvt_null_facet)
+{
+    if(! no_codecvt){
+        m_sb.pubsync();
+        m_sb.pubimbue(archive_locale);
+    }
+}
+#else
+    m_sb(sb)
+{}
+#endif
+
+// scoped_ptr requires that g be a complete type at time of
+// destruction so define destructor here rather than in the header
+template<class Archive, class Elem, class Tr>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL
+basic_binary_iprimitive<Archive, Elem, Tr>::~basic_binary_iprimitive(){}
+
+} // namespace archive
+} // namespace boost
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/impl/basic_binary_oarchive.ipp b/contrib/libboost/boost_1_65_0/boost/archive/impl/basic_binary_oarchive.ipp
new file mode 100644
index 00000000000..d5a019d32bc
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/archive/impl/basic_binary_oarchive.ipp
@@ -0,0 +1,42 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// basic_binary_oarchive.ipp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+#include <string>
+#include <boost/assert.hpp>
+#include <algorithm>
+#include <cstring>
+
+#include <boost/config.hpp>
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{ 
+    using ::memcpy; 
+}
+#endif
+
+#include <boost/archive/basic_binary_oarchive.hpp>
+
+namespace boost {
+namespace archive {
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// implementation of binary_binary_oarchive
+
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+basic_binary_oarchive<Archive>::init(){
+    // write signature in an archive version independent manner
+    const std::string file_signature(BOOST_ARCHIVE_SIGNATURE());
+    * this->This() << file_signature;
+    // write library version
+    const library_version_type v(BOOST_ARCHIVE_VERSION());
+    * this->This() << v;
+}
+
+} // namespace archive
+} // namespace boost
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/impl/basic_binary_oprimitive.ipp b/contrib/libboost/boost_1_65_0/boost/archive/impl/basic_binary_oprimitive.ipp
new file mode 100644
index 00000000000..7b042173a48
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/archive/impl/basic_binary_oprimitive.ipp
@@ -0,0 +1,126 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// basic_binary_oprimitive.ipp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+#include <ostream>
+#include <cstddef> // NULL
+#include <cstring>
+
+#include <boost/config.hpp>
+
+#if defined(BOOST_NO_STDC_NAMESPACE) && ! defined(__LIBCOMO__)
+namespace std{ 
+    using ::strlen; 
+} // namespace std
+#endif
+
+#ifndef BOOST_NO_CWCHAR
+#include <cwchar>
+#ifdef BOOST_NO_STDC_NAMESPACE
+namespace std{ using ::wcslen; }
+#endif
+#endif
+
+#include <boost/archive/basic_binary_oprimitive.hpp>
+#include <boost/core/no_exceptions_support.hpp>
+
+namespace boost {
+namespace archive {
+
+//////////////////////////////////////////////////////////////////////
+// implementation of basic_binary_oprimitive
+
+template<class Archive, class Elem, class Tr>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+basic_binary_oprimitive<Archive, Elem, Tr>::init()
+{
+    // record native sizes of fundamental types
+    // this is to permit detection of attempts to pass
+    // native binary archives accross incompatible machines.
+    // This is not foolproof but its better than nothing.
+    this->This()->save(static_cast<unsigned char>(sizeof(int)));
+    this->This()->save(static_cast<unsigned char>(sizeof(long)));
+    this->This()->save(static_cast<unsigned char>(sizeof(float)));
+    this->This()->save(static_cast<unsigned char>(sizeof(double)));
+    // for checking endianness
+    this->This()->save(int(1));
+}
+
+template<class Archive, class Elem, class Tr>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+basic_binary_oprimitive<Archive, Elem, Tr>::save(const char * s)
+{
+    std::size_t l = std::strlen(s);
+    this->This()->save(l);
+    save_binary(s, l);
+}
+
+template<class Archive, class Elem, class Tr>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+basic_binary_oprimitive<Archive, Elem, Tr>::save(const std::string &s)
+{
+    std::size_t l = static_cast<std::size_t>(s.size());
+    this->This()->save(l);
+    save_binary(s.data(), l);
+}
+
+#ifndef BOOST_NO_CWCHAR
+#ifndef BOOST_NO_INTRINSIC_WCHAR_T
+template<class Archive, class Elem, class Tr>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+basic_binary_oprimitive<Archive, Elem, Tr>::save(const wchar_t * ws)
+{
+    std::size_t l = std::wcslen(ws);
+    this->This()->save(l);
+    save_binary(ws, l * sizeof(wchar_t) / sizeof(char));
+}
+#endif
+
+#ifndef BOOST_NO_STD_WSTRING
+template<class Archive, class Elem, class Tr>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+basic_binary_oprimitive<Archive, Elem, Tr>::save(const std::wstring &ws)
+{
+    std::size_t l = ws.size();
+    this->This()->save(l);
+    save_binary(ws.data(), l * sizeof(wchar_t) / sizeof(char));
+}
+#endif
+#endif // BOOST_NO_CWCHAR
+
+template<class Archive, class Elem, class Tr>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL
+basic_binary_oprimitive<Archive, Elem, Tr>::basic_binary_oprimitive(
+    std::basic_streambuf<Elem, Tr> & sb, 
+    bool no_codecvt
+) : 
+#ifndef BOOST_NO_STD_LOCALE
+    m_sb(sb),
+    codecvt_null_facet(1),
+    locale_saver(m_sb),
+    archive_locale(sb.getloc(), & codecvt_null_facet)
+{
+    if(! no_codecvt){
+        m_sb.pubsync();
+        m_sb.pubimbue(archive_locale);
+    }
+}
+#else
+    m_sb(sb)
+{}
+#endif
+
+// scoped_ptr requires that g be a complete type at time of
+// destruction so define destructor here rather than in the header
+template<class Archive, class Elem, class Tr>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL
+basic_binary_oprimitive<Archive, Elem, Tr>::~basic_binary_oprimitive(){}
+
+} // namespace archive
+} // namespace boost
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/impl/basic_text_iarchive.ipp b/contrib/libboost/boost_1_65_0/boost/archive/impl/basic_text_iarchive.ipp
new file mode 100644
index 00000000000..9ec8c6588c8
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/archive/impl/basic_text_iarchive.ipp
@@ -0,0 +1,76 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// basic_text_iarchive.ipp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+#include <string>
+#include <algorithm>
+#include <cstring>
+
+#include <boost/config.hpp>
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{ 
+    using ::memcpy; 
+}
+#endif
+
+#include <boost/detail/workaround.hpp>
+#include <boost/serialization/string.hpp>
+#include <boost/archive/basic_text_iarchive.hpp>
+
+namespace boost {
+namespace archive {
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// implementation of text_text_archive
+
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+basic_text_iarchive<Archive>::load_override(class_name_type & t){
+    std::string cn;
+    cn.reserve(BOOST_SERIALIZATION_MAX_KEY_SIZE);
+    load_override(cn);
+    if(cn.size() > (BOOST_SERIALIZATION_MAX_KEY_SIZE - 1))
+        boost::serialization::throw_exception(
+            archive_exception(archive_exception::invalid_class_name)
+        );
+    std::memcpy(t, cn.data(), cn.size());
+    // borland tweak
+    t.t[cn.size()] = '\0';
+}
+
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+basic_text_iarchive<Archive>::init(void){
+    // read signature in an archive version independent manner
+    std::string file_signature;
+    * this->This() >> file_signature;
+    if(file_signature != BOOST_ARCHIVE_SIGNATURE())
+        boost::serialization::throw_exception(
+            archive_exception(archive_exception::invalid_signature)
+        );
+
+    // make sure the version of the reading archive library can
+    // support the format of the archive being read
+    library_version_type input_library_version;
+    * this->This() >> input_library_version;
+
+    #if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3205))
+    this->set_library_version(input_library_version);
+    #else
+    detail::basic_iarchive::set_library_version(input_library_version);
+    #endif
+
+    // extra little .t is to get around borland quirk
+    if(BOOST_ARCHIVE_VERSION() < input_library_version)
+        boost::serialization::throw_exception(
+            archive_exception(archive_exception::unsupported_version)
+        );
+}
+
+} // namespace archive
+} // namespace boost
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/impl/basic_text_iprimitive.ipp b/contrib/libboost/boost_1_65_0/boost/archive/impl/basic_text_iprimitive.ipp
new file mode 100644
index 00000000000..4e44728068d
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/archive/impl/basic_text_iprimitive.ipp
@@ -0,0 +1,137 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// basic_text_iprimitive.ipp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org for updates, documentation, and revision history.
+
+#include <cstddef> // size_t, NULL
+#include <limits> // NULL
+
+#include <boost/config.hpp>
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{ 
+    using ::size_t; 
+} // namespace std
+#endif
+
+#include <boost/serialization/throw_exception.hpp>
+
+#include <boost/archive/basic_text_iprimitive.hpp>
+
+#include <boost/archive/iterators/remove_whitespace.hpp>
+#include <boost/archive/iterators/istream_iterator.hpp>
+#include <boost/archive/iterators/binary_from_base64.hpp>
+#include <boost/archive/iterators/transform_width.hpp>
+
+namespace boost {
+namespace archive {
+
+namespace detail {
+    template<class CharType>
+    static inline bool is_whitespace(CharType c);
+
+    template<>
+    inline bool is_whitespace(char t){
+        return 0 != std::isspace(t);
+    }
+
+    #ifndef BOOST_NO_CWCHAR
+    template<>
+    inline bool is_whitespace(wchar_t t){
+        return 0 != std::iswspace(t);
+    }
+    #endif
+} // detail
+
+// translate base64 text into binary and copy into buffer
+// until buffer is full.
+template<class IStream>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+basic_text_iprimitive<IStream>::load_binary(
+    void *address, 
+    std::size_t count
+){
+    typedef typename IStream::char_type CharType;
+    
+    if(0 == count)
+        return;
+        
+    BOOST_ASSERT(
+        static_cast<std::size_t>((std::numeric_limits<std::streamsize>::max)())
+        > (count + sizeof(CharType) - 1)/sizeof(CharType)
+    );
+        
+    if(is.fail())
+        boost::serialization::throw_exception(
+            archive_exception(archive_exception::input_stream_error)
+        );
+    // convert from base64 to binary
+    typedef typename
+        iterators::transform_width<
+            iterators::binary_from_base64<
+                iterators::remove_whitespace<
+                    iterators::istream_iterator<CharType>
+                >
+                ,typename IStream::int_type
+            >
+            ,8
+            ,6
+            ,CharType
+        > 
+        binary;
+        
+    binary i = binary(iterators::istream_iterator<CharType>(is));
+
+    char * caddr = static_cast<char *>(address);
+    
+    // take care that we don't increment anymore than necessary
+    while(count-- > 0){
+        *caddr++ = static_cast<char>(*i++);
+    }
+
+    // skip over any excess input
+    for(;;){
+        typename IStream::int_type r;
+        r = is.get();
+        if(is.eof())
+            break;
+        if(detail::is_whitespace(static_cast<CharType>(r)))
+            break;
+    }
+}
+    
+template<class IStream>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL
+basic_text_iprimitive<IStream>::basic_text_iprimitive(
+    IStream  &is_,
+    bool no_codecvt
+) :
+    is(is_),
+    flags_saver(is_),
+    precision_saver(is_),
+#ifndef BOOST_NO_STD_LOCALE
+    codecvt_null_facet(1),
+    archive_locale(is.getloc(), & codecvt_null_facet),
+    locale_saver(is)
+{
+    if(! no_codecvt){
+        is_.sync();
+        is_.imbue(archive_locale);
+    }
+    is_ >> std::noboolalpha;
+}
+#else
+{}
+#endif
+
+template<class IStream>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL
+basic_text_iprimitive<IStream>::~basic_text_iprimitive(){
+}
+
+} // namespace archive
+} // namespace boost
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/impl/basic_text_oarchive.ipp b/contrib/libboost/boost_1_65_0/boost/archive/impl/basic_text_oarchive.ipp
new file mode 100644
index 00000000000..44bc1401fd6
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/archive/impl/basic_text_oarchive.ipp
@@ -0,0 +1,62 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// basic_text_oarchive.ipp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+#include <string>
+#include <boost/assert.hpp>
+#include <cstring>
+
+#include <boost/config.hpp>
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{ 
+    using ::memcpy; 
+}
+#endif
+
+#include <boost/archive/basic_text_oarchive.hpp>
+
+namespace boost {
+namespace archive {
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// implementation of basic_text_oarchive
+
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+basic_text_oarchive<Archive>::newtoken()
+{
+    switch(delimiter){
+    default:
+        BOOST_ASSERT(false);
+        break;
+    case eol:
+        this->This()->put('\n');
+        delimiter = space;
+        break;
+    case space:
+        this->This()->put(' ');
+        break;
+    case none:
+        delimiter = space;
+        break;
+    }
+}
+
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+basic_text_oarchive<Archive>::init(){
+    // write signature in an archive version independent manner
+    const std::string file_signature(BOOST_ARCHIVE_SIGNATURE());
+    * this->This() << file_signature;
+    // write library version
+    const library_version_type v(BOOST_ARCHIVE_VERSION());
+    * this->This() << v;
+}
+
+} // namespace archive
+} // namespace boost
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/impl/basic_text_oprimitive.ipp b/contrib/libboost/boost_1_65_0/boost/archive/impl/basic_text_oprimitive.ipp
new file mode 100644
index 00000000000..6030fd44c57
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/archive/impl/basic_text_oprimitive.ipp
@@ -0,0 +1,115 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// basic_text_oprimitive.ipp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+#include <cstddef> // NULL
+#include <algorithm> // std::copy
+#include <exception> // std::uncaught_exception
+#include <boost/config.hpp>
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{ 
+    using ::size_t; 
+} // namespace std
+#endif
+
+#include <boost/archive/basic_text_oprimitive.hpp>
+
+#include <boost/archive/iterators/base64_from_binary.hpp>
+#include <boost/archive/iterators/insert_linebreaks.hpp>
+#include <boost/archive/iterators/transform_width.hpp>
+#include <boost/archive/iterators/ostream_iterator.hpp>
+
+namespace boost {
+namespace archive {
+
+// translate to base64 and copy in to buffer.
+template<class OStream>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+basic_text_oprimitive<OStream>::save_binary(
+    const void *address, 
+    std::size_t count
+){
+    typedef typename OStream::char_type CharType;
+    
+    if(0 == count)
+        return;
+    
+    if(os.fail())
+        boost::serialization::throw_exception(
+            archive_exception(archive_exception::output_stream_error)
+        );
+        
+    os.put('\n');
+    
+    typedef 
+        boost::archive::iterators::insert_linebreaks<
+            boost::archive::iterators::base64_from_binary<
+                boost::archive::iterators::transform_width<
+                    const char *,
+                    6,
+                    8
+                >
+            > 
+            ,76
+            ,const char // cwpro8 needs this
+        > 
+        base64_text;
+
+    boost::archive::iterators::ostream_iterator<CharType> oi(os);
+    std::copy(
+        base64_text(static_cast<const char *>(address)),
+        base64_text(
+            static_cast<const char *>(address) + count
+        ),
+        oi
+    );
+    
+    std::size_t tail = count % 3;
+    if(tail > 0){
+        *oi++ = '=';
+        if(tail < 2)
+            *oi = '=';
+    }
+}
+
+template<class OStream>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL
+basic_text_oprimitive<OStream>::basic_text_oprimitive(
+    OStream & os_,
+    bool no_codecvt
+) : 
+    os(os_),
+    flags_saver(os_),
+    precision_saver(os_),
+#ifndef BOOST_NO_STD_LOCALE
+    codecvt_null_facet(1),
+    archive_locale(os.getloc(), & codecvt_null_facet),
+    locale_saver(os)
+{
+    if(! no_codecvt){
+        os_.flush();
+        os_.imbue(archive_locale);
+    }
+    os_ << std::noboolalpha;
+}
+#else
+{}
+#endif
+
+
+template<class OStream>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL
+basic_text_oprimitive<OStream>::~basic_text_oprimitive(){
+    if(std::uncaught_exception())
+        return;
+    os << std::endl;
+}
+
+} //namespace boost 
+} //namespace archive 
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/impl/basic_xml_grammar.hpp b/contrib/libboost/boost_1_65_0/boost/archive/impl/basic_xml_grammar.hpp
new file mode 100644
index 00000000000..6d4e4683f6a
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/archive/impl/basic_xml_grammar.hpp
@@ -0,0 +1,173 @@
+#ifndef BOOST_ARCHIVE_BASIC_XML_GRAMMAR_HPP
+#define BOOST_ARCHIVE_BASIC_XML_GRAMMAR_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// basic_xml_grammar.hpp
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+// this module is derived from simplexml.cpp - an example shipped as part of
+// the spirit parser.  This example contains the following notice:
+/*=============================================================================
+    simplexml.cpp
+
+    Spirit V1.3
+    URL: http://spirit.sourceforge.net/
+
+    Copyright (c) 2001, Daniel C. Nuffer
+
+    This software is provided 'as-is', without any express or implied
+    warranty. In no event will the copyright holder be held liable for
+    any damages arising from the use of this software.
+
+    Permission is granted to anyone to use this software for any purpose,
+    including commercial applications, and to alter it and redistribute
+    it freely, subject to the following restrictions:
+
+    1.  The origin of this software must not be misrepresented; you must
+        not claim that you wrote the original software. If you use this
+        software in a product, an acknowledgment in the product documentation
+        would be appreciated but is not required.
+
+    2.  Altered source versions must be plainly marked as such, and must
+        not be misrepresented as being the original software.
+
+    3.  This notice may not be removed or altered from any source
+        distribution.
+=============================================================================*/
+#include <string>
+
+#include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
+
+#include <boost/spirit/include/classic_rule.hpp>
+#include <boost/spirit/include/classic_chset.hpp>
+
+#include <boost/archive/basic_archive.hpp>
+#include <boost/serialization/tracking.hpp>
+#include <boost/serialization/version.hpp>
+
+namespace boost {
+namespace archive {
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// XML grammar parsing
+
+template<class CharType>
+class basic_xml_grammar {
+public:
+    // The following is not necessary according to DR45, but at least
+    // one compiler (Compaq C++ 6.5 in strict_ansi mode) chokes otherwise.
+    struct return_values;
+    friend struct return_values;
+    
+private:
+    typedef typename std::basic_istream<CharType> IStream;
+    typedef typename std::basic_string<CharType> StringType;
+    typedef typename boost::spirit::classic::chset<CharType> chset_t;
+    typedef typename boost::spirit::classic::chlit<CharType> chlit_t;
+    typedef typename boost::spirit::classic::scanner<
+        typename  std::basic_string<CharType>::iterator
+    > scanner_t;
+    typedef typename boost::spirit::classic::rule<scanner_t> rule_t;
+    // Start grammar definition
+    rule_t    
+        Reference,
+        Eq, 
+        STag,
+        ETag,
+        LetterOrUnderscoreOrColon,
+        AttValue, 
+        CharRef1, 
+        CharRef2, 
+        CharRef, 
+        AmpRef,
+        LTRef,
+        GTRef,
+        AposRef,
+        QuoteRef,
+        CharData,
+        CharDataChars,
+        content,
+        AmpName,
+        LTName,
+        GTName,
+        ClassNameChar,
+        ClassName,
+        Name,
+        XMLDecl,
+        XMLDeclChars,
+        DocTypeDecl,
+        DocTypeDeclChars,
+        ClassIDAttribute,
+        ObjectIDAttribute,
+        ClassNameAttribute,
+        TrackingAttribute,
+        VersionAttribute,
+        UnusedAttribute,
+        Attribute,
+        SignatureAttribute,
+        SerializationWrapper,
+        NameHead,
+        NameTail,
+        AttributeList,
+        S;
+
+    // XML Character classes
+    chset_t
+        BaseChar,
+        Ideographic,
+        Char, 
+        Letter, 
+        Digit,
+        CombiningChar,
+        Extender, 
+        Sch,
+        NameChar;
+
+    void init_chset();
+
+    bool my_parse(
+        IStream & is,
+        const rule_t &rule_, 
+        const CharType delimiter = L'>'
+    ) const ;
+public:
+    struct return_values {
+        StringType object_name;
+        StringType contents;
+        //class_id_type class_id;
+        int_least16_t class_id;
+        //object_id_type object_id;
+        uint_least32_t object_id;
+        //version_type version;
+        unsigned int version;
+        tracking_type tracking_level;
+        StringType class_name;
+        return_values() :
+            version(0),
+            tracking_level(false)
+        {}
+    } rv;
+    bool parse_start_tag(IStream & is) /*const*/;
+    bool parse_end_tag(IStream & is) const;
+    bool parse_string(IStream & is, StringType & s) /*const*/;
+    void init(IStream & is);
+    bool windup(IStream & is);
+    basic_xml_grammar();
+};
+
+} // namespace archive
+} // namespace boost
+
+#endif // BOOST_ARCHIVE_BASIC_XML_GRAMMAR_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/impl/basic_xml_iarchive.ipp b/contrib/libboost/boost_1_65_0/boost/archive/impl/basic_xml_iarchive.ipp
new file mode 100644
index 00000000000..625458b9eb5
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/archive/impl/basic_xml_iarchive.ipp
@@ -0,0 +1,115 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// basic_xml_iarchive.ipp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+#include <boost/assert.hpp>
+#include <cstddef> // NULL
+#include <algorithm>
+
+#include <boost/serialization/throw_exception.hpp>
+#include <boost/archive/xml_archive_exception.hpp>
+#include <boost/archive/basic_xml_iarchive.hpp>
+#include <boost/serialization/tracking.hpp>
+
+namespace boost {
+namespace archive {
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// implementation of xml_text_archive
+
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+basic_xml_iarchive<Archive>::load_start(const char *name){
+    // if there's no name
+    if(NULL == name)
+        return;
+    bool result = this->This()->gimpl->parse_start_tag(this->This()->get_is());
+    if(true != result){
+        boost::serialization::throw_exception(
+            archive_exception(archive_exception::input_stream_error)
+        );
+    }
+    // don't check start tag at highest level
+    ++depth;
+    return;
+}
+
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+basic_xml_iarchive<Archive>::load_end(const char *name){
+    // if there's no name
+    if(NULL == name)
+        return;
+    bool result = this->This()->gimpl->parse_end_tag(this->This()->get_is());
+    if(true != result){
+        boost::serialization::throw_exception(
+            archive_exception(archive_exception::input_stream_error)
+        );
+    }
+    
+    // don't check start tag at highest level
+    if(0 == --depth)
+        return;
+        
+    if(0 == (this->get_flags() & no_xml_tag_checking)){
+        // double check that the tag matches what is expected - useful for debug
+        if(0 != name[this->This()->gimpl->rv.object_name.size()]
+        || ! std::equal(
+                this->This()->gimpl->rv.object_name.begin(),
+                this->This()->gimpl->rv.object_name.end(),
+                name
+            )
+        ){
+            boost::serialization::throw_exception(
+                xml_archive_exception(
+                    xml_archive_exception::xml_archive_tag_mismatch,
+                    name
+                )
+            );
+        }
+    }
+}
+
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+basic_xml_iarchive<Archive>::load_override(object_id_type & t){
+    t = object_id_type(this->This()->gimpl->rv.object_id);
+}
+
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+basic_xml_iarchive<Archive>::load_override(version_type & t){
+    t = version_type(this->This()->gimpl->rv.version);
+}
+
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+basic_xml_iarchive<Archive>::load_override(class_id_type & t){
+    t = class_id_type(this->This()->gimpl->rv.class_id);
+}
+
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+basic_xml_iarchive<Archive>::load_override(tracking_type & t){
+    t = this->This()->gimpl->rv.tracking_level;
+}
+
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL
+basic_xml_iarchive<Archive>::basic_xml_iarchive(unsigned int flags) :
+    detail::common_iarchive<Archive>(flags),
+    depth(0)
+{}
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL
+basic_xml_iarchive<Archive>::~basic_xml_iarchive(){
+}
+
+} // namespace archive
+} // namespace boost
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/impl/basic_xml_oarchive.ipp b/contrib/libboost/boost_1_65_0/boost/archive/impl/basic_xml_oarchive.ipp
new file mode 100644
index 00000000000..3184413f382
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/archive/impl/basic_xml_oarchive.ipp
@@ -0,0 +1,272 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// basic_xml_oarchive.ipp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org for updates, documentation, and revision history.
+
+#include <algorithm>
+#include <cstddef> // NULL
+#include <cstring>
+#if defined(BOOST_NO_STDC_NAMESPACE) && ! defined(__LIBCOMO__)
+namespace std{
+    using ::strlen;
+} // namespace std
+#endif
+
+#include <boost/archive/basic_xml_archive.hpp>
+#include <boost/archive/basic_xml_oarchive.hpp>
+#include <boost/archive/xml_archive_exception.hpp>
+#include <boost/core/no_exceptions_support.hpp>
+
+namespace boost {
+namespace archive {
+
+namespace detail {
+template<class CharType>
+struct XML_name {
+    void operator()(CharType t) const{
+        const unsigned char lookup_table[] = {
+            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,0,0,0,0,0,0,0,0,0,0,0,1,1,0, // -.
+            1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0, // 0-9
+            0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, // A-
+            1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,1, // -Z _
+            0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, // a-
+            1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0, // -z
+            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
+        };
+        if((unsigned)t > 127)
+            return;
+        if(0 == lookup_table[(unsigned)t])
+            boost::serialization::throw_exception(
+                xml_archive_exception(
+                    xml_archive_exception::xml_archive_tag_name_error
+                )
+            );
+    }
+};
+
+} // namespace detail
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// implemenations of functions common to both types of xml output
+
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+basic_xml_oarchive<Archive>::write_attribute(
+    const char *attribute_name,
+    int t,
+    const char *conjunction
+){
+    this->This()->put(' ');
+    this->This()->put(attribute_name);
+    this->This()->put(conjunction);
+    this->This()->save(t);
+    this->This()->put('"');
+}
+
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+basic_xml_oarchive<Archive>::write_attribute(
+    const char *attribute_name,
+    const char *key
+){
+    this->This()->put(' ');
+    this->This()->put(attribute_name);
+    this->This()->put("=\"");
+    this->This()->save(key);
+    this->This()->put('"');
+}
+
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+basic_xml_oarchive<Archive>::indent(){
+    int i;
+    for(i = depth; i-- > 0;)
+        this->This()->put('\t');
+}
+
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+basic_xml_oarchive<Archive>::save_start(const char *name)
+{
+    if(NULL == name)
+        return;
+
+    // be sure name has no invalid characters
+    std::for_each(name, name + std::strlen(name), detail::XML_name<const char>());
+
+    end_preamble();
+    if(depth > 0){
+        this->This()->put('\n');
+        indent();
+    }
+    ++depth;
+    this->This()->put('<');
+    this->This()->save(name);
+    pending_preamble = true;
+    indent_next = false;
+}
+
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+basic_xml_oarchive<Archive>::save_end(const char *name)
+{
+    if(NULL == name)
+        return;
+
+    // be sure name has no invalid characters
+    std::for_each(name, name + std::strlen(name), detail::XML_name<const char>());
+
+    end_preamble();
+    --depth;
+    if(indent_next){
+        this->This()->put('\n');
+        indent();
+    }
+    indent_next = true;
+    this->This()->put("</");
+    this->This()->save(name);
+    this->This()->put('>');
+    if(0 == depth)
+        this->This()->put('\n');
+}
+
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+basic_xml_oarchive<Archive>::end_preamble(){
+    if(pending_preamble){
+        this->This()->put('>');
+        pending_preamble = false;
+    }
+}
+#if 0
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+basic_xml_oarchive<Archive>::save_override(const object_id_type & t)
+{
+    int i = t.t; // extra .t is for borland
+    write_attribute(BOOST_ARCHIVE_XML_OBJECT_ID(), i, "=\"_");
+}
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+basic_xml_oarchive<Archive>::save_override(
+    const object_reference_type & t,
+    int
+){
+    int i = t.t; // extra .t is for borland
+    write_attribute(BOOST_ARCHIVE_XML_OBJECT_REFERENCE(), i, "=\"_");
+}
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+basic_xml_oarchive<Archive>::save_override(const version_type & t)
+{
+    int i = t.t; // extra .t is for borland
+    write_attribute(BOOST_ARCHIVE_XML_VERSION(), i);
+}
+#endif
+
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+basic_xml_oarchive<Archive>::save_override(const object_id_type & t)
+{
+    // borland doesn't do conversion of STRONG_TYPEDEFs very well
+    const unsigned int i = t;
+    write_attribute(BOOST_ARCHIVE_XML_OBJECT_ID(), i, "=\"_");
+}
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+basic_xml_oarchive<Archive>::save_override(
+    const object_reference_type & t
+){
+    const unsigned int i = t;
+    write_attribute(BOOST_ARCHIVE_XML_OBJECT_REFERENCE(), i, "=\"_");
+}
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+basic_xml_oarchive<Archive>::save_override(const version_type & t)
+{
+    const unsigned int i = t;
+    write_attribute(BOOST_ARCHIVE_XML_VERSION(), i);
+}
+
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+basic_xml_oarchive<Archive>::save_override(const class_id_type & t)
+{
+    write_attribute(BOOST_ARCHIVE_XML_CLASS_ID(), t);
+}
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+basic_xml_oarchive<Archive>::save_override(
+    const class_id_reference_type & t
+){
+    write_attribute(BOOST_ARCHIVE_XML_CLASS_ID_REFERENCE(), t);
+}
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+basic_xml_oarchive<Archive>::save_override(
+    const class_id_optional_type & t
+){
+    write_attribute(BOOST_ARCHIVE_XML_CLASS_ID(), t);
+}
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+basic_xml_oarchive<Archive>::save_override(const class_name_type & t)
+{
+    const char * key = t;
+    if(NULL == key)
+        return;
+    write_attribute(BOOST_ARCHIVE_XML_CLASS_NAME(), key);
+}
+
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+basic_xml_oarchive<Archive>::save_override(const tracking_type & t)
+{
+    write_attribute(BOOST_ARCHIVE_XML_TRACKING(), t.t);
+}
+
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+basic_xml_oarchive<Archive>::init(){
+    // xml header
+    this->This()->put("<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\" ?>\n");
+    this->This()->put("<!DOCTYPE boost_serialization>\n");
+    // xml document wrapper - outer root
+    this->This()->put("<boost_serialization");
+    write_attribute("signature", BOOST_ARCHIVE_SIGNATURE());
+    write_attribute("version", BOOST_ARCHIVE_VERSION());
+    this->This()->put(">\n");
+}
+
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL void
+basic_xml_oarchive<Archive>::windup(){
+    // xml_trailer
+    this->This()->put("</boost_serialization>\n");
+}
+
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL
+basic_xml_oarchive<Archive>::basic_xml_oarchive(unsigned int flags) :
+    detail::common_oarchive<Archive>(flags),
+    depth(0),
+    pending_preamble(false),
+    indent_next(false)
+{
+}
+
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL
+basic_xml_oarchive<Archive>::~basic_xml_oarchive(){
+}
+
+} // namespace archive
+} // namespace boost
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/impl/text_iarchive_impl.ipp b/contrib/libboost/boost_1_65_0/boost/archive/impl/text_iarchive_impl.ipp
new file mode 100644
index 00000000000..ae4e2750ce8
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/archive/impl/text_iarchive_impl.ipp
@@ -0,0 +1,128 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// text_iarchive_impl.ipp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org for updates, documentation, and revision history.
+
+//////////////////////////////////////////////////////////////////////
+// implementation of basic_text_iprimitive overrides for the combination
+// of template parameters used to implement a text_iprimitive
+
+#include <cstddef> // size_t, NULL
+#include <boost/config.hpp>
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{ 
+    using ::size_t; 
+} // namespace std
+#endif
+
+#include <boost/detail/workaround.hpp> // RogueWave
+
+#include <boost/archive/text_iarchive.hpp>
+
+namespace boost {
+namespace archive {
+
+template<class Archive>
+BOOST_ARCHIVE_DECL void
+text_iarchive_impl<Archive>::load(char *s)
+{
+    std::size_t size;
+    * this->This() >> size;
+    // skip separating space
+    is.get();
+    // Works on all tested platforms
+    is.read(s, size);
+    s[size] = '\0';
+}
+
+template<class Archive>
+BOOST_ARCHIVE_DECL void
+text_iarchive_impl<Archive>::load(std::string &s)
+{
+    std::size_t size;
+    * this->This() >> size;
+    // skip separating space
+    is.get();
+    // borland de-allocator fixup
+    #if BOOST_WORKAROUND(_RWSTD_VER, BOOST_TESTED_AT(20101))
+    if(NULL != s.data())
+    #endif
+        s.resize(size);
+    if(0 < size)
+        is.read(&(*s.begin()), size);
+}
+
+#ifndef BOOST_NO_CWCHAR
+#ifndef BOOST_NO_INTRINSIC_WCHAR_T
+template<class Archive>
+BOOST_ARCHIVE_DECL void
+text_iarchive_impl<Archive>::load(wchar_t *ws)
+{
+    std::size_t size;
+    * this->This() >> size;
+    // skip separating space
+    is.get();
+    is.read((char *)ws, size * sizeof(wchar_t)/sizeof(char));
+    ws[size] = L'\0';
+}
+#endif // BOOST_NO_INTRINSIC_WCHAR_T
+
+#ifndef BOOST_NO_STD_WSTRING
+template<class Archive>
+BOOST_ARCHIVE_DECL void
+text_iarchive_impl<Archive>::load(std::wstring &ws)
+{
+    std::size_t size;
+    * this->This() >> size;
+    // borland de-allocator fixup
+    #if BOOST_WORKAROUND(_RWSTD_VER, BOOST_TESTED_AT(20101))
+    if(NULL != ws.data())
+    #endif
+        ws.resize(size);
+    // skip separating space
+    is.get();
+    is.read((char *)ws.data(), size * sizeof(wchar_t)/sizeof(char));
+}
+
+#endif // BOOST_NO_STD_WSTRING
+#endif // BOOST_NO_CWCHAR
+
+template<class Archive>
+BOOST_ARCHIVE_DECL void
+text_iarchive_impl<Archive>::load_override(class_name_type & t){
+    basic_text_iarchive<Archive>::load_override(t);
+}
+
+template<class Archive>
+BOOST_ARCHIVE_DECL void
+text_iarchive_impl<Archive>::init(){
+    basic_text_iarchive<Archive>::init();
+}
+
+template<class Archive>
+BOOST_ARCHIVE_DECL 
+text_iarchive_impl<Archive>::text_iarchive_impl(
+    std::istream & is, 
+    unsigned int flags
+) :
+    basic_text_iprimitive<std::istream>(
+        is, 
+        0 != (flags & no_codecvt)
+    ),
+    basic_text_iarchive<Archive>(flags)
+{
+    if(0 == (flags & no_header))
+        #if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3205))
+        this->init();
+        #else
+        this->basic_text_iarchive<Archive>::init();
+        #endif
+}
+
+} // namespace archive
+} // namespace boost
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/impl/text_oarchive_impl.ipp b/contrib/libboost/boost_1_65_0/boost/archive/impl/text_oarchive_impl.ipp
new file mode 100644
index 00000000000..37d8664a98c
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/archive/impl/text_oarchive_impl.ipp
@@ -0,0 +1,122 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// text_oarchive_impl.ipp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org for updates, documentation, and revision history.
+
+#include <string>
+#include <boost/config.hpp>
+#include <cstddef> // size_t
+
+#include <boost/config.hpp>
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{ 
+    using ::size_t; 
+} // namespace std
+#endif
+
+#ifndef BOOST_NO_CWCHAR
+#include <cwchar>
+#ifdef BOOST_NO_STDC_NAMESPACE
+namespace std{ using ::wcslen; }
+#endif
+#endif
+
+#include <boost/archive/text_oarchive.hpp>
+
+namespace boost { 
+namespace archive {
+
+//////////////////////////////////////////////////////////////////////
+// implementation of basic_text_oprimitive overrides for the combination
+// of template parameters used to create a text_oprimitive
+
+template<class Archive>
+BOOST_ARCHIVE_DECL void
+text_oarchive_impl<Archive>::save(const char * s)
+{
+    const std::size_t len = std::ostream::traits_type::length(s);
+    *this->This() << len;
+    this->This()->newtoken();
+    os << s;
+}
+
+template<class Archive>
+BOOST_ARCHIVE_DECL void
+text_oarchive_impl<Archive>::save(const std::string &s)
+{
+    const std::size_t size = s.size();
+    *this->This() << size;
+    this->This()->newtoken();
+    os << s;
+}
+
+#ifndef BOOST_NO_CWCHAR
+#ifndef BOOST_NO_INTRINSIC_WCHAR_T
+template<class Archive>
+BOOST_ARCHIVE_DECL void
+text_oarchive_impl<Archive>::save(const wchar_t * ws)
+{
+    const std::size_t l = std::wcslen(ws);
+    * this->This() << l;
+    this->This()->newtoken();
+    os.write((const char *)ws, l * sizeof(wchar_t)/sizeof(char));
+}
+#endif
+
+#ifndef BOOST_NO_STD_WSTRING
+template<class Archive>
+BOOST_ARCHIVE_DECL void
+text_oarchive_impl<Archive>::save(const std::wstring &ws)
+{
+    const std::size_t l = ws.size();
+    * this->This() << l;
+    this->This()->newtoken();
+    os.write((const char *)(ws.data()), l * sizeof(wchar_t)/sizeof(char));
+}
+#endif
+#endif // BOOST_NO_CWCHAR
+
+template<class Archive>
+BOOST_ARCHIVE_DECL 
+text_oarchive_impl<Archive>::text_oarchive_impl(
+    std::ostream & os, 
+    unsigned int flags
+) :
+    basic_text_oprimitive<std::ostream>(
+        os, 
+        0 != (flags & no_codecvt)
+    ),
+    basic_text_oarchive<Archive>(flags)
+{
+    if(0 == (flags & no_header))
+        #if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3205))
+        this->init();
+        #else
+        this->basic_text_oarchive<Archive>::init();
+        #endif
+}
+
+template<class Archive>
+BOOST_ARCHIVE_DECL void
+text_oarchive_impl<Archive>::save_binary(const void *address, std::size_t count){
+    put('\n');
+    this->end_preamble();
+    #if ! defined(__MWERKS__)
+    this->basic_text_oprimitive<std::ostream>::save_binary(
+    #else
+    this->basic_text_oprimitive::save_binary(
+    #endif
+        address, 
+        count
+    );
+    this->delimiter = this->eol;
+}
+
+} // namespace archive
+} // namespace boost
+
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/impl/text_wiarchive_impl.ipp b/contrib/libboost/boost_1_65_0/boost/archive/impl/text_wiarchive_impl.ipp
new file mode 100644
index 00000000000..e85625ac326
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/archive/impl/text_wiarchive_impl.ipp
@@ -0,0 +1,118 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// text_text_wiarchive_impl.ipp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org for updates, documentation, and revision history.
+
+#include <cstddef> // size_t, NULL
+
+#include <boost/config.hpp>
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{ 
+    using ::size_t; 
+} // namespace std
+#endif
+
+#include <boost/detail/workaround.hpp>  // fixup for RogueWave
+
+#ifndef BOOST_NO_STD_WSTREAMBUF
+#include <boost/archive/basic_text_iprimitive.hpp>
+
+namespace boost { 
+namespace archive {
+
+//////////////////////////////////////////////////////////////////////
+// implementation of wiprimtives functions
+//
+template<class Archive>
+BOOST_WARCHIVE_DECL void
+text_wiarchive_impl<Archive>::load(char *s)
+{
+    std::size_t size;
+    * this->This() >> size;
+    // skip separating space
+    is.get();
+    while(size-- > 0){
+        *s++ = is.narrow(is.get(), '\0');
+    }
+    *s = '\0';
+}
+
+template<class Archive>
+BOOST_WARCHIVE_DECL void
+text_wiarchive_impl<Archive>::load(std::string &s)
+{
+    std::size_t size;
+    * this->This() >> size;
+    // skip separating space
+    is.get();
+    #if BOOST_WORKAROUND(_RWSTD_VER, BOOST_TESTED_AT(20101))
+    if(NULL != s.data())
+    #endif
+        s.resize(0);
+    s.reserve(size);
+    while(size-- > 0){
+        char x = is.narrow(is.get(), '\0');
+        s += x;
+    }
+}
+
+#ifndef BOOST_NO_INTRINSIC_WCHAR_T
+template<class Archive>
+BOOST_WARCHIVE_DECL void
+text_wiarchive_impl<Archive>::load(wchar_t *s)
+{
+    std::size_t size;
+    * this->This() >> size;
+    // skip separating space
+    is.get();
+    // Works on all tested platforms
+    is.read(s, size);
+    s[size] = L'\0';
+}
+#endif
+
+#ifndef BOOST_NO_STD_WSTRING
+template<class Archive>
+BOOST_WARCHIVE_DECL void
+text_wiarchive_impl<Archive>::load(std::wstring &ws)
+{
+    std::size_t size;
+    * this->This() >> size;
+    // skip separating space
+    is.get();
+    // borland complains about resize
+    // borland de-allocator fixup
+    #if BOOST_WORKAROUND(_RWSTD_VER, BOOST_TESTED_AT(20101))
+    if(NULL != ws.data())
+    #endif
+        ws.resize(size);
+    // note breaking a rule here - is this a problem on some platform
+    is.read(const_cast<wchar_t *>(ws.data()), size);
+}
+#endif
+
+template<class Archive>
+BOOST_WARCHIVE_DECL 
+text_wiarchive_impl<Archive>::text_wiarchive_impl(
+    std::wistream & is, 
+    unsigned int flags
+) :
+    basic_text_iprimitive<std::wistream>(
+        is, 
+        0 != (flags & no_codecvt)
+    ),
+    basic_text_iarchive<Archive>(flags)
+{
+    if(0 == (flags & no_header))
+        basic_text_iarchive<Archive>::init();
+}
+
+} // archive
+} // boost
+
+#endif // BOOST_NO_STD_WSTREAMBUF
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/impl/text_woarchive_impl.ipp b/contrib/libboost/boost_1_65_0/boost/archive/impl/text_woarchive_impl.ipp
new file mode 100644
index 00000000000..2b6d427cd3a
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/archive/impl/text_woarchive_impl.ipp
@@ -0,0 +1,85 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// text_woarchive_impl.ipp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org for updates, documentation, and revision history.
+
+#include <boost/config.hpp>
+#ifndef BOOST_NO_STD_WSTREAMBUF
+
+#include <cstring>
+#include <cstddef> // size_t
+#if defined(BOOST_NO_STDC_NAMESPACE) && ! defined(__LIBCOMO__)
+namespace std{ 
+    using ::strlen;
+    using ::size_t; 
+} // namespace std
+#endif
+
+#include <ostream>
+
+#include <boost/archive/text_woarchive.hpp>
+
+namespace boost {
+namespace archive {
+
+//////////////////////////////////////////////////////////////////////
+// implementation of woarchive functions
+//
+template<class Archive>
+BOOST_WARCHIVE_DECL void
+text_woarchive_impl<Archive>::save(const char *s)
+{
+    // note: superfluous local variable fixes borland warning
+    const std::size_t size = std::strlen(s);
+    * this->This() << size;
+    this->This()->newtoken();
+    while(*s != '\0')
+        os.put(os.widen(*s++));
+}
+
+template<class Archive>
+BOOST_WARCHIVE_DECL void
+text_woarchive_impl<Archive>::save(const std::string &s)
+{
+    const std::size_t size = s.size();
+    * this->This() << size;
+    this->This()->newtoken();
+    const char * cptr = s.data();
+    for(std::size_t i = size; i-- > 0;)
+        os.put(os.widen(*cptr++));
+}
+
+#ifndef BOOST_NO_INTRINSIC_WCHAR_T
+template<class Archive>
+BOOST_WARCHIVE_DECL void
+text_woarchive_impl<Archive>::save(const wchar_t *ws)
+{
+    const std::size_t size = std::wostream::traits_type::length(ws);
+    * this->This() << size;
+    this->This()->newtoken();
+    os.write(ws, size);
+}
+#endif
+
+#ifndef BOOST_NO_STD_WSTRING
+template<class Archive>
+BOOST_WARCHIVE_DECL void
+text_woarchive_impl<Archive>::save(const std::wstring &ws)
+{
+    const std::size_t size = ws.length();
+    * this->This() << size;
+    this->This()->newtoken();
+    os.write(ws.data(), size);
+}
+#endif
+
+} // namespace archive
+} // namespace boost
+
+#endif
+
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/impl/xml_iarchive_impl.ipp b/contrib/libboost/boost_1_65_0/boost/archive/impl/xml_iarchive_impl.ipp
new file mode 100644
index 00000000000..efc32e01632
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/archive/impl/xml_iarchive_impl.ipp
@@ -0,0 +1,199 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// xml_iarchive_impl.cpp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org for updates, documentation, and revision history.
+
+#include <boost/config.hpp>
+#include <cstring> // memcpy
+#include <cstddef> // NULL
+#include <exception>
+
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{ 
+    using ::memcpy;
+} // namespace std
+#endif
+
+#ifndef BOOST_NO_CWCHAR
+#include <cwchar> // mbstate_t and mbrtowc
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{ 
+    using ::mbstate_t;
+    using ::mbrtowc;
+ } // namespace std
+#endif
+#endif // BOOST_NO_CWCHAR
+
+#include <boost/detail/workaround.hpp> // RogueWave and Dinkumware
+#if BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, == 1)
+#include <boost/archive/dinkumware.hpp>
+#endif
+
+#include <boost/core/no_exceptions_support.hpp>
+
+#include <boost/archive/xml_archive_exception.hpp>
+#include <boost/archive/iterators/dataflow_exception.hpp>
+#include <boost/archive/basic_xml_archive.hpp>
+#include <boost/archive/xml_iarchive.hpp>
+
+#include "basic_xml_grammar.hpp"
+
+namespace boost {
+namespace archive {
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// implemenations of functions specific to char archives
+
+// wide char stuff used by char archives
+
+#ifndef BOOST_NO_CWCHAR
+#ifndef BOOST_NO_STD_WSTRING
+template<class Archive>
+BOOST_ARCHIVE_DECL void
+xml_iarchive_impl<Archive>::load(std::wstring &ws){
+    std::string s;
+    bool result = gimpl->parse_string(is, s);
+    if(! result)
+        boost::serialization::throw_exception(
+            xml_archive_exception(xml_archive_exception::xml_archive_parsing_error)
+        );
+    
+    #if BOOST_WORKAROUND(_RWSTD_VER, BOOST_TESTED_AT(20101))
+    if(NULL != ws.data())
+    #endif
+    ws.resize(0);
+    std::mbstate_t mbs = std::mbstate_t();
+    const char * start = s.data();
+    const char * end = start + s.size();
+    while(start < end){
+        wchar_t wc;
+        std::size_t count = std::mbrtowc(&wc, start, end - start, &mbs);
+        if(count == static_cast<std::size_t>(-1))
+            boost::serialization::throw_exception(
+                iterators::dataflow_exception(
+                    iterators::dataflow_exception::invalid_conversion
+                )
+            );
+        if(count == static_cast<std::size_t>(-2))
+            continue;
+        start += count;
+        ws += wc;
+    }
+}
+#endif // BOOST_NO_STD_WSTRING
+
+#ifndef BOOST_NO_INTRINSIC_WCHAR_T
+template<class Archive>
+BOOST_ARCHIVE_DECL void
+xml_iarchive_impl<Archive>::load(wchar_t * ws){
+    std::string s;
+    bool result = gimpl->parse_string(is, s);
+    if(! result)
+        boost::serialization::throw_exception(
+            xml_archive_exception(
+                xml_archive_exception::xml_archive_parsing_error
+            )
+        );
+        
+    std::mbstate_t mbs = std::mbstate_t();
+    const char * start = s.data();
+    const char * end = start + s.size();
+    while(start < end){
+        wchar_t wc;
+        std::size_t length = std::mbrtowc(&wc, start, end - start, &mbs);
+        if(static_cast<std::size_t>(-1) == length)
+            boost::serialization::throw_exception(
+                iterators::dataflow_exception(
+                    iterators::dataflow_exception::invalid_conversion
+                )
+            );
+        if(static_cast<std::size_t>(-2) == length)
+            continue;
+
+        start += length;
+        *ws++ = wc;
+    }
+    *ws = L'\0';
+}
+#endif // BOOST_NO_INTRINSIC_WCHAR_T
+
+#endif // BOOST_NO_CWCHAR
+
+template<class Archive>
+BOOST_ARCHIVE_DECL void
+xml_iarchive_impl<Archive>::load(std::string &s){
+    bool result = gimpl->parse_string(is, s);
+    if(! result)
+        boost::serialization::throw_exception(
+            xml_archive_exception(xml_archive_exception::xml_archive_parsing_error)
+        );
+}
+
+template<class Archive>
+BOOST_ARCHIVE_DECL void
+xml_iarchive_impl<Archive>::load(char * s){
+    std::string tstring;
+    bool result = gimpl->parse_string(is, tstring);
+    if(! result)
+        boost::serialization::throw_exception(
+            xml_archive_exception(xml_archive_exception::xml_archive_parsing_error)
+        );
+    std::memcpy(s, tstring.data(), tstring.size());
+    s[tstring.size()] = 0;
+}
+
+template<class Archive>
+BOOST_ARCHIVE_DECL void
+xml_iarchive_impl<Archive>::load_override(class_name_type & t){
+    const std::string & s = gimpl->rv.class_name;
+    if(s.size() > BOOST_SERIALIZATION_MAX_KEY_SIZE - 1)
+        boost::serialization::throw_exception(
+            archive_exception(archive_exception::invalid_class_name)
+       );
+    char * tptr = t;
+    std::memcpy(tptr, s.data(), s.size());
+    tptr[s.size()] = '\0';
+}
+
+template<class Archive>
+BOOST_ARCHIVE_DECL void
+xml_iarchive_impl<Archive>::init(){
+    gimpl->init(is);
+    this->set_library_version(
+        library_version_type(gimpl->rv.version)
+    );
+}
+
+template<class Archive>
+BOOST_ARCHIVE_DECL
+xml_iarchive_impl<Archive>::xml_iarchive_impl(
+    std::istream &is_,
+    unsigned int flags
+) :
+    basic_text_iprimitive<std::istream>(
+        is_, 
+        0 != (flags & no_codecvt)
+    ),
+    basic_xml_iarchive<Archive>(flags),
+    gimpl(new xml_grammar())
+{
+    if(0 == (flags & no_header))
+        init();
+}
+
+template<class Archive>
+BOOST_ARCHIVE_DECL
+xml_iarchive_impl<Archive>::~xml_iarchive_impl(){
+    if(std::uncaught_exception())
+        return;
+    if(0 == (this->get_flags() & no_header)){
+        gimpl->windup(is);
+    }
+}
+} // namespace archive
+} // namespace boost
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/impl/xml_oarchive_impl.ipp b/contrib/libboost/boost_1_65_0/boost/archive/impl/xml_oarchive_impl.ipp
new file mode 100644
index 00000000000..5ebd454e722
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/archive/impl/xml_oarchive_impl.ipp
@@ -0,0 +1,142 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// xml_oarchive_impl.ipp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.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)
+
+#include <ostream>
+#include <iomanip>
+#include <algorithm> // std::copy
+#include <string>
+#include <exception>
+
+#include <cstring> // strlen
+#include <boost/config.hpp> // msvc 6.0 needs this to suppress warnings
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{ 
+    using ::strlen; 
+} // namespace std
+#endif
+
+#include <boost/archive/iterators/xml_escape.hpp>
+#include <boost/archive/iterators/ostream_iterator.hpp>
+
+#ifndef BOOST_NO_CWCHAR
+#include <boost/archive/wcslen.hpp>
+#include <boost/archive/iterators/mb_from_wchar.hpp>
+#endif
+
+namespace boost {
+namespace archive {
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// implemenations of functions specific to char archives
+
+// wide char stuff used by char archives
+#ifndef BOOST_NO_CWCHAR
+// copy chars to output escaping to xml and translating wide chars to mb chars
+template<class InputIterator>
+void save_iterator(std::ostream &os, InputIterator begin, InputIterator end){
+    typedef boost::archive::iterators::mb_from_wchar<
+        boost::archive::iterators::xml_escape<InputIterator>
+    > translator;
+    std::copy(
+        translator(begin),
+        translator(end),
+        boost::archive::iterators::ostream_iterator<char>(os)
+    );
+}
+
+#ifndef BOOST_NO_STD_WSTRING
+template<class Archive>
+BOOST_ARCHIVE_DECL void
+xml_oarchive_impl<Archive>::save(const std::wstring & ws){
+//  at least one library doesn't typedef value_type for strings
+//  so rather than using string directly make a pointer iterator out of it
+//    save_iterator(os, ws.data(), ws.data() + std::wcslen(ws.data()));
+    save_iterator(os, ws.data(), ws.data() + ws.size());
+}
+#endif
+
+#ifndef BOOST_NO_INTRINSIC_WCHAR_T
+template<class Archive>
+BOOST_ARCHIVE_DECL void
+xml_oarchive_impl<Archive>::save(const wchar_t * ws){
+    save_iterator(os, ws, ws + std::wcslen(ws));
+}
+#endif
+
+#endif // BOOST_NO_CWCHAR
+
+template<class Archive>
+BOOST_ARCHIVE_DECL void
+xml_oarchive_impl<Archive>::save(const std::string & s){
+//  at least one library doesn't typedef value_type for strings
+//  so rather than using string directly make a pointer iterator out of it
+    typedef boost::archive::iterators::xml_escape<
+        const char * 
+    > xml_escape_translator;
+    std::copy(
+        xml_escape_translator(s.data()),
+        xml_escape_translator(s.data()+ s.size()),
+        boost::archive::iterators::ostream_iterator<char>(os)
+    );
+}
+
+template<class Archive>
+BOOST_ARCHIVE_DECL void
+xml_oarchive_impl<Archive>::save(const char * s){
+    typedef boost::archive::iterators::xml_escape<
+        const char * 
+    > xml_escape_translator;
+    std::copy(
+        xml_escape_translator(s),
+        xml_escape_translator(s + std::strlen(s)),
+        boost::archive::iterators::ostream_iterator<char>(os)
+    );
+}
+
+template<class Archive>
+BOOST_ARCHIVE_DECL
+xml_oarchive_impl<Archive>::xml_oarchive_impl(
+    std::ostream & os_, 
+    unsigned int flags
+) : 
+    basic_text_oprimitive<std::ostream>(
+        os_,
+        0 != (flags & no_codecvt)
+    ),
+    basic_xml_oarchive<Archive>(flags)
+{
+    if(0 == (flags & no_header))
+        this->init();
+}
+
+template<class Archive>
+BOOST_ARCHIVE_DECL void
+xml_oarchive_impl<Archive>::save_binary(const void *address, std::size_t count){
+    this->end_preamble();
+    #if ! defined(__MWERKS__)
+    this->basic_text_oprimitive<std::ostream>::save_binary(
+    #else
+    this->basic_text_oprimitive::save_binary(
+    #endif
+        address, 
+        count
+    );
+    this->indent_next = true;
+}
+
+template<class Archive>
+BOOST_ARCHIVE_DECL
+xml_oarchive_impl<Archive>::~xml_oarchive_impl(){
+    if(std::uncaught_exception())
+        return;
+    if(0 == (this->get_flags() & no_header))
+        this->windup();
+}
+
+} // namespace archive
+} // namespace boost
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/impl/xml_wiarchive_impl.ipp b/contrib/libboost/boost_1_65_0/boost/archive/impl/xml_wiarchive_impl.ipp
new file mode 100644
index 00000000000..ee66c1263e6
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/archive/impl/xml_wiarchive_impl.ipp
@@ -0,0 +1,189 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// xml_wiarchive_impl.ipp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org for updates, documentation, and revision history.
+
+#include <cstring>
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{ 
+    using ::memcpy; 
+} //std
+#endif
+
+#include <boost/config.hpp> // msvc 6.0 needs this to suppress warnings
+#ifndef BOOST_NO_STD_WSTREAMBUF
+
+#include <boost/assert.hpp>
+#include <algorithm> // std::copy
+#include <exception> // uncaught exception
+#include <boost/detail/workaround.hpp> // Dinkumware and RogueWave
+#if BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, == 1)
+#include <boost/archive/dinkumware.hpp>
+#endif
+
+#include <boost/io/ios_state.hpp>
+#include <boost/core/no_exceptions_support.hpp>
+#include <boost/serialization/string.hpp>
+
+#include <boost/archive/basic_xml_archive.hpp>
+#include <boost/archive/xml_wiarchive.hpp>
+
+#include <boost/archive/xml_archive_exception.hpp>
+#include <boost/archive/iterators/mb_from_wchar.hpp>
+
+#include <boost/archive/detail/utf8_codecvt_facet.hpp>
+
+#include "basic_xml_grammar.hpp"
+
+namespace boost {
+namespace archive {
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// implemenations of functions specific to wide char archives
+
+namespace { // anonymous
+
+void copy_to_ptr(char * s, const std::wstring & ws){
+    std::copy(
+        iterators::mb_from_wchar<std::wstring::const_iterator>(
+            ws.begin()
+        ), 
+        iterators::mb_from_wchar<std::wstring::const_iterator>(
+            ws.end()
+        ), 
+        s
+    );
+    s[ws.size()] = 0;
+}
+
+} // anonymous
+
+template<class Archive>
+BOOST_WARCHIVE_DECL void
+xml_wiarchive_impl<Archive>::load(std::string & s){
+    std::wstring ws;
+    bool result = gimpl->parse_string(is, ws);
+    if(! result)
+        boost::serialization::throw_exception(
+            xml_archive_exception(xml_archive_exception::xml_archive_parsing_error)
+        );
+    #if BOOST_WORKAROUND(_RWSTD_VER, BOOST_TESTED_AT(20101))
+    if(NULL != s.data())
+    #endif
+        s.resize(0);
+    s.reserve(ws.size());
+    std::copy(
+        iterators::mb_from_wchar<std::wstring::iterator>(
+            ws.begin()
+        ), 
+        iterators::mb_from_wchar<std::wstring::iterator>(
+            ws.end()
+        ), 
+        std::back_inserter(s)
+    );
+}
+
+#ifndef BOOST_NO_STD_WSTRING
+template<class Archive>
+BOOST_WARCHIVE_DECL void
+xml_wiarchive_impl<Archive>::load(std::wstring & ws){
+    bool result = gimpl->parse_string(is, ws);
+    if(! result)
+        boost::serialization::throw_exception(
+            xml_archive_exception(xml_archive_exception::xml_archive_parsing_error)
+        );
+}
+#endif
+
+template<class Archive>
+BOOST_WARCHIVE_DECL void
+xml_wiarchive_impl<Archive>::load(char * s){
+    std::wstring ws;
+    bool result = gimpl->parse_string(is, ws);
+    if(! result)
+        boost::serialization::throw_exception(
+            xml_archive_exception(xml_archive_exception::xml_archive_parsing_error)
+        );
+    copy_to_ptr(s, ws);
+}
+
+#ifndef BOOST_NO_INTRINSIC_WCHAR_T
+template<class Archive>
+BOOST_WARCHIVE_DECL void
+xml_wiarchive_impl<Archive>::load(wchar_t * ws){
+    std::wstring twstring;
+    bool result = gimpl->parse_string(is, twstring);
+    if(! result)
+        boost::serialization::throw_exception(
+            xml_archive_exception(xml_archive_exception::xml_archive_parsing_error)
+        );
+    std::memcpy(ws, twstring.c_str(), twstring.size());
+    ws[twstring.size()] = L'\0';
+}
+#endif
+
+template<class Archive>
+BOOST_WARCHIVE_DECL void
+xml_wiarchive_impl<Archive>::load_override(class_name_type & t){
+    const std::wstring & ws = gimpl->rv.class_name;
+    if(ws.size() > BOOST_SERIALIZATION_MAX_KEY_SIZE - 1)
+        boost::serialization::throw_exception(
+            archive_exception(archive_exception::invalid_class_name)
+        );
+    copy_to_ptr(t, ws);
+}
+
+template<class Archive>
+BOOST_WARCHIVE_DECL void
+xml_wiarchive_impl<Archive>::init(){
+    gimpl->init(is);
+    this->set_library_version(
+        library_version_type(gimpl->rv.version)
+    );
+}
+
+template<class Archive>
+BOOST_WARCHIVE_DECL
+xml_wiarchive_impl<Archive>::xml_wiarchive_impl(
+    std::wistream &is_,
+    unsigned int flags
+) :
+    basic_text_iprimitive<std::wistream>(
+        is_, 
+        true // don't change the codecvt - use the one below
+    ),
+    basic_xml_iarchive<Archive>(flags),
+    gimpl(new xml_wgrammar())
+{
+    if(0 == (flags & no_codecvt)){
+        std::locale l = std::locale(
+            is_.getloc(),
+            new boost::archive::detail::utf8_codecvt_facet
+        );
+        // libstdc++ crashes without this
+        is_.sync();
+        is_.imbue(l);
+    }
+    if(0 == (flags & no_header))
+        init();
+}
+
+template<class Archive>
+BOOST_WARCHIVE_DECL
+xml_wiarchive_impl<Archive>::~xml_wiarchive_impl(){
+    if(std::uncaught_exception())
+        return;
+    if(0 == (this->get_flags() & no_header)){
+        gimpl->windup(is);
+    }
+}
+
+} // namespace archive
+} // namespace boost
+
+#endif  // BOOST_NO_STD_WSTREAMBUF
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/impl/xml_woarchive_impl.ipp b/contrib/libboost/boost_1_65_0/boost/archive/impl/xml_woarchive_impl.ipp
new file mode 100644
index 00000000000..01b1a052d51
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/archive/impl/xml_woarchive_impl.ipp
@@ -0,0 +1,171 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// xml_woarchive_impl.ipp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.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)
+
+#include <boost/config.hpp>
+#ifndef BOOST_NO_STD_WSTREAMBUF
+
+#include <ostream>
+#include <string>
+#include <algorithm> // std::copy
+#include <locale>
+#include <exception>
+
+#include <cstring> // strlen
+#include <cstdlib> // mbtowc
+#ifndef BOOST_NO_CWCHAR
+#include <cwchar>  // wcslen
+#endif
+
+#include <boost/config.hpp>
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{ 
+    using ::strlen; 
+    #if ! defined(BOOST_NO_INTRINSIC_WCHAR_T)
+        using ::mbtowc; 
+        using ::wcslen;
+    #endif
+} // namespace std
+#endif
+
+#include <boost/archive/xml_woarchive.hpp>
+#include <boost/archive/detail/utf8_codecvt_facet.hpp>
+
+#include <boost/serialization/throw_exception.hpp>
+
+#include <boost/archive/iterators/xml_escape.hpp>
+#include <boost/archive/iterators/wchar_from_mb.hpp>
+#include <boost/archive/iterators/ostream_iterator.hpp>
+#include <boost/archive/iterators/dataflow_exception.hpp>
+
+namespace boost {
+namespace archive {
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// implemenations of functions specific to wide char archives
+
+// copy chars to output escaping to xml and widening characters as we go
+template<class InputIterator>
+void save_iterator(std::wostream &os, InputIterator begin, InputIterator end){
+    typedef iterators::wchar_from_mb<
+        iterators::xml_escape<InputIterator>
+    > xmbtows;
+    std::copy(
+        xmbtows(begin),
+        xmbtows(end),
+        boost::archive::iterators::ostream_iterator<wchar_t>(os)
+    );
+}
+
+template<class Archive>
+BOOST_WARCHIVE_DECL void
+xml_woarchive_impl<Archive>::save(const std::string & s){
+    // note: we don't use s.begin() and s.end() because dinkumware
+    // doesn't have string::value_type defined. So use a wrapper
+    // around these values to implement the definitions.
+    const char * begin = s.data();
+    const char * end = begin + s.size();
+    save_iterator(os, begin, end);
+}
+
+#ifndef BOOST_NO_STD_WSTRING
+template<class Archive>
+BOOST_WARCHIVE_DECL void
+xml_woarchive_impl<Archive>::save(const std::wstring & ws){
+#if 0
+    typedef iterators::xml_escape<std::wstring::const_iterator> xmbtows;
+    std::copy(
+        xmbtows(ws.begin()),
+        xmbtows(ws.end()),
+        boost::archive::iterators::ostream_iterator<wchar_t>(os)
+    );
+#endif
+    typedef iterators::xml_escape<const wchar_t *> xmbtows;
+    std::copy(
+        xmbtows(ws.data()),
+        xmbtows(ws.data() + ws.size()),
+        boost::archive::iterators::ostream_iterator<wchar_t>(os)
+    );
+}
+#endif //BOOST_NO_STD_WSTRING
+
+template<class Archive>
+BOOST_WARCHIVE_DECL void
+xml_woarchive_impl<Archive>::save(const char * s){
+   save_iterator(os, s, s + std::strlen(s));
+}
+
+#ifndef BOOST_NO_INTRINSIC_WCHAR_T
+template<class Archive>
+BOOST_WARCHIVE_DECL void
+xml_woarchive_impl<Archive>::save(const wchar_t * ws){
+    os << ws;
+    typedef iterators::xml_escape<const wchar_t *> xmbtows;
+    std::copy(
+        xmbtows(ws),
+        xmbtows(ws + std::wcslen(ws)),
+        boost::archive::iterators::ostream_iterator<wchar_t>(os)
+    );
+}
+#endif
+
+template<class Archive>
+BOOST_WARCHIVE_DECL
+xml_woarchive_impl<Archive>::xml_woarchive_impl(
+    std::wostream & os_,
+    unsigned int flags
+) :
+    basic_text_oprimitive<std::wostream>(
+        os_,
+        true // don't change the codecvt - use the one below
+    ),
+    basic_xml_oarchive<Archive>(flags)
+{
+    if(0 == (flags & no_codecvt)){
+        std::locale l = std::locale(
+            os_.getloc(),
+            new boost::archive::detail::utf8_codecvt_facet
+        );
+        os_.flush();
+        os_.imbue(l);
+    }
+    if(0 == (flags & no_header))
+        this->init();
+}
+
+template<class Archive>
+BOOST_WARCHIVE_DECL
+xml_woarchive_impl<Archive>::~xml_woarchive_impl(){
+    if(std::uncaught_exception())
+        return;
+    if(0 == (this->get_flags() & no_header)){
+        save(L"</boost_serialization>\n");
+    }
+}
+
+template<class Archive>
+BOOST_WARCHIVE_DECL void
+xml_woarchive_impl<Archive>::save_binary(
+    const void *address,
+    std::size_t count
+){
+    this->end_preamble();
+    #if ! defined(__MWERKS__)
+    this->basic_text_oprimitive<std::wostream>::save_binary(
+    #else
+    this->basic_text_oprimitive::save_binary(
+    #endif
+        address, 
+        count
+    );
+    this->indent_next = true;
+}
+
+} // namespace archive
+} // namespace boost
+
+#endif //BOOST_NO_STD_WSTREAMBUF
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/iterators/base64_exception.hpp b/contrib/libboost/boost_1_65_0/boost/archive/iterators/base64_exception.hpp
new file mode 100644
index 00000000000..8f9208b60ea
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/archive/iterators/base64_exception.hpp
@@ -0,0 +1,68 @@
+#ifndef BOOST_ARCHIVE_ITERATORS_BASE64_EXCEPTION_HPP
+#define BOOST_ARCHIVE_ITERATORS_BASE64_EXCEPTION_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// base64_exception.hpp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+#include <boost/config.hpp>
+#ifndef BOOST_NO_EXCEPTIONS
+#include <exception>
+
+#include <boost/assert.hpp>
+
+namespace boost {
+namespace archive {
+namespace iterators {
+
+//////////////////////////////////////////////////////////////////////
+// exceptions thrown by base64s
+//
+class base64_exception : public std::exception
+{
+public:
+    typedef enum {
+        invalid_code,       // attempt to encode a value > 6 bits
+        invalid_character,  // decode a value not in base64 char set
+        other_exception
+    } exception_code;
+    exception_code code;
+
+    base64_exception(exception_code c = other_exception) : code(c)
+    {}
+
+    virtual const char *what( ) const throw( )
+    {
+        const char *msg = "unknown exception code";
+        switch(code){
+        case invalid_code:
+            msg = "attempt to encode a value > 6 bits";
+            break;
+        case invalid_character:
+            msg = "attempt to decode a value not in base64 char set";
+            break;
+        default:
+            BOOST_ASSERT(false);
+            break;
+        }
+        return msg;
+    }
+};
+
+} // namespace iterators
+} // namespace archive
+} // namespace boost
+
+#endif //BOOST_NO_EXCEPTIONS
+#endif //BOOST_ARCHIVE_ITERATORS_ARCHIVE_EXCEPTION_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/iterators/base64_from_binary.hpp b/contrib/libboost/boost_1_65_0/boost/archive/iterators/base64_from_binary.hpp
new file mode 100644
index 00000000000..ee849944397
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/archive/iterators/base64_from_binary.hpp
@@ -0,0 +1,109 @@
+#ifndef BOOST_ARCHIVE_ITERATORS_BASE64_FROM_BINARY_HPP
+#define BOOST_ARCHIVE_ITERATORS_BASE64_FROM_BINARY_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// base64_from_binary.hpp
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+#include <boost/assert.hpp>
+
+#include <cstddef> // size_t
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{ 
+    using ::size_t; 
+} // namespace std
+#endif
+
+#include <boost/iterator/transform_iterator.hpp>
+#include <boost/archive/iterators/dataflow_exception.hpp>
+
+namespace boost { 
+namespace archive {
+namespace iterators {
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// convert binary integers to base64 characters
+
+namespace detail {
+
+template<class CharType>
+struct from_6_bit {
+    typedef CharType result_type;
+    CharType operator()(CharType t) const{
+        static const char * lookup_table =
+            "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+            "abcdefghijklmnopqrstuvwxyz"
+            "0123456789"
+            "+/";
+        BOOST_ASSERT(t < 64);
+        return lookup_table[static_cast<size_t>(t)];
+    }
+};
+
+} // namespace detail
+
+// note: what we would like to do is
+// template<class Base, class CharType = typename Base::value_type>
+//  typedef transform_iterator<
+//      from_6_bit<CharType>,
+//      transform_width<Base, 6, sizeof(Base::value_type) * 8, CharType>
+//  > base64_from_binary;
+// but C++ won't accept this.  Rather than using a "type generator" and
+// using a different syntax, make a derivation which should be equivalent.
+//
+// Another issue addressed here is that the transform_iterator doesn't have
+// a templated constructor.  This makes it incompatible with the dataflow
+// ideal.  This is also addressed here.
+
+//template<class Base, class CharType = typename Base::value_type>
+template<
+    class Base, 
+    class CharType = typename boost::iterator_value<Base>::type
+>
+class base64_from_binary : 
+    public transform_iterator<
+        detail::from_6_bit<CharType>,
+        Base
+    >
+{
+    friend class boost::iterator_core_access;
+    typedef transform_iterator<
+        typename detail::from_6_bit<CharType>,
+        Base
+    > super_t;
+
+public:
+    // make composible buy using templated constructor
+    template<class T>
+    base64_from_binary(T start) :
+        super_t(
+            Base(static_cast< T >(start)),
+            detail::from_6_bit<CharType>()
+        )
+    {}
+    // intel 7.1 doesn't like default copy constructor
+    base64_from_binary(const base64_from_binary & rhs) : 
+        super_t(
+            Base(rhs.base_reference()),
+            detail::from_6_bit<CharType>()
+        )
+    {}
+//    base64_from_binary(){};
+};
+
+} // namespace iterators
+} // namespace archive
+} // namespace boost
+
+#endif // BOOST_ARCHIVE_ITERATORS_BASE64_FROM_BINARY_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/iterators/binary_from_base64.hpp b/contrib/libboost/boost_1_65_0/boost/archive/iterators/binary_from_base64.hpp
new file mode 100644
index 00000000000..89b8f889da3
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/archive/iterators/binary_from_base64.hpp
@@ -0,0 +1,118 @@
+#ifndef BOOST_ARCHIVE_ITERATORS_BINARY_FROM_BASE64_HPP
+#define BOOST_ARCHIVE_ITERATORS_BINARY_FROM_BASE64_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// binary_from_base64.hpp
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+#include <boost/assert.hpp>
+
+#include <boost/serialization/throw_exception.hpp>
+#include <boost/static_assert.hpp>
+
+#include <boost/iterator/transform_iterator.hpp>
+#include <boost/archive/iterators/dataflow_exception.hpp>
+
+namespace boost { 
+namespace archive {
+namespace iterators {
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// convert base64 characters to binary data
+
+namespace detail {
+
+template<class CharType>
+struct to_6_bit {
+    typedef CharType result_type;
+    CharType operator()(CharType t) const{
+        static const signed char lookup_table[] = {
+            -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+            -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+            -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,62,-1,-1,-1,63,
+            52,53,54,55,56,57,58,59,60,61,-1,-1,-1, 0,-1,-1, // render '=' as 0
+            -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,
+            15,16,17,18,19,20,21,22,23,24,25,-1,-1,-1,-1,-1,
+            -1,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,
+            41,42,43,44,45,46,47,48,49,50,51,-1,-1,-1,-1,-1
+        };
+        // metrowerks trips this assertion - how come?
+        #if ! defined(__MWERKS__)
+        BOOST_STATIC_ASSERT(128 == sizeof(lookup_table));
+        #endif
+        signed char value = -1;
+        if((unsigned)t <= 127)
+            value = lookup_table[(unsigned)t];
+        if(-1 == value)
+            boost::serialization::throw_exception(
+                dataflow_exception(dataflow_exception::invalid_base64_character)
+            );
+        return value;
+    }
+};
+
+} // namespace detail
+
+// note: what we would like to do is
+// template<class Base, class CharType = typename Base::value_type>
+//  typedef transform_iterator<
+//      from_6_bit<CharType>,
+//      transform_width<Base, 6, sizeof(Base::value_type) * 8, CharType>
+//  > base64_from_binary;
+// but C++ won't accept this.  Rather than using a "type generator" and
+// using a different syntax, make a derivation which should be equivalent.
+//
+// Another issue addressed here is that the transform_iterator doesn't have
+// a templated constructor.  This makes it incompatible with the dataflow
+// ideal.  This is also addressed here.
+
+template<
+    class Base, 
+    class CharType = typename boost::iterator_value<Base>::type
+>
+class binary_from_base64 : public
+    transform_iterator<
+        detail::to_6_bit<CharType>,
+        Base
+    >
+{
+    friend class boost::iterator_core_access;
+    typedef transform_iterator<
+        detail::to_6_bit<CharType>,
+        Base
+    > super_t;
+public:
+    // make composible buy using templated constructor
+    template<class T>
+    binary_from_base64(T  start) :
+        super_t(
+            Base(static_cast< T >(start)),
+            detail::to_6_bit<CharType>()
+        )
+    {}
+    // intel 7.1 doesn't like default copy constructor
+    binary_from_base64(const binary_from_base64 & rhs) : 
+        super_t(
+            Base(rhs.base_reference()),
+            detail::to_6_bit<CharType>()
+        )
+    {}
+//    binary_from_base64(){};
+};
+
+} // namespace iterators
+} // namespace archive
+} // namespace boost
+
+#endif // BOOST_ARCHIVE_ITERATORS_BINARY_FROM_BASE64_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/iterators/dataflow.hpp b/contrib/libboost/boost_1_65_0/boost/archive/iterators/dataflow.hpp
new file mode 100644
index 00000000000..07733d5fd62
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/archive/iterators/dataflow.hpp
@@ -0,0 +1,102 @@
+#ifndef BOOST_ARCHIVE_ITERATORS_DATAFLOW_HPP
+#define BOOST_ARCHIVE_ITERATORS_DATAFLOW_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// dataflow.hpp
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+#include <boost/assert.hpp>
+
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/mpl/apply.hpp>
+#include <boost/mpl/plus.hpp>
+#include <boost/mpl/int.hpp>
+
+#include <boost/type_traits/is_convertible.hpp>
+#include <boost/type_traits/is_base_and_derived.hpp>
+#include <boost/type_traits/is_pointer.hpp>
+#include <boost/iterator/iterator_adaptor.hpp>
+#include <boost/iterator/iterator_traits.hpp>
+#include <boost/static_assert.hpp>
+
+namespace boost { 
+namespace archive {
+namespace iterators {
+
+// poor man's tri-state
+struct tri_state {
+    enum state_enum {
+        is_false = false,
+        is_true = true,
+        is_indeterminant
+    } m_state;
+    // convert to bool
+    operator bool (){
+        BOOST_ASSERT(is_indeterminant != m_state);
+        return is_true == m_state ? true : false;
+    }
+    // assign from bool
+    tri_state & operator=(bool rhs) {
+        m_state = rhs ? is_true : is_false;
+        return *this;
+    }
+    tri_state(bool rhs) :
+        m_state(rhs ? is_true : is_false)
+    {}
+    tri_state(state_enum state) :
+        m_state(state)
+    {}
+    bool operator==(const tri_state & rhs) const {
+        return m_state == rhs.m_state;
+    }
+    bool operator!=(const tri_state & rhs) const {
+        return m_state != rhs.m_state;
+    }
+};
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// implement functions common to dataflow iterators
+template<class Derived>
+class dataflow {
+    bool m_eoi;
+protected:
+    // test for iterator equality
+    tri_state equal(const Derived & rhs) const {
+        if(m_eoi && rhs.m_eoi)
+            return true;
+        if(m_eoi || rhs.m_eoi)
+            return false;
+        return tri_state(tri_state::is_indeterminant);
+    }
+    void eoi(bool tf){
+        m_eoi = tf;
+    }
+    bool eoi() const {
+        return m_eoi;
+    }
+public:
+    dataflow(bool tf) :
+        m_eoi(tf)
+    {}
+    dataflow() : // used for iterator end
+        m_eoi(true)
+    {}
+};
+
+} // namespace iterators
+} // namespace archive
+} // namespace boost
+
+#endif // BOOST_ARCHIVE_ITERATORS_DATAFLOW_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/iterators/dataflow_exception.hpp b/contrib/libboost/boost_1_65_0/boost/archive/iterators/dataflow_exception.hpp
new file mode 100644
index 00000000000..e3e18605b38
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/archive/iterators/dataflow_exception.hpp
@@ -0,0 +1,80 @@
+#ifndef BOOST_ARCHIVE_ITERATORS_DATAFLOW_EXCEPTION_HPP
+#define BOOST_ARCHIVE_ITERATORS_DATAFLOW_EXCEPTION_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// dataflow_exception.hpp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+#include <boost/config.hpp>
+#ifndef BOOST_NO_EXCEPTIONS
+#include <exception>
+#endif //BOOST_NO_EXCEPTIONS
+
+#include <boost/assert.hpp>
+
+namespace boost {
+namespace archive {
+namespace iterators {
+
+//////////////////////////////////////////////////////////////////////
+// exceptions thrown by dataflows
+//
+class dataflow_exception : public std::exception
+{
+public:
+    typedef enum {
+        invalid_6_bitcode,
+        invalid_base64_character,
+        invalid_xml_escape_sequence,
+        comparison_not_permitted,
+        invalid_conversion,
+        other_exception
+    } exception_code;
+    exception_code code;
+
+    dataflow_exception(exception_code c = other_exception) : code(c)
+    {}
+
+    virtual const char *what( ) const throw( )
+    {
+        const char *msg = "unknown exception code";
+        switch(code){
+        case invalid_6_bitcode:
+            msg = "attempt to encode a value > 6 bits";
+            break;
+        case invalid_base64_character:
+            msg = "attempt to decode a value not in base64 char set";
+            break;
+        case invalid_xml_escape_sequence:
+            msg = "invalid xml escape_sequence";
+            break;
+        case comparison_not_permitted:
+            msg = "cannot invoke iterator comparison now";
+            break;
+        case invalid_conversion:
+            msg = "invalid multbyte/wide char conversion";
+            break;
+        default:
+            BOOST_ASSERT(false);
+            break;
+        }
+        return msg;
+    }
+};
+
+} // namespace iterators
+} // namespace archive
+} // namespace boost
+
+#endif //BOOST_ARCHIVE_ITERATORS_DATAFLOW_EXCEPTION_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/iterators/escape.hpp b/contrib/libboost/boost_1_65_0/boost/archive/iterators/escape.hpp
new file mode 100644
index 00000000000..103b31e0fef
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/archive/iterators/escape.hpp
@@ -0,0 +1,115 @@
+#ifndef BOOST_ARCHIVE_ITERATORS_ESCAPE_HPP
+#define BOOST_ARCHIVE_ITERATORS_ESCAPE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// escape.hpp
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+#include <boost/assert.hpp>
+#include <cstddef> // NULL
+
+#include <boost/iterator/iterator_adaptor.hpp>
+#include <boost/iterator/iterator_traits.hpp>
+
+namespace boost { 
+namespace archive {
+namespace iterators {
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// insert escapes into text
+
+template<class Derived, class Base>
+class escape : 
+    public boost::iterator_adaptor<
+        Derived, 
+        Base, 
+        typename boost::iterator_value<Base>::type,
+        single_pass_traversal_tag,
+        typename boost::iterator_value<Base>::type
+    >
+{
+    typedef typename boost::iterator_value<Base>::type base_value_type;
+    typedef typename boost::iterator_reference<Base>::type reference_type;
+    friend class boost::iterator_core_access;
+
+    typedef typename boost::iterator_adaptor<
+        Derived, 
+        Base, 
+        base_value_type,
+        single_pass_traversal_tag,
+        base_value_type
+    > super_t;
+
+    typedef escape<Derived, Base> this_t;
+
+    void dereference_impl() {
+        m_current_value = static_cast<Derived *>(this)->fill(m_bnext, m_bend);
+        m_full = true;
+    }
+
+    //Access the value referred to 
+    reference_type dereference() const {
+        if(!m_full)
+            const_cast<this_t *>(this)->dereference_impl();
+        return m_current_value;
+    }
+
+    bool equal(const this_t & rhs) const {
+        if(m_full){
+            if(! rhs.m_full)
+                const_cast<this_t *>(& rhs)->dereference_impl();
+        }
+        else{
+            if(rhs.m_full)
+                const_cast<this_t *>(this)->dereference_impl();
+        }
+        if(m_bnext != rhs.m_bnext)
+            return false;
+        if(this->base_reference() != rhs.base_reference())
+            return false;
+        return true;
+    }
+
+   void increment(){
+        if(++m_bnext < m_bend){
+            m_current_value = *m_bnext;
+            return;
+        }
+        ++(this->base_reference());
+        m_bnext = NULL;
+        m_bend = NULL;
+        m_full = false;
+    }
+
+    // buffer to handle pending characters
+    const base_value_type *m_bnext;
+    const base_value_type *m_bend;
+    bool m_full;
+    base_value_type m_current_value;
+public:
+    escape(Base base) : 
+        super_t(base),
+        m_bnext(NULL),
+        m_bend(NULL),
+        m_full(false),
+        m_current_value(0)
+    {
+    }
+};
+
+} // namespace iterators
+} // namespace archive
+} // namespace boost
+
+#endif // BOOST_ARCHIVE_ITERATORS_ESCAPE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/iterators/insert_linebreaks.hpp b/contrib/libboost/boost_1_65_0/boost/archive/iterators/insert_linebreaks.hpp
new file mode 100644
index 00000000000..2504b030db1
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/archive/iterators/insert_linebreaks.hpp
@@ -0,0 +1,99 @@
+#ifndef BOOST_ARCHIVE_ITERATORS_INSERT_LINEBREAKS_HPP
+#define BOOST_ARCHIVE_ITERATORS_INSERT_LINEBREAKS_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// insert_linebreaks.hpp
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+#include <boost/assert.hpp>
+
+#include <boost/config.hpp>
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{ using ::memcpy; }
+#endif
+
+#include <boost/iterator/iterator_adaptor.hpp>
+#include <boost/iterator/iterator_traits.hpp>
+
+namespace boost { 
+namespace archive {
+namespace iterators {
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// insert line break every N characters
+template<
+    class Base, 
+    int N, 
+    class CharType = typename boost::iterator_value<Base>::type
+>
+class insert_linebreaks : 
+    public iterator_adaptor<
+        insert_linebreaks<Base, N, CharType>,
+        Base,
+        CharType,
+        single_pass_traversal_tag,
+        CharType
+    >
+{
+private:
+    friend class boost::iterator_core_access;
+    typedef iterator_adaptor<
+        insert_linebreaks<Base, N, CharType>,
+        Base,
+        CharType,
+        single_pass_traversal_tag,
+        CharType
+    > super_t;
+
+    bool equal(const insert_linebreaks<Base, N, CharType> & rhs) const {
+        return
+//            m_count == rhs.m_count
+//            && base_reference() == rhs.base_reference()
+            this->base_reference() == rhs.base_reference()
+        ;
+    }
+
+    void increment() {
+        if(m_count == N){
+            m_count = 0;
+            return;
+        }
+        ++m_count;
+        ++(this->base_reference());
+    }
+    CharType dereference() const {
+        if(m_count == N)
+            return '\n';
+        return * (this->base_reference());
+    }
+    unsigned int m_count;
+public:
+    // make composible buy using templated constructor
+    template<class T>
+    insert_linebreaks(T  start) :
+        super_t(Base(static_cast< T >(start))),
+        m_count(0)
+    {}
+    // intel 7.1 doesn't like default copy constructor
+    insert_linebreaks(const insert_linebreaks & rhs) : 
+        super_t(rhs.base_reference()),
+        m_count(rhs.m_count)
+    {}
+};
+
+} // namespace iterators
+} // namespace archive
+} // namespace boost
+
+#endif // BOOST_ARCHIVE_ITERATORS_INSERT_LINEBREAKS_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/iterators/istream_iterator.hpp b/contrib/libboost/boost_1_65_0/boost/archive/iterators/istream_iterator.hpp
new file mode 100644
index 00000000000..a187f605e69
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/archive/iterators/istream_iterator.hpp
@@ -0,0 +1,92 @@
+#ifndef BOOST_ARCHIVE_ITERATORS_ISTREAM_ITERATOR_HPP
+#define BOOST_ARCHIVE_ITERATORS_ISTREAM_ITERATOR_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// istream_iterator.hpp
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+// note: this is a custom version of the standard istream_iterator.
+// This is necessary as the standard version doesn't work as expected
+// for wchar_t based streams on systems for which wchar_t not a true
+// type but rather a synonym for some integer type.
+
+#include <cstddef> // NULL
+#include <istream>
+#include <boost/iterator/iterator_facade.hpp>
+
+namespace boost { 
+namespace archive {
+namespace iterators {
+
+// given a type, make an input iterator based on a pointer to that type
+template<class Elem = char>
+class istream_iterator :  
+    public boost::iterator_facade<
+        istream_iterator<Elem>,
+        Elem,
+        std::input_iterator_tag,
+        Elem
+    >
+{
+    friend class boost::iterator_core_access;
+    typedef istream_iterator this_t ;
+    typedef typename boost::iterator_facade<
+        istream_iterator<Elem>,
+        Elem,
+        std::input_iterator_tag,
+        Elem
+    > super_t;
+    typedef typename std::basic_istream<Elem> istream_type;
+ 
+    bool equal(const this_t & rhs) const {
+        // note: only  works for comparison against end of stream
+        return m_istream == rhs.m_istream;
+    }
+
+    //Access the value referred to 
+    Elem dereference() const {
+        return static_cast<Elem>(m_istream->peek());
+    }
+
+    void increment(){
+        if(NULL != m_istream){
+            m_istream->ignore(1);
+        }
+    }
+
+    istream_type *m_istream;
+    Elem m_current_value;
+public:
+    istream_iterator(istream_type & is) :
+        m_istream(& is)
+    {
+        //increment();
+    }
+
+    istream_iterator() :
+        m_istream(NULL),
+        m_current_value(NULL)
+    {}
+
+    istream_iterator(const istream_iterator<Elem> & rhs) :
+        m_istream(rhs.m_istream),
+        m_current_value(rhs.m_current_value)
+    {}
+};
+
+} // namespace iterators
+} // namespace archive
+} // namespace boost
+
+#endif // BOOST_ARCHIVE_ITERATORS_ISTREAM_ITERATOR_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/iterators/mb_from_wchar.hpp b/contrib/libboost/boost_1_65_0/boost/archive/iterators/mb_from_wchar.hpp
new file mode 100644
index 00000000000..05df71c258e
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/archive/iterators/mb_from_wchar.hpp
@@ -0,0 +1,139 @@
+#ifndef BOOST_ARCHIVE_ITERATORS_MB_FROM_WCHAR_HPP
+#define BOOST_ARCHIVE_ITERATORS_MB_FROM_WCHAR_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// mb_from_wchar.hpp
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+#include <boost/assert.hpp>
+#include <cstddef> // size_t
+#ifndef BOOST_NO_CWCHAR
+#include <cwchar> //  mbstate_t
+#endif
+#include <boost/config.hpp>
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{ 
+    using ::mbstate_t;
+} // namespace std
+#endif
+
+#include <boost/archive/detail/utf8_codecvt_facet.hpp>
+#include <boost/iterator/iterator_adaptor.hpp>
+
+namespace boost { 
+namespace archive {
+namespace iterators {
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// class used by text archives to translate wide strings and to char
+// strings of the currently selected locale
+template<class Base>    // the input iterator
+class mb_from_wchar
+    : public boost::iterator_adaptor<
+        mb_from_wchar<Base>, 
+        Base, 
+        wchar_t,
+        single_pass_traversal_tag,
+        char
+    >
+{
+    friend class boost::iterator_core_access;
+
+    typedef typename boost::iterator_adaptor<
+        mb_from_wchar<Base>, 
+        Base, 
+        wchar_t,
+        single_pass_traversal_tag,
+        char
+    > super_t;
+
+    typedef mb_from_wchar<Base> this_t;
+
+    char dereference_impl() {
+        if(! m_full){
+            fill();
+            m_full = true;
+        }
+        return m_buffer[m_bnext];
+    }
+
+    char dereference() const {
+        return (const_cast<this_t *>(this))->dereference_impl();
+    }
+    // test for iterator equality
+    bool equal(const mb_from_wchar<Base> & rhs) const {
+        // once the value is filled, the base_reference has been incremented
+        // so don't permit comparison anymore.
+        return 
+            0 == m_bend
+            && 0 == m_bnext
+            && this->base_reference() == rhs.base_reference()
+        ;
+    }
+
+    void fill(){
+        wchar_t value = * this->base_reference();
+        const wchar_t *wend;
+        char *bend;
+        std::codecvt_base::result r = m_codecvt_facet.out(
+            m_mbs,
+            & value, & value + 1, wend,
+            m_buffer, m_buffer + sizeof(m_buffer), bend
+        );
+        BOOST_ASSERT(std::codecvt_base::ok == r);
+        m_bnext = 0;
+        m_bend = bend - m_buffer;
+    }
+
+    void increment(){
+        if(++m_bnext < m_bend)
+            return;
+        m_bend = 
+        m_bnext = 0;
+        ++(this->base_reference());
+        m_full = false;
+    }
+
+    boost::archive::detail::utf8_codecvt_facet m_codecvt_facet;
+    std::mbstate_t m_mbs;
+    // buffer to handle pending characters
+    char m_buffer[9 /* MB_CUR_MAX */];
+    std::size_t m_bend;
+    std::size_t m_bnext;
+    bool m_full;
+
+public:
+    // make composible buy using templated constructor
+    template<class T>
+    mb_from_wchar(T start) :
+        super_t(Base(static_cast< T >(start))),
+        m_mbs(std::mbstate_t()),
+        m_bend(0),
+        m_bnext(0),
+        m_full(false)
+    {}
+    // intel 7.1 doesn't like default copy constructor
+    mb_from_wchar(const mb_from_wchar & rhs) : 
+        super_t(rhs.base_reference()),
+        m_bend(rhs.m_bend),
+        m_bnext(rhs.m_bnext),
+        m_full(rhs.m_full)
+    {}
+};
+
+} // namespace iterators
+} // namespace archive
+} // namespace boost
+
+#endif // BOOST_ARCHIVE_ITERATORS_MB_FROM_WCHAR_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/iterators/ostream_iterator.hpp b/contrib/libboost/boost_1_65_0/boost/archive/iterators/ostream_iterator.hpp
new file mode 100644
index 00000000000..49a9b99034b
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/archive/iterators/ostream_iterator.hpp
@@ -0,0 +1,83 @@
+#ifndef BOOST_ARCHIVE_ITERATORS_OSTREAM_ITERATOR_HPP
+#define BOOST_ARCHIVE_ITERATORS_OSTREAM_ITERATOR_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// ostream_iterator.hpp
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+// note: this is a custom version of the standard ostream_iterator.
+// This is necessary as the standard version doesn't work as expected
+// for wchar_t based streams on systems for which wchar_t not a true
+// type but rather a synonym for some integer type.
+
+#include <ostream>
+#include <boost/iterator/iterator_facade.hpp>
+
+namespace boost { 
+namespace archive {
+namespace iterators {
+
+// given a type, make an input iterator based on a pointer to that type
+template<class Elem>
+class ostream_iterator :  
+    public boost::iterator_facade<
+        ostream_iterator<Elem>,
+        Elem,
+        std::output_iterator_tag,
+        ostream_iterator<Elem> &
+    >
+{
+    friend class boost::iterator_core_access;
+    typedef ostream_iterator this_t ;
+    typedef Elem char_type;
+    typedef std::basic_ostream<char_type> ostream_type;
+
+    //emulate the behavior of std::ostream 
+    ostream_iterator & dereference() const {
+        return const_cast<ostream_iterator &>(*this);
+    }
+    bool equal(const this_t & rhs) const {
+        return m_ostream == rhs.m_ostream;
+    }
+    void increment(){}
+protected:
+    ostream_type *m_ostream;
+    void put_val(char_type e){
+        if(NULL != m_ostream){
+            m_ostream->put(e);
+            if(! m_ostream->good())
+                m_ostream = NULL;
+        }
+    }
+public:
+    this_t & operator=(char_type c){
+        put_val(c);
+        return *this;
+    }
+    ostream_iterator(ostream_type & os) :
+        m_ostream (& os)
+    {}
+    ostream_iterator() :
+        m_ostream (NULL)
+    {}
+    ostream_iterator(const ostream_iterator & rhs) :
+        m_ostream (rhs.m_ostream)
+    {}
+};
+
+} // namespace iterators
+} // namespace archive
+} // namespace boost
+
+#endif // BOOST_ARCHIVE_ITERATORS_OSTREAM_ITERATOR_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/iterators/remove_whitespace.hpp b/contrib/libboost/boost_1_65_0/boost/archive/iterators/remove_whitespace.hpp
new file mode 100644
index 00000000000..c3580ab258a
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/archive/iterators/remove_whitespace.hpp
@@ -0,0 +1,167 @@
+#ifndef BOOST_ARCHIVE_ITERATORS_REMOVE_WHITESPACE_HPP
+#define BOOST_ARCHIVE_ITERATORS_REMOVE_WHITESPACE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// remove_whitespace.hpp
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+#include <boost/assert.hpp>
+
+#include <boost/iterator/iterator_adaptor.hpp>
+#include <boost/iterator/filter_iterator.hpp>
+#include <boost/iterator/iterator_traits.hpp>
+
+// here is the default standard implementation of the functor used
+// by the filter iterator to remove spaces.  Unfortunately usage
+// of this implementation in combination with spirit trips a bug
+// VC 6.5.  The only way I can find to work around it is to 
+// implement a special non-standard version for this platform
+
+#ifndef BOOST_NO_CWCTYPE
+#include <cwctype> // iswspace
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{ using ::iswspace; }
+#endif
+#endif
+
+#include <cctype> // isspace
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{ using ::isspace; }
+#endif
+
+#if defined(__STD_RWCOMPILER_H__) || defined(_RWSTD_VER)
+// this is required for the RW STL on Linux and Tru64.
+#undef isspace
+#undef iswspace
+#endif
+
+namespace { // anonymous
+
+template<class CharType>
+struct remove_whitespace_predicate;
+
+template<>
+struct remove_whitespace_predicate<char>
+{
+    bool operator()(unsigned char t){
+        return ! std::isspace(t);
+    }
+};
+
+#ifndef BOOST_NO_CWCHAR
+template<>
+struct remove_whitespace_predicate<wchar_t>
+{
+    bool operator()(wchar_t t){
+        return ! std::iswspace(t);
+    }
+};
+#endif
+
+} // namespace anonymous
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// convert base64 file data (including whitespace and padding) to binary
+
+namespace boost { 
+namespace archive {
+namespace iterators {
+
+// custom version of filter iterator which doesn't look ahead further than
+// necessary
+
+template<class Predicate, class Base>
+class filter_iterator
+    : public boost::iterator_adaptor<
+        filter_iterator<Predicate, Base>,
+        Base,
+        use_default,
+        single_pass_traversal_tag
+    >
+{
+    friend class boost::iterator_core_access;
+    typedef typename boost::iterator_adaptor<
+        filter_iterator<Predicate, Base>,
+        Base,
+        use_default,
+        single_pass_traversal_tag
+    > super_t;
+    typedef filter_iterator<Predicate, Base> this_t;
+    typedef typename super_t::reference reference_type;
+
+    reference_type dereference_impl(){
+        if(! m_full){
+            while(! m_predicate(* this->base_reference()))
+                ++(this->base_reference());
+            m_full = true;
+        }
+        return * this->base_reference();
+    }
+
+    reference_type dereference() const {
+        return const_cast<this_t *>(this)->dereference_impl();
+    }
+
+    Predicate m_predicate;
+    bool m_full;
+public:
+    // note: this function is public only because comeau compiler complained
+    // I don't know if this is because the compiler is wrong or what
+    void increment(){
+        m_full = false;
+        ++(this->base_reference());
+    }
+    filter_iterator(Base start) : 
+        super_t(start), 
+        m_full(false)
+    {}
+    filter_iterator(){}
+};
+
+template<class Base>
+class remove_whitespace : 
+    public filter_iterator<
+        remove_whitespace_predicate<
+            typename boost::iterator_value<Base>::type
+            //typename Base::value_type
+        >,
+        Base
+    >
+{
+    friend class boost::iterator_core_access;
+    typedef filter_iterator<
+        remove_whitespace_predicate<
+            typename boost::iterator_value<Base>::type
+            //typename Base::value_type
+        >,
+        Base
+    > super_t;
+public:
+//    remove_whitespace(){} // why is this needed?
+    // make composible buy using templated constructor
+    template<class T>
+    remove_whitespace(T start) :
+        super_t(Base(static_cast< T >(start)))
+    {}
+    // intel 7.1 doesn't like default copy constructor
+    remove_whitespace(const remove_whitespace & rhs) : 
+        super_t(rhs.base_reference())
+    {}
+};
+
+} // namespace iterators
+} // namespace archive
+} // namespace boost
+
+#endif // BOOST_ARCHIVE_ITERATORS_REMOVE_WHITESPACE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/iterators/transform_width.hpp b/contrib/libboost/boost_1_65_0/boost/archive/iterators/transform_width.hpp
new file mode 100644
index 00000000000..09c050a9274
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/archive/iterators/transform_width.hpp
@@ -0,0 +1,177 @@
+#ifndef BOOST_ARCHIVE_ITERATORS_TRANSFORM_WIDTH_HPP
+#define BOOST_ARCHIVE_ITERATORS_TRANSFORM_WIDTH_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// transform_width.hpp
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+// iterator which takes elements of x bits and returns elements of y bits.
+// used to change streams of 8 bit characters into streams of 6 bit characters.
+// and vice-versa for implementing base64 encodeing/decoding. Be very careful
+// when using and end iterator.  end is only reliable detected when the input
+// stream length is some common multiple of x and y.  E.G. Base64 6 bit
+// character and 8 bit bytes. Lowest common multiple is 24 => 4 6 bit characters
+// or 3 8 bit characters
+
+#include <boost/iterator/iterator_adaptor.hpp>
+#include <boost/iterator/iterator_traits.hpp>
+
+#include <algorithm> // std::min
+
+namespace boost { 
+namespace archive {
+namespace iterators {
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// class used by text archives to translate char strings to wchar_t
+// strings of the currently selected locale
+template<
+    class Base, 
+    int BitsOut, 
+    int BitsIn, 
+    class CharType = typename boost::iterator_value<Base>::type // output character
+>
+class transform_width : 
+    public boost::iterator_adaptor<
+        transform_width<Base, BitsOut, BitsIn, CharType>,
+        Base,
+        CharType,
+        single_pass_traversal_tag,
+        CharType
+    >
+{
+    friend class boost::iterator_core_access;
+    typedef typename boost::iterator_adaptor<
+        transform_width<Base, BitsOut, BitsIn, CharType>,
+        Base,
+        CharType,
+        single_pass_traversal_tag,
+        CharType
+    > super_t;
+
+    typedef transform_width<Base, BitsOut, BitsIn, CharType> this_t;
+    typedef typename iterator_value<Base>::type base_value_type;
+
+    void fill();
+
+    CharType dereference() const {
+        if(!m_buffer_out_full)
+            const_cast<this_t *>(this)->fill();
+        return m_buffer_out;
+    }
+
+    bool equal_impl(const this_t & rhs){
+        if(BitsIn < BitsOut) // discard any left over bits
+            return this->base_reference() == rhs.base_reference();
+        else{
+            // BitsIn > BitsOut  // zero fill
+            if(this->base_reference() == rhs.base_reference()){
+                m_end_of_sequence = true;
+                return 0 == m_remaining_bits;
+            }
+            return false;
+        }
+    }
+
+    // standard iterator interface
+    bool equal(const this_t & rhs) const {
+        return const_cast<this_t *>(this)->equal_impl(rhs);
+    }
+
+    void increment(){
+        m_buffer_out_full = false;
+    }
+
+    bool m_buffer_out_full;
+    CharType m_buffer_out;
+
+    // last read element from input
+    base_value_type m_buffer_in;
+
+    // number of bits to left in the input buffer.
+    unsigned int m_remaining_bits;
+
+    // flag to indicate we've reached end of data.
+    bool m_end_of_sequence;
+
+public:
+    // make composible buy using templated constructor
+    template<class T>
+    transform_width(T start) : 
+        super_t(Base(static_cast< T >(start))),
+        m_buffer_out_full(false),
+        m_buffer_out(0),
+        // To disable GCC warning, but not truly necessary 
+	    //(m_buffer_in will be initialized later before being 
+	    //used because m_remaining_bits == 0)
+        m_buffer_in(0), 
+        m_remaining_bits(0),
+        m_end_of_sequence(false)
+    {}
+    // intel 7.1 doesn't like default copy constructor
+    transform_width(const transform_width & rhs) : 
+        super_t(rhs.base_reference()),
+        m_buffer_out_full(rhs.m_buffer_out_full),
+        m_buffer_out(rhs.m_buffer_out),
+        m_buffer_in(rhs.m_buffer_in),
+        m_remaining_bits(rhs.m_remaining_bits),
+        m_end_of_sequence(false)
+    {}
+};
+
+template<
+    class Base, 
+    int BitsOut, 
+    int BitsIn, 
+    class CharType
+>
+void transform_width<Base, BitsOut, BitsIn, CharType>::fill() {
+    unsigned int missing_bits = BitsOut;
+    m_buffer_out = 0;
+    do{
+        if(0 == m_remaining_bits){
+            if(m_end_of_sequence){
+                m_buffer_in = 0;
+                m_remaining_bits = missing_bits;
+            }
+            else{
+                m_buffer_in = * this->base_reference()++;
+                m_remaining_bits = BitsIn;
+            }
+        }
+
+        // append these bits to the next output
+        // up to the size of the output
+        unsigned int i = (std::min)(missing_bits, m_remaining_bits);
+        // shift interesting bits to least significant position
+        base_value_type j = m_buffer_in >> (m_remaining_bits - i);
+        // and mask off the un interesting higher bits
+        // note presumption of twos complement notation
+        j &= (1 << i) - 1;
+        // append then interesting bits to the output value
+        m_buffer_out <<= i;
+        m_buffer_out |= j;
+
+        // and update counters
+        missing_bits -= i;
+        m_remaining_bits -= i;
+    }while(0 < missing_bits);
+    m_buffer_out_full = true;
+}
+
+} // namespace iterators
+} // namespace archive
+} // namespace boost
+
+#endif // BOOST_ARCHIVE_ITERATORS_TRANSFORM_WIDTH_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/iterators/unescape.hpp b/contrib/libboost/boost_1_65_0/boost/archive/iterators/unescape.hpp
new file mode 100644
index 00000000000..abf62406088
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/archive/iterators/unescape.hpp
@@ -0,0 +1,89 @@
+#ifndef BOOST_ARCHIVE_ITERATORS_UNESCAPE_HPP
+#define BOOST_ARCHIVE_ITERATORS_UNESCAPE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// unescape.hpp
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+#include <boost/assert.hpp>
+
+#include <boost/iterator/iterator_adaptor.hpp>
+#include <boost/pointee.hpp>
+
+namespace boost { 
+namespace archive {
+namespace iterators {
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// class used by text archives to translate char strings to wchar_t
+// strings of the currently selected locale
+template<class Derived, class Base>
+class unescape 
+    : public boost::iterator_adaptor<
+        unescape<Derived, Base>,
+        Base, 
+        typename pointee<Base>::type,
+        single_pass_traversal_tag,
+        typename pointee<Base>::type
+    >
+{
+    friend class boost::iterator_core_access;
+    typedef typename boost::iterator_adaptor<
+        unescape<Derived, Base>, 
+        Base, 
+        typename pointee<Base>::type,
+        single_pass_traversal_tag,
+        typename pointee<Base>::type
+    > super_t;
+
+    typedef unescape<Derived, Base> this_t;
+public:
+    typedef typename this_t::value_type value_type;
+    typedef typename this_t::reference reference;
+private:
+    value_type dereference_impl() {
+        if(! m_full){
+            m_current_value = static_cast<Derived *>(this)->drain();
+            m_full = true;
+        }
+        return m_current_value;
+    }
+
+    reference dereference() const {
+        return const_cast<this_t *>(this)->dereference_impl();
+    }
+
+    value_type m_current_value;
+    bool m_full;
+
+    void increment(){
+        ++(this->base_reference());
+        dereference_impl();
+        m_full = false;
+    };
+
+public:
+
+    unescape(Base base) : 
+        super_t(base),
+        m_full(false)
+    {}
+
+};
+
+} // namespace iterators
+} // namespace archive
+} // namespace boost
+
+#endif // BOOST_ARCHIVE_ITERATORS_UNESCAPE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/iterators/wchar_from_mb.hpp b/contrib/libboost/boost_1_65_0/boost/archive/iterators/wchar_from_mb.hpp
new file mode 100644
index 00000000000..2af8f6401f2
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/archive/iterators/wchar_from_mb.hpp
@@ -0,0 +1,194 @@
+#ifndef BOOST_ARCHIVE_ITERATORS_WCHAR_FROM_MB_HPP
+#define BOOST_ARCHIVE_ITERATORS_WCHAR_FROM_MB_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// wchar_from_mb.hpp
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+#include <boost/assert.hpp>
+#include <cctype>
+#include <cstddef> // size_t
+#ifndef BOOST_NO_CWCHAR
+#include <cwchar>  // mbstate_t
+#endif
+#include <algorithm> // copy
+
+#include <boost/config.hpp>
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{ 
+    using ::mbstate_t;
+} // namespace std
+#endif
+#include <boost/array.hpp>
+#include <boost/iterator/iterator_adaptor.hpp>
+#include <boost/archive/detail/utf8_codecvt_facet.hpp>
+#include <boost/archive/iterators/dataflow_exception.hpp>
+#include <boost/serialization/throw_exception.hpp>
+
+#include <iostream>
+
+namespace boost { 
+namespace archive {
+namespace iterators {
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// class used by text archives to translate char strings to wchar_t
+// strings of the currently selected locale
+template<class Base>
+class wchar_from_mb 
+    : public boost::iterator_adaptor<
+        wchar_from_mb<Base>, 
+        Base, 
+        wchar_t,
+        single_pass_traversal_tag,
+        wchar_t
+    >
+{
+    friend class boost::iterator_core_access;
+    typedef typename boost::iterator_adaptor<
+        wchar_from_mb<Base>, 
+        Base, 
+        wchar_t,
+        single_pass_traversal_tag,
+        wchar_t
+    > super_t;
+
+    typedef wchar_from_mb<Base> this_t;
+
+    void drain();
+
+    wchar_t dereference() const {
+        if(m_output.m_next == m_output.m_next_available)
+            return static_cast<wchar_t>(0);
+        return * m_output.m_next;
+    }
+
+    void increment(){
+        if(m_output.m_next == m_output.m_next_available)
+            return;
+        if(++m_output.m_next == m_output.m_next_available){
+            if(m_input.m_done)
+                return;
+            drain();
+        }
+    }
+
+    bool equal(this_t const & rhs) const {
+        return dereference() == rhs.dereference();
+    }
+
+    boost::archive::detail::utf8_codecvt_facet m_codecvt_facet;
+    std::mbstate_t m_mbs;
+
+    template<typename T>
+    struct sliding_buffer {
+        boost::array<T, 32> m_buffer;
+        typename boost::array<T, 32>::const_iterator m_next_available;
+        typename boost::array<T, 32>::iterator m_next;
+        bool m_done;
+        // default ctor
+        sliding_buffer() :
+            m_next_available(m_buffer.begin()),
+            m_next(m_buffer.begin()),
+            m_done(false)
+        {}
+        // copy ctor
+        sliding_buffer(const sliding_buffer & rhs) :
+            m_next_available(
+                std::copy(
+                    rhs.m_buffer.begin(),
+                    rhs.m_next_available,
+                    m_buffer.begin()
+                )
+            ),
+            m_next(
+                m_buffer.begin() + (rhs.m_next - rhs.m_buffer.begin())
+            ),
+            m_done(rhs.m_done)
+        {}
+    };
+
+    sliding_buffer<typename iterator_value<Base>::type> m_input;
+    sliding_buffer<typename iterator_value<this_t>::type> m_output;
+
+public:
+    // make composible buy using templated constructor
+    template<class T>
+    wchar_from_mb(T start) : 
+        super_t(Base(static_cast< T >(start))),
+        m_mbs(std::mbstate_t())
+    {
+        BOOST_ASSERT(std::mbsinit(&m_mbs));
+        drain();
+    }
+    // default constructor used as an end iterator
+    wchar_from_mb(){}
+
+    // copy ctor
+    wchar_from_mb(const wchar_from_mb & rhs) :
+        super_t(rhs.base_reference()),
+        m_mbs(rhs.m_mbs),
+        m_input(rhs.m_input),
+        m_output(rhs.m_output)
+    {}
+};
+
+template<class Base>
+void wchar_from_mb<Base>::drain(){
+    BOOST_ASSERT(! m_input.m_done);
+    for(;;){
+        typename boost::iterators::iterator_reference<Base>::type c = *(this->base_reference());
+        // a null character in a multibyte stream is takes as end of string
+        if(0 == c){
+            m_input.m_done = true;
+            break;
+        }
+        ++(this->base_reference());
+        * const_cast<typename iterator_value<Base>::type *>(
+            (m_input.m_next_available++)
+        ) = c;
+        // if input buffer is full - we're done for now
+        if(m_input.m_buffer.end() == m_input.m_next_available)
+            break;
+    }
+    const typename boost::iterators::iterator_value<Base>::type * input_new_start;
+    typename iterator_value<this_t>::type * next_available;
+
+    std::codecvt_base::result r = m_codecvt_facet.in(
+        m_mbs,
+        m_input.m_buffer.begin(),
+        m_input.m_next_available,
+        input_new_start,
+        m_output.m_buffer.begin(),
+        m_output.m_buffer.end(),
+        next_available
+    );
+    BOOST_ASSERT(std::codecvt_base::ok == r);
+    m_output.m_next_available = next_available;
+    m_output.m_next = m_output.m_buffer.begin();
+
+    // we're done with some of the input so shift left.
+    m_input.m_next_available = std::copy(
+        input_new_start,
+        m_input.m_next_available,
+        m_input.m_buffer.begin()
+    );
+    m_input.m_next = m_input.m_buffer.begin();
+}
+
+} // namespace iterators
+} // namespace archive
+} // namespace boost
+
+#endif // BOOST_ARCHIVE_ITERATORS_WCHAR_FROM_MB_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/iterators/xml_escape.hpp b/contrib/libboost/boost_1_65_0/boost/archive/iterators/xml_escape.hpp
new file mode 100644
index 00000000000..c838a73b864
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/archive/iterators/xml_escape.hpp
@@ -0,0 +1,121 @@
+#ifndef BOOST_ARCHIVE_ITERATORS_XML_ESCAPE_HPP
+#define BOOST_ARCHIVE_ITERATORS_XML_ESCAPE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// xml_escape.hpp
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+#include <boost/assert.hpp>
+#include <boost/archive/iterators/escape.hpp>
+
+namespace boost { 
+namespace archive {
+namespace iterators {
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// insert escapes into xml text
+
+template<class Base>
+class xml_escape 
+    : public escape<xml_escape<Base>, Base>
+{
+    friend class boost::iterator_core_access;
+
+    typedef escape<xml_escape<Base>, Base> super_t;
+
+public:
+    char fill(const char * & bstart, const char * & bend);
+    wchar_t fill(const wchar_t * & bstart, const wchar_t * & bend);
+
+    template<class T>
+    xml_escape(T start) :
+        super_t(Base(static_cast< T >(start)))
+    {}
+    // intel 7.1 doesn't like default copy constructor
+    xml_escape(const xml_escape & rhs) : 
+        super_t(rhs.base_reference())
+    {}
+};
+
+template<class Base>
+char xml_escape<Base>::fill(
+    const char * & bstart, 
+    const char * & bend
+){
+    char current_value = * this->base_reference();
+    switch(current_value){
+    case '<':
+        bstart = "&lt;";
+        bend = bstart + 4;
+        break;
+    case '>':
+        bstart = "&gt;";
+        bend = bstart + 4;
+        break;
+    case '&':
+        bstart = "&amp;";
+        bend = bstart + 5;
+        break;
+    case '"':
+        bstart = "&quot;";
+        bend = bstart + 6;
+        break;
+    case '\'':
+        bstart = "&apos;";
+        bend = bstart + 6;
+        break;
+    default:
+        return current_value;
+    }
+    return *bstart;
+}
+
+template<class Base>
+wchar_t xml_escape<Base>::fill(
+    const wchar_t * & bstart, 
+    const wchar_t * & bend
+){
+    wchar_t current_value = * this->base_reference();
+    switch(current_value){
+    case '<':
+        bstart = L"&lt;";
+        bend = bstart + 4;
+        break;
+    case '>':
+        bstart = L"&gt;";
+        bend = bstart + 4;
+        break;
+    case '&':
+        bstart = L"&amp;";
+        bend = bstart + 5;
+        break;
+    case '"':
+        bstart = L"&quot;";
+        bend = bstart + 6;
+        break;
+    case '\'':
+        bstart = L"&apos;";
+        bend = bstart + 6;
+        break;
+    default:
+        return current_value;
+    }
+    return *bstart;
+}
+
+} // namespace iterators
+} // namespace archive
+} // namespace boost
+
+#endif // BOOST_ARCHIVE_ITERATORS_XML_ESCAPE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/iterators/xml_unescape.hpp b/contrib/libboost/boost_1_65_0/boost/archive/iterators/xml_unescape.hpp
new file mode 100644
index 00000000000..69977404567
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/archive/iterators/xml_unescape.hpp
@@ -0,0 +1,125 @@
+#ifndef BOOST_ARCHIVE_ITERATORS_XML_UNESCAPE_HPP
+#define BOOST_ARCHIVE_ITERATORS_XML_UNESCAPE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// xml_unescape.hpp
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+#include <boost/assert.hpp>
+
+#include <boost/serialization/throw_exception.hpp>
+
+#include <boost/archive/iterators/unescape.hpp>
+#include <boost/archive/iterators/dataflow_exception.hpp>
+
+namespace boost { 
+namespace archive {
+namespace iterators {
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// replace &??? xml escape sequences with the corresponding characters
+template<class Base>
+class xml_unescape 
+    : public unescape<xml_unescape<Base>, Base>
+{
+    friend class boost::iterator_core_access;
+    typedef xml_unescape<Base> this_t;
+    typedef unescape<this_t, Base> super_t;
+    typedef typename boost::iterator_reference<this_t> reference_type;
+
+    reference_type dereference() const {
+        return unescape<xml_unescape<Base>, Base>::dereference();
+    }
+public:
+    // workaround msvc 7.1 ICU crash
+    #if defined(BOOST_MSVC)
+        typedef int value_type;
+    #else
+        typedef typename this_t::value_type value_type;
+    #endif
+
+    void drain_residue(const char *literal);
+    value_type drain();
+
+    template<class T>
+    xml_unescape(T start) : 
+        super_t(Base(static_cast< T >(start)))
+    {}
+    // intel 7.1 doesn't like default copy constructor
+    xml_unescape(const xml_unescape & rhs) : 
+        super_t(rhs.base_reference())
+    {}
+};
+
+template<class Base>
+void xml_unescape<Base>::drain_residue(const char * literal){
+    do{
+        if(* literal != * ++(this->base_reference()))
+            boost::serialization::throw_exception(
+                dataflow_exception(
+                    dataflow_exception::invalid_xml_escape_sequence
+                )
+            );
+    }
+    while('\0' != * ++literal);
+}
+
+// note key constraint on this function is that can't "look ahead" any
+// more than necessary into base iterator.  Doing so would alter the base
+// iterator refenence which would make subsequent iterator comparisons
+// incorrect and thereby break the composiblity of iterators.
+template<class Base>
+typename xml_unescape<Base>::value_type 
+//int 
+xml_unescape<Base>::drain(){
+    value_type retval = * this->base_reference();
+    if('&' != retval){
+        return retval;
+    }
+    retval = * ++(this->base_reference());
+    switch(retval){
+    case 'l': // &lt;
+        drain_residue("t;");
+        retval = '<';
+        break;
+    case 'g': // &gt;
+        drain_residue("t;");
+        retval = '>';
+        break;
+    case 'a':
+        retval = * ++(this->base_reference());
+        switch(retval){
+        case 'p': // &apos;
+            drain_residue("os;");
+            retval = '\'';
+            break;
+        case 'm': // &amp;
+            drain_residue("p;");
+            retval = '&';
+            break;
+        }
+        break;
+    case 'q':
+        drain_residue("uot;");
+        retval = '"';
+        break;
+    }
+    return retval;
+}
+
+} // namespace iterators
+} // namespace archive
+} // namespace boost
+
+#endif // BOOST_ARCHIVE_ITERATORS_XML_UNESCAPE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/iterators/xml_unescape_exception.hpp b/contrib/libboost/boost_1_65_0/boost/archive/iterators/xml_unescape_exception.hpp
new file mode 100644
index 00000000000..71a64378c20
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/archive/iterators/xml_unescape_exception.hpp
@@ -0,0 +1,49 @@
+#ifndef BOOST_ARCHIVE_ITERATORS_XML_UNESCAPE_EXCEPTION_HPP
+#define BOOST_ARCHIVE_ITERATORS_XML_UNESCAPE_EXCEPTION_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// xml_unescape_exception.hpp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+#include <boost/config.hpp>
+#ifndef BOOST_NO_EXCEPTIONS
+#include <exception>
+
+#include <boost/assert.hpp>
+
+namespace boost {
+namespace archive {
+namespace iterators {
+
+//////////////////////////////////////////////////////////////////////
+// exceptions thrown by xml_unescapes
+//
+class xml_unescape_exception : public std::exception
+{
+public:
+    xml_unescape_exception()
+    {}
+
+    virtual const char *what( ) const throw( )
+    {
+        return "xml contained un-recognized escape code";
+    }
+};
+
+} // namespace iterators
+} // namespace archive
+} // namespace boost
+
+#endif //BOOST_NO_EXCEPTIONS
+#endif //BOOST_ARCHIVE_ITERATORS_XML_UNESCAPE_EXCEPTION_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/polymorphic_binary_iarchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/polymorphic_binary_iarchive.hpp
new file mode 100644
index 00000000000..4a898a8ad16
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/archive/polymorphic_binary_iarchive.hpp
@@ -0,0 +1,54 @@
+#ifndef BOOST_ARCHIVE_POLYMORPHIC_BINARY_IARCHIVE_HPP
+#define BOOST_ARCHIVE_POLYMORPHIC_BINARY_IARCHIVE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// polymorphic_binary_iarchive.hpp
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+#include <boost/config.hpp>
+#include <boost/archive/binary_iarchive.hpp>
+#include <boost/archive/detail/polymorphic_iarchive_route.hpp>
+
+#ifdef BOOST_MSVC
+#  pragma warning(push)
+#  pragma warning(disable : 4511 4512)
+#endif
+
+namespace boost { 
+namespace archive {
+
+class polymorphic_binary_iarchive : 
+    public detail::polymorphic_iarchive_route<binary_iarchive>
+{
+public:
+    polymorphic_binary_iarchive(std::istream & is, unsigned int flags = 0) :
+        detail::polymorphic_iarchive_route<binary_iarchive>(is, flags)
+    {}
+    ~polymorphic_binary_iarchive(){}
+};
+
+} // namespace archive
+} // namespace boost
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+// required by export
+BOOST_SERIALIZATION_REGISTER_ARCHIVE(
+    boost::archive::polymorphic_binary_iarchive
+)
+
+#endif // BOOST_ARCHIVE_POLYMORPHIC_BINARY_IARCHIVE_HPP
+
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/polymorphic_binary_oarchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/polymorphic_binary_oarchive.hpp
new file mode 100644
index 00000000000..931b243feb8
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/archive/polymorphic_binary_oarchive.hpp
@@ -0,0 +1,43 @@
+#ifndef BOOST_ARCHIVE_POLYMORPHIC_BINARY_OARCHIVE_HPP
+#define BOOST_ARCHIVE_POLYMORPHIC_BINARY_OARCHIVE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// polymorphic_binary_oarchive.hpp
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+#include <boost/config.hpp>
+#include <boost/archive/binary_oarchive.hpp>
+#include <boost/archive/detail/polymorphic_oarchive_route.hpp>
+
+namespace boost { 
+namespace archive {
+
+typedef detail::polymorphic_oarchive_route<
+    binary_oarchive_impl<
+        binary_oarchive, 
+        std::ostream::char_type, 
+        std::ostream::traits_type
+    >
+ > polymorphic_binary_oarchive;
+
+} // namespace archive
+} // namespace boost
+
+// required by export
+BOOST_SERIALIZATION_REGISTER_ARCHIVE(
+    boost::archive::polymorphic_binary_oarchive
+)
+
+#endif // BOOST_ARCHIVE_POLYMORPHIC_BINARY_OARCHIVE_HPP
+
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/polymorphic_iarchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/polymorphic_iarchive.hpp
new file mode 100644
index 00000000000..d3c59a9f0f4
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/archive/polymorphic_iarchive.hpp
@@ -0,0 +1,168 @@
+#ifndef BOOST_ARCHIVE_POLYMORPHIC_IARCHIVE_HPP
+#define BOOST_ARCHIVE_POLYMORPHIC_IARCHIVE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// polymorphic_iarchive.hpp
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+#include <cstddef> // std::size_t
+#include <climits> // ULONG_MAX 
+#include <string>
+
+#include <boost/config.hpp>
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{
+    using ::size_t;
+} // namespace std
+#endif
+
+#include <boost/cstdint.hpp>
+
+#include <boost/archive/detail/iserializer.hpp>
+#include <boost/archive/detail/interface_iarchive.hpp>
+#include <boost/serialization/nvp.hpp>
+#include <boost/archive/detail/register_archive.hpp>
+
+#include <boost/archive/detail/decl.hpp>
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+namespace boost {
+namespace serialization {
+    class extended_type_info;
+} // namespace serialization
+namespace archive {
+namespace detail {
+    class basic_iarchive;
+    class basic_iserializer;
+}
+
+class polymorphic_iarchive;
+
+class BOOST_SYMBOL_VISIBLE polymorphic_iarchive_impl :
+    public detail::interface_iarchive<polymorphic_iarchive>
+{
+#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
+public:
+#else
+    friend class detail::interface_iarchive<polymorphic_iarchive>;
+    friend class load_access;
+#endif
+    // primitive types the only ones permitted by polymorphic archives
+    virtual void load(bool & t) = 0;
+
+    virtual void load(char & t) = 0;
+    virtual void load(signed char & t) = 0;
+    virtual void load(unsigned char & t) = 0;
+    #ifndef BOOST_NO_CWCHAR
+    #ifndef BOOST_NO_INTRINSIC_WCHAR_T
+    virtual void load(wchar_t & t) = 0;
+    #endif
+    #endif
+    virtual void load(short & t) = 0;
+    virtual void load(unsigned short & t) = 0;
+    virtual void load(int & t) = 0;
+    virtual void load(unsigned int & t) = 0;
+    virtual void load(long & t) = 0;
+    virtual void load(unsigned long & t) = 0;
+
+    #if defined(BOOST_HAS_LONG_LONG)
+    virtual void load(boost::long_long_type & t) = 0;
+    virtual void load(boost::ulong_long_type & t) = 0;
+    #elif defined(BOOST_HAS_MS_INT64)
+    virtual void load(__int64 & t) = 0;
+    virtual void load(unsigned __int64 & t) = 0;
+    #endif
+
+    virtual void load(float & t) = 0;
+    virtual void load(double & t) = 0;
+
+    // string types are treated as primitives
+    virtual void load(std::string & t) = 0;
+    #ifndef BOOST_NO_STD_WSTRING
+    virtual void load(std::wstring & t) = 0;
+    #endif
+
+    // used for xml and other tagged formats
+    virtual void load_start(const char * name) = 0;
+    virtual void load_end(const char * name) = 0;
+    virtual void register_basic_serializer(const detail::basic_iserializer & bis) = 0;
+    virtual detail::helper_collection & get_helper_collection() = 0;
+
+    // msvc and borland won't automatically pass these to the base class so
+    // make it explicit here
+    template<class T>
+    void load_override(T & t)
+    {
+        archive::load(* this->This(), t);
+    }
+    // special treatment for name-value pairs.
+    template<class T>
+    void load_override(
+        const boost::serialization::nvp< T > & t
+    ){
+        load_start(t.name());
+        archive::load(* this->This(), t.value());
+        load_end(t.name());
+    }
+protected:
+    virtual ~polymorphic_iarchive_impl(){};
+public:
+    // utility function implemented by all legal archives
+    virtual void set_library_version(library_version_type archive_library_version) = 0;
+    virtual library_version_type get_library_version() const = 0;
+    virtual unsigned int get_flags() const = 0;
+    virtual void delete_created_pointers() = 0;
+    virtual void reset_object_address(
+        const void * new_address,
+        const void * old_address
+    ) = 0;
+
+    virtual void load_binary(void * t, std::size_t size) = 0;
+
+    // these are used by the serialization library implementation.
+    virtual void load_object(
+        void *t,
+        const detail::basic_iserializer & bis
+    ) = 0;
+    virtual const detail::basic_pointer_iserializer * load_pointer(
+        void * & t,
+        const detail::basic_pointer_iserializer * bpis_ptr,
+        const detail::basic_pointer_iserializer * (*finder)(
+            const boost::serialization::extended_type_info & type
+        )
+    ) = 0;
+};
+
+} // namespace archive
+} // namespace boost
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+namespace boost {
+namespace archive {
+
+class BOOST_SYMBOL_VISIBLE polymorphic_iarchive :
+    public polymorphic_iarchive_impl
+{
+public:
+    virtual ~polymorphic_iarchive(){};
+};
+
+} // namespace archive
+} // namespace boost
+
+// required by export
+BOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::polymorphic_iarchive)
+
+#endif // BOOST_ARCHIVE_POLYMORPHIC_IARCHIVE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/polymorphic_oarchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/polymorphic_oarchive.hpp
new file mode 100644
index 00000000000..edac4edb1e8
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/archive/polymorphic_oarchive.hpp
@@ -0,0 +1,154 @@
+#ifndef BOOST_ARCHIVE_POLYMORPHIC_OARCHIVE_HPP
+#define BOOST_ARCHIVE_POLYMORPHIC_OARCHIVE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// polymorphic_oarchive.hpp
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+#include <cstddef> // size_t
+#include <climits> // ULONG_MAX 
+#include <string>
+
+#include <boost/config.hpp>
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{
+    using ::size_t;
+} // namespace std
+#endif
+
+#include <boost/cstdint.hpp>
+#include <boost/archive/detail/oserializer.hpp>
+#include <boost/archive/detail/interface_oarchive.hpp>
+#include <boost/serialization/nvp.hpp>
+#include <boost/archive/detail/register_archive.hpp>
+
+#include <boost/archive/detail/decl.hpp>
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+namespace boost {
+namespace serialization {
+    class extended_type_info;
+} // namespace serialization
+namespace archive {
+namespace detail {
+    class basic_oarchive;
+    class basic_oserializer;
+}
+
+class polymorphic_oarchive;
+
+class BOOST_SYMBOL_VISIBLE polymorphic_oarchive_impl :
+    public detail::interface_oarchive<polymorphic_oarchive>
+{
+#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
+public:
+#else
+    friend class detail::interface_oarchive<polymorphic_oarchive>;
+    friend class save_access;
+#endif
+    // primitive types the only ones permitted by polymorphic archives
+    virtual void save(const bool t) = 0;
+
+    virtual void save(const char t) = 0;
+    virtual void save(const signed char t) = 0;
+    virtual void save(const unsigned char t) = 0;
+    #ifndef BOOST_NO_CWCHAR
+    #ifndef BOOST_NO_INTRINSIC_WCHAR_T
+    virtual void save(const wchar_t t) = 0;
+    #endif
+    #endif
+    virtual void save(const short t) = 0;
+    virtual void save(const unsigned short t) = 0;
+    virtual void save(const int t) = 0;
+    virtual void save(const unsigned int t) = 0;
+    virtual void save(const long t) = 0;
+    virtual void save(const unsigned long t) = 0;
+
+    #if defined(BOOST_HAS_LONG_LONG)
+    virtual void save(const boost::long_long_type t) = 0;
+    virtual void save(const boost::ulong_long_type t) = 0;
+    #elif defined(BOOST_HAS_MS_INT64)
+    virtual void save(const __int64 t) = 0;
+    virtual void save(const unsigned __int64 t) = 0;
+    #endif
+
+    virtual void save(const float t) = 0;
+    virtual void save(const double t) = 0;
+
+    // string types are treated as primitives
+    virtual void save(const std::string & t) = 0;
+    #ifndef BOOST_NO_STD_WSTRING
+    virtual void save(const std::wstring & t) = 0;
+    #endif
+
+    virtual void save_null_pointer() = 0;
+    // used for xml and other tagged formats
+    virtual void save_start(const char * name) = 0;
+    virtual void save_end(const char * name) = 0;
+    virtual void register_basic_serializer(const detail::basic_oserializer & bos) = 0;
+    virtual detail::helper_collection & get_helper_collection() = 0;
+
+    virtual void end_preamble() = 0;
+
+    // msvc and borland won't automatically pass these to the base class so
+    // make it explicit here
+    template<class T>
+    void save_override(T & t)
+    {
+        archive::save(* this->This(), t);
+    }
+    // special treatment for name-value pairs.
+    template<class T>
+    void save_override(
+            const ::boost::serialization::nvp< T > & t
+        ){
+        save_start(t.name());
+        archive::save(* this->This(), t.const_value());
+        save_end(t.name());
+    }
+protected:
+    virtual ~polymorphic_oarchive_impl(){};
+public:
+    // utility functions implemented by all legal archives
+    virtual unsigned int get_flags() const = 0;
+    virtual library_version_type get_library_version() const = 0;
+    virtual void save_binary(const void * t, std::size_t size) = 0;
+
+    virtual void save_object(
+        const void *x,
+        const detail::basic_oserializer & bos
+    ) = 0;
+    virtual void save_pointer(
+        const void * t,
+        const detail::basic_pointer_oserializer * bpos_ptr
+    ) = 0;
+};
+
+// note: preserve naming symmetry
+class BOOST_SYMBOL_VISIBLE polymorphic_oarchive : 
+    public polymorphic_oarchive_impl
+{
+public:
+    virtual ~polymorphic_oarchive(){};
+};
+
+} // namespace archive
+} // namespace boost
+
+// required by export
+BOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::polymorphic_oarchive)
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#endif // BOOST_ARCHIVE_POLYMORPHIC_OARCHIVE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/polymorphic_text_iarchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/polymorphic_text_iarchive.hpp
new file mode 100644
index 00000000000..7bef2927865
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/archive/polymorphic_text_iarchive.hpp
@@ -0,0 +1,54 @@
+#ifndef BOOST_ARCHIVE_POLYMORPHIC_TEXT_IARCHIVE_HPP
+#define BOOST_ARCHIVE_POLYMORPHIC_TEXT_IARCHIVE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// polymorphic_text_iarchive.hpp
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+#include <boost/config.hpp>
+#include <boost/archive/text_iarchive.hpp>
+#include <boost/archive/detail/polymorphic_iarchive_route.hpp>
+
+#ifdef BOOST_MSVC
+#  pragma warning(push)
+#  pragma warning(disable : 4511 4512)
+#endif
+
+namespace boost { 
+namespace archive {
+
+class polymorphic_text_iarchive : 
+    public detail::polymorphic_iarchive_route<text_iarchive>
+{
+public:
+    polymorphic_text_iarchive(std::istream & is, unsigned int flags = 0) :
+        detail::polymorphic_iarchive_route<text_iarchive>(is, flags)
+    {}
+    ~polymorphic_text_iarchive(){}
+};
+
+} // namespace archive
+} // namespace boost
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+// required by export
+BOOST_SERIALIZATION_REGISTER_ARCHIVE(
+    boost::archive::polymorphic_text_iarchive
+)
+
+#endif // BOOST_ARCHIVE_POLYMORPHIC_TEXT_IARCHIVE_HPP
+
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/polymorphic_text_oarchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/polymorphic_text_oarchive.hpp
new file mode 100644
index 00000000000..457aad9fd75
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/archive/polymorphic_text_oarchive.hpp
@@ -0,0 +1,39 @@
+#ifndef BOOST_ARCHIVE_POLYMORPHIC_TEXT_OARCHIVE_HPP
+#define BOOST_ARCHIVE_POLYMORPHIC_TEXT_OARCHIVE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// polymorphic_text_oarchive.hpp
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+#include <boost/config.hpp>
+#include <boost/archive/text_oarchive.hpp>
+#include <boost/archive/detail/polymorphic_oarchive_route.hpp>
+
+namespace boost { 
+namespace archive {
+
+typedef detail::polymorphic_oarchive_route<
+    text_oarchive_impl<text_oarchive> 
+> polymorphic_text_oarchive;
+
+} // namespace archive
+} // namespace boost
+
+// required by export
+BOOST_SERIALIZATION_REGISTER_ARCHIVE(
+    boost::archive::polymorphic_text_oarchive
+)
+
+#endif // BOOST_ARCHIVE_POLYMORPHIC_TEXT_OARCHIVE_HPP
+
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/polymorphic_text_wiarchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/polymorphic_text_wiarchive.hpp
new file mode 100644
index 00000000000..8466f05d6a6
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/archive/polymorphic_text_wiarchive.hpp
@@ -0,0 +1,59 @@
+#ifndef BOOST_ARCHIVE_POLYMORPHIC_TEXT_WIARCHIVE_HPP
+#define BOOST_ARCHIVE_POLYMORPHIC_TEXT_WIARCHIVE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// polymorphic_text_wiarchive.hpp
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+#include <boost/config.hpp>
+#ifdef BOOST_NO_STD_WSTREAMBUF
+#error "wide char i/o not supported on this platform"
+#else
+
+#include <boost/archive/text_wiarchive.hpp>
+#include <boost/archive/detail/polymorphic_iarchive_route.hpp>
+
+#ifdef BOOST_MSVC
+#  pragma warning(push)
+#  pragma warning(disable : 4511 4512)
+#endif
+
+namespace boost { 
+namespace archive {
+
+class polymorphic_text_wiarchive : 
+    public detail::polymorphic_iarchive_route<text_wiarchive>
+{
+public:
+    polymorphic_text_wiarchive(std::wistream & is, unsigned int flags = 0) :
+        detail::polymorphic_iarchive_route<text_wiarchive>(is, flags)
+    {}
+    ~polymorphic_text_wiarchive(){}
+};
+
+} // namespace archive
+} // namespace boost
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+// required by export
+BOOST_SERIALIZATION_REGISTER_ARCHIVE(
+    boost::archive::polymorphic_text_wiarchive
+)
+
+#endif // BOOST_NO_STD_WSTREAMBUF
+#endif // BOOST_ARCHIVE_POLYMORPHIC_TEXT_WIARCHIVE_HPP
+
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/polymorphic_text_woarchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/polymorphic_text_woarchive.hpp
new file mode 100644
index 00000000000..295625d1bcf
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/archive/polymorphic_text_woarchive.hpp
@@ -0,0 +1,44 @@
+#ifndef BOOST_ARCHIVE_POLYMORPHIC_TEXT_WOARCHIVE_HPP
+#define BOOST_ARCHIVE_POLYMORPHIC_TEXT_WOARCHIVE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// polymorphic_text_oarchive.hpp
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+#include <boost/config.hpp>
+#ifdef BOOST_NO_STD_WSTREAMBUF
+#error "wide char i/o not supported on this platform"
+#else
+
+#include <boost/archive/text_woarchive.hpp>
+#include <boost/archive/detail/polymorphic_oarchive_route.hpp>
+
+namespace boost { 
+namespace archive {
+
+typedef detail::polymorphic_oarchive_route<
+    text_woarchive_impl<text_woarchive> 
+> polymorphic_text_woarchive;
+
+} // namespace archive
+} // namespace boost
+
+// required by export
+BOOST_SERIALIZATION_REGISTER_ARCHIVE(
+    boost::archive::polymorphic_text_woarchive
+)
+
+#endif // BOOST_NO_STD_WSTREAMBUF 
+#endif // BOOST_ARCHIVE_POLYMORPHIC_TEXT_WOARCHIVE_HPP
+
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/polymorphic_xml_iarchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/polymorphic_xml_iarchive.hpp
new file mode 100644
index 00000000000..4dc3f894b38
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/archive/polymorphic_xml_iarchive.hpp
@@ -0,0 +1,54 @@
+#ifndef BOOST_ARCHIVE_POLYMORPHIC_XML_IARCHIVE_HPP
+#define BOOST_ARCHIVE_POLYMORPHIC_XML_IARCHIVE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// polymorphic_xml_iarchive.hpp
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+#include <boost/config.hpp>
+#include <boost/archive/xml_iarchive.hpp>
+#include <boost/archive/detail/polymorphic_iarchive_route.hpp>
+
+#ifdef BOOST_MSVC
+#  pragma warning(push)
+#  pragma warning(disable : 4511 4512)
+#endif
+
+namespace boost { 
+namespace archive {
+
+class polymorphic_xml_iarchive : 
+    public detail::polymorphic_iarchive_route<xml_iarchive>
+{
+public:
+    polymorphic_xml_iarchive(std::istream & is, unsigned int flags = 0) :
+        detail::polymorphic_iarchive_route<xml_iarchive>(is, flags)
+    {}
+    ~polymorphic_xml_iarchive(){}
+};
+
+} // namespace archive
+} // namespace boost
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+// required by export
+BOOST_SERIALIZATION_REGISTER_ARCHIVE(
+    boost::archive::polymorphic_xml_iarchive
+)
+
+#endif // BOOST_ARCHIVE_POLYMORPHIC_XML_IARCHIVE_HPP
+
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/polymorphic_xml_oarchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/polymorphic_xml_oarchive.hpp
new file mode 100644
index 00000000000..514f9e530a8
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/archive/polymorphic_xml_oarchive.hpp
@@ -0,0 +1,39 @@
+#ifndef BOOST_ARCHIVE_POLYMORPHIC_XML_OARCHIVE_HPP
+#define BOOST_ARCHIVE_POLYMORPHIC_XML_OARCHIVE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// polymorphic_xml_oarchive.hpp
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+#include <boost/config.hpp>
+#include <boost/archive/xml_oarchive.hpp>
+#include <boost/archive/detail/polymorphic_oarchive_route.hpp>
+
+namespace boost { 
+namespace archive {
+
+typedef detail::polymorphic_oarchive_route<
+    xml_oarchive_impl<xml_oarchive> 
+> polymorphic_xml_oarchive;
+
+} // namespace archive
+} // namespace boost
+
+// required by export
+BOOST_SERIALIZATION_REGISTER_ARCHIVE(
+    boost::archive::polymorphic_xml_oarchive
+)
+
+#endif // BOOST_ARCHIVE_POLYMORPHIC_XML_OARCHIVE_HPP
+
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/polymorphic_xml_wiarchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/polymorphic_xml_wiarchive.hpp
new file mode 100644
index 00000000000..d4ab731267f
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/archive/polymorphic_xml_wiarchive.hpp
@@ -0,0 +1,50 @@
+#ifndef BOOST_ARCHIVE_POLYMORPHIC_XML_WIARCHIVE_HPP
+#define BOOST_ARCHIVE_POLYMORPHIC_XML_WIARCHIVE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// polymorphic_xml_wiarchive.hpp
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+#include <boost/config.hpp>
+#ifdef BOOST_NO_STD_WSTREAMBUF
+#error "wide char i/o not supported on this platform"
+#else
+
+#include <boost/archive/xml_wiarchive.hpp>
+#include <boost/archive/detail/polymorphic_iarchive_route.hpp>
+
+namespace boost { 
+namespace archive {
+
+class polymorphic_xml_wiarchive : 
+    public detail::polymorphic_iarchive_route<xml_wiarchive>
+{
+public:
+    polymorphic_xml_wiarchive(std::wistream & is, unsigned int flags = 0) :
+        detail::polymorphic_iarchive_route<xml_wiarchive>(is, flags)
+    {}
+    ~polymorphic_xml_wiarchive(){}
+};
+
+} // namespace archive
+} // namespace boost
+
+// required by export
+BOOST_SERIALIZATION_REGISTER_ARCHIVE(
+    boost::archive::polymorphic_xml_wiarchive
+)
+
+#endif // BOOST_NO_STD_WSTREAMBUF 
+#endif // BOOST_ARCHIVE_POLYMORPHIC_XML_WIARCHIVE_HPP
+
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/polymorphic_xml_woarchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/polymorphic_xml_woarchive.hpp
new file mode 100644
index 00000000000..dd8963fbb14
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/archive/polymorphic_xml_woarchive.hpp
@@ -0,0 +1,44 @@
+#ifndef BOOST_ARCHIVE_POLYMORPHIC_XML_WOARCHIVE_HPP
+#define BOOST_ARCHIVE_POLYMORPHIC_XML_WOARCHIVE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// polymorphic_xml_oarchive.hpp
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+#include <boost/config.hpp>
+#ifdef BOOST_NO_STD_WSTREAMBUF
+#error "wide char i/o not supported on this platform"
+#else
+
+#include <boost/archive/xml_woarchive.hpp>
+#include <boost/archive/detail/polymorphic_oarchive_route.hpp>
+
+namespace boost { 
+namespace archive {
+
+typedef detail::polymorphic_oarchive_route<
+        xml_woarchive_impl<xml_woarchive> 
+> polymorphic_xml_woarchive;
+
+} // namespace archive
+} // namespace boost
+
+// required by export
+BOOST_SERIALIZATION_REGISTER_ARCHIVE(
+    boost::archive::polymorphic_xml_woarchive
+)
+
+#endif // BOOST_NO_STD_WSTREAMBUF
+#endif // BOOST_ARCHIVE_POLYMORPHIC_XML_WOARCHIVE_HPP
+
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/text_iarchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/text_iarchive.hpp
new file mode 100644
index 00000000000..d9d60adf0b8
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/archive/text_iarchive.hpp
@@ -0,0 +1,132 @@
+#ifndef BOOST_ARCHIVE_TEXT_IARCHIVE_HPP
+#define BOOST_ARCHIVE_TEXT_IARCHIVE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// text_iarchive.hpp
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+#include <istream>
+
+#include <boost/config.hpp>
+#include <boost/archive/detail/auto_link_archive.hpp>
+#include <boost/archive/basic_text_iprimitive.hpp>
+#include <boost/archive/basic_text_iarchive.hpp>
+#include <boost/archive/detail/register_archive.hpp>
+#include <boost/serialization/item_version_type.hpp>
+
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+#ifdef BOOST_MSVC
+#  pragma warning(push)
+#  pragma warning(disable : 4511 4512)
+#endif
+
+namespace boost { 
+namespace archive {
+
+namespace detail {
+    template<class Archive> class interface_iarchive;
+} // namespace detail
+
+template<class Archive>
+class BOOST_SYMBOL_VISIBLE text_iarchive_impl :
+    public basic_text_iprimitive<std::istream>,
+    public basic_text_iarchive<Archive>
+{
+#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
+public:
+#else
+protected:
+    friend class detail::interface_iarchive<Archive>;
+    friend class load_access;
+#endif
+    template<class T>
+    void load(T & t){
+        basic_text_iprimitive<std::istream>::load(t);
+    }
+    void load(version_type & t){
+        unsigned int v;
+        load(v);
+        t = version_type(v);
+    }
+    void load(boost::serialization::item_version_type & t){
+        unsigned int v;
+        load(v);
+        t = boost::serialization::item_version_type(v);
+    }
+    BOOST_ARCHIVE_DECL void 
+    load(char * t);
+    #ifndef BOOST_NO_INTRINSIC_WCHAR_T
+    BOOST_ARCHIVE_DECL void 
+    load(wchar_t * t);
+    #endif
+    BOOST_ARCHIVE_DECL void 
+    load(std::string &s);
+    #ifndef BOOST_NO_STD_WSTRING
+    BOOST_ARCHIVE_DECL void 
+    load(std::wstring &ws);
+    #endif
+    template<class T>
+    void load_override(T & t){
+        basic_text_iarchive<Archive>::load_override(t);
+    }
+    BOOST_ARCHIVE_DECL void
+    load_override(class_name_type & t);
+    BOOST_ARCHIVE_DECL void
+    init();
+    BOOST_ARCHIVE_DECL 
+    text_iarchive_impl(std::istream & is, unsigned int flags);
+    // don't import inline definitions! leave this as a reminder.
+    //BOOST_ARCHIVE_DECL 
+    ~text_iarchive_impl(){};
+};
+
+} // namespace archive
+} // namespace boost
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#ifdef BOOST_MSVC
+#  pragma warning(push)
+#  pragma warning(disable : 4511 4512)
+#endif
+
+namespace boost { 
+namespace archive {
+
+class BOOST_SYMBOL_VISIBLE text_iarchive : 
+    public text_iarchive_impl<text_iarchive>{
+public:
+    text_iarchive(std::istream & is_, unsigned int flags = 0) :
+        // note: added _ to suppress useless gcc warning
+        text_iarchive_impl<text_iarchive>(is_, flags)
+    {}
+    ~text_iarchive(){}
+};
+
+} // namespace archive
+} // namespace boost
+
+// required by export
+BOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::text_iarchive)
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+#endif // BOOST_ARCHIVE_TEXT_IARCHIVE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/text_oarchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/text_oarchive.hpp
new file mode 100644
index 00000000000..9ba0dafffb4
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/archive/text_oarchive.hpp
@@ -0,0 +1,121 @@
+#ifndef BOOST_ARCHIVE_TEXT_OARCHIVE_HPP
+#define BOOST_ARCHIVE_TEXT_OARCHIVE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// text_oarchive.hpp
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+#include <ostream>
+#include <cstddef> // std::size_t
+
+#include <boost/config.hpp>
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{ 
+    using ::size_t; 
+} // namespace std
+#endif
+
+#include <boost/archive/detail/auto_link_archive.hpp>
+#include <boost/archive/basic_text_oprimitive.hpp>
+#include <boost/archive/basic_text_oarchive.hpp>
+#include <boost/archive/detail/register_archive.hpp>
+#include <boost/serialization/item_version_type.hpp>
+
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+#ifdef BOOST_MSVC
+#  pragma warning(push)
+#  pragma warning(disable : 4511 4512)
+#endif
+
+namespace boost { 
+namespace archive {
+
+namespace detail {
+    template<class Archive> class interface_oarchive;
+} // namespace detail
+
+template<class Archive>
+class BOOST_SYMBOL_VISIBLE text_oarchive_impl :
+     /* protected ? */ public basic_text_oprimitive<std::ostream>,
+     public basic_text_oarchive<Archive>
+{
+#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
+public:
+#else
+protected:
+    friend class detail::interface_oarchive<Archive>;
+    friend class basic_text_oarchive<Archive>;
+    friend class save_access;
+#endif
+    template<class T>
+    void save(const T & t){
+        this->newtoken();
+        basic_text_oprimitive<std::ostream>::save(t);
+    }
+    void save(const version_type & t){
+        save(static_cast<const unsigned int>(t));
+    }
+    void save(const boost::serialization::item_version_type & t){
+        save(static_cast<const unsigned int>(t));
+    }
+    BOOST_ARCHIVE_DECL void 
+    save(const char * t);
+    #ifndef BOOST_NO_INTRINSIC_WCHAR_T
+    BOOST_ARCHIVE_DECL void 
+    save(const wchar_t * t);
+    #endif
+    BOOST_ARCHIVE_DECL void 
+    save(const std::string &s);
+    #ifndef BOOST_NO_STD_WSTRING
+    BOOST_ARCHIVE_DECL void 
+    save(const std::wstring &ws);
+    #endif
+    BOOST_ARCHIVE_DECL 
+    text_oarchive_impl(std::ostream & os, unsigned int flags);
+    // don't import inline definitions! leave this as a reminder.
+    //BOOST_ARCHIVE_DECL 
+    ~text_oarchive_impl(){};
+public:
+    BOOST_ARCHIVE_DECL void 
+    save_binary(const void *address, std::size_t count);
+};
+
+// do not derive from this class.  If you want to extend this functionality
+// via inhertance, derived from text_oarchive_impl instead.  This will
+// preserve correct static polymorphism.
+class BOOST_SYMBOL_VISIBLE text_oarchive : 
+    public text_oarchive_impl<text_oarchive>
+{
+public:
+    text_oarchive(std::ostream & os_, unsigned int flags = 0) :
+        // note: added _ to suppress useless gcc warning
+        text_oarchive_impl<text_oarchive>(os_, flags)
+    {}
+    ~text_oarchive(){}
+};
+
+} // namespace archive
+} // namespace boost
+
+// required by export
+BOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::text_oarchive)
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#endif // BOOST_ARCHIVE_TEXT_OARCHIVE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/text_wiarchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/text_wiarchive.hpp
new file mode 100644
index 00000000000..3adf068a51a
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/archive/text_wiarchive.hpp
@@ -0,0 +1,137 @@
+#ifndef BOOST_ARCHIVE_TEXT_WIARCHIVE_HPP
+#define BOOST_ARCHIVE_TEXT_WIARCHIVE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// text_wiarchive.hpp
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+#include <boost/config.hpp>
+#ifdef BOOST_NO_STD_WSTREAMBUF
+#error "wide char i/o not supported on this platform"
+#else
+
+#include <istream>
+
+#include <boost/archive/detail/auto_link_warchive.hpp>
+#include <boost/archive/basic_text_iprimitive.hpp>
+#include <boost/archive/basic_text_iarchive.hpp>
+#include <boost/archive/detail/register_archive.hpp>
+#include <boost/serialization/item_version_type.hpp>
+
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+#ifdef BOOST_MSVC
+#  pragma warning(push)
+#  pragma warning(disable : 4511 4512)
+#endif
+
+namespace boost { 
+namespace archive {
+
+namespace detail {
+    template<class Archive> class interface_iarchive;
+} // namespace detail
+
+template<class Archive>
+class BOOST_SYMBOL_VISIBLE text_wiarchive_impl :
+    public basic_text_iprimitive<std::wistream>,
+    public basic_text_iarchive<Archive>
+{
+#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
+public:
+#else
+protected:
+    #if BOOST_WORKAROUND(BOOST_MSVC, < 1500)
+        // for some inexplicable reason insertion of "class" generates compile erro
+        // on msvc 7.1
+        friend detail::interface_iarchive<Archive>;
+        friend load_access;
+    #else
+        friend class detail::interface_iarchive<Archive>;
+        friend class load_access;
+    #endif
+#endif
+    template<class T>
+    void load(T & t){
+        basic_text_iprimitive<std::wistream>::load(t);
+    }
+    void load(version_type & t){
+        unsigned int v;
+        load(v);
+        t = version_type(v);
+    }
+    void load(boost::serialization::item_version_type & t){
+        unsigned int v;
+        load(v);
+        t = boost::serialization::item_version_type(v);
+    }
+    BOOST_WARCHIVE_DECL void
+    load(char * t);
+    #ifndef BOOST_NO_INTRINSIC_WCHAR_T
+    BOOST_WARCHIVE_DECL void
+    load(wchar_t * t);
+    #endif
+    BOOST_WARCHIVE_DECL void
+    load(std::string &s);
+    #ifndef BOOST_NO_STD_WSTRING
+    BOOST_WARCHIVE_DECL void
+    load(std::wstring &ws);
+    #endif
+    template<class T>
+    void load_override(T & t){
+        basic_text_iarchive<Archive>::load_override(t);
+    }
+    BOOST_WARCHIVE_DECL 
+    text_wiarchive_impl(std::wistream & is, unsigned int flags);
+    ~text_wiarchive_impl(){};
+};
+
+} // namespace archive
+} // namespace boost
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#ifdef BOOST_MSVC
+#  pragma warning(push)
+#  pragma warning(disable : 4511 4512)
+#endif
+
+namespace boost { 
+namespace archive {
+
+class BOOST_SYMBOL_VISIBLE text_wiarchive : 
+    public text_wiarchive_impl<text_wiarchive>{
+public:
+    text_wiarchive(std::wistream & is, unsigned int flags = 0) :
+        text_wiarchive_impl<text_wiarchive>(is, flags)
+    {}
+    ~text_wiarchive(){}
+};
+
+} // namespace archive
+} // namespace boost
+
+// required by export
+BOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::text_wiarchive)
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+#endif // BOOST_NO_STD_WSTREAMBUF
+#endif // BOOST_ARCHIVE_TEXT_WIARCHIVE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/text_woarchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/text_woarchive.hpp
new file mode 100644
index 00000000000..b6b4f8ed59a
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/archive/text_woarchive.hpp
@@ -0,0 +1,155 @@
+#ifndef BOOST_ARCHIVE_TEXT_WOARCHIVE_HPP
+#define BOOST_ARCHIVE_TEXT_WOARCHIVE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// text_woarchive.hpp
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+#include <boost/config.hpp>
+
+#ifdef BOOST_NO_STD_WSTREAMBUF
+#error "wide char i/o not supported on this platform"
+#else
+
+#include <ostream>
+#include <cstddef> // size_t
+
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{ 
+    using ::size_t; 
+} // namespace std
+#endif
+
+#include <boost/archive/detail/auto_link_warchive.hpp>
+#include <boost/archive/basic_text_oprimitive.hpp>
+#include <boost/archive/basic_text_oarchive.hpp>
+#include <boost/archive/detail/register_archive.hpp>
+#include <boost/serialization/item_version_type.hpp>
+
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+#ifdef BOOST_MSVC
+#  pragma warning(push)
+#  pragma warning(disable : 4511 4512)
+#endif
+
+namespace boost { 
+namespace archive {
+
+namespace detail {
+    template<class Archive> class interface_oarchive;
+} // namespace detail
+
+template<class Archive>
+class BOOST_SYMBOL_VISIBLE text_woarchive_impl :
+    public basic_text_oprimitive<std::wostream>,
+    public basic_text_oarchive<Archive>
+{
+#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
+public:
+#else
+protected:
+    #if BOOST_WORKAROUND(BOOST_MSVC, < 1500)
+        // for some inexplicable reason insertion of "class" generates compile erro
+        // on msvc 7.1
+        friend detail::interface_oarchive<Archive>;
+        friend basic_text_oarchive<Archive>;
+        friend save_access;
+    #else
+        friend class detail::interface_oarchive<Archive>;
+        friend class basic_text_oarchive<Archive>;
+        friend class save_access;
+    #endif
+#endif
+    template<class T>
+    void save(const T & t){
+        this->newtoken();
+        basic_text_oprimitive<std::wostream>::save(t);
+    }
+    void save(const version_type & t){
+        save(static_cast<const unsigned int>(t));
+    }
+    void save(const boost::serialization::item_version_type & t){
+        save(static_cast<const unsigned int>(t));
+    }
+    BOOST_WARCHIVE_DECL void
+    save(const char * t);
+    #ifndef BOOST_NO_INTRINSIC_WCHAR_T
+    BOOST_WARCHIVE_DECL void
+    save(const wchar_t * t);
+    #endif
+    BOOST_WARCHIVE_DECL void
+    save(const std::string &s);
+    #ifndef BOOST_NO_STD_WSTRING
+    BOOST_WARCHIVE_DECL void
+    save(const std::wstring &ws);
+    #endif
+    text_woarchive_impl(std::wostream & os, unsigned int flags) :
+        basic_text_oprimitive<std::wostream>(
+            os, 
+            0 != (flags & no_codecvt)
+        ),
+        basic_text_oarchive<Archive>(flags)
+    {
+        if(0 == (flags & no_header))
+            basic_text_oarchive<Archive>::init();
+    }
+public:
+    void save_binary(const void *address, std::size_t count){
+        put(static_cast<wchar_t>('\n'));
+        this->end_preamble();
+        #if ! defined(__MWERKS__)
+        this->basic_text_oprimitive<std::wostream>::save_binary(
+        #else
+        this->basic_text_oprimitive::save_binary(
+        #endif
+            address, 
+            count
+        );
+        put(static_cast<wchar_t>('\n'));
+        this->delimiter = this->none;
+    }
+
+};
+
+// we use the following because we can't use
+// typedef text_oarchive_impl<text_oarchive_impl<...> > text_oarchive;
+
+// do not derive from this class.  If you want to extend this functionality
+// via inhertance, derived from text_oarchive_impl instead.  This will
+// preserve correct static polymorphism.
+class BOOST_SYMBOL_VISIBLE text_woarchive : 
+    public text_woarchive_impl<text_woarchive>
+{
+public:
+    text_woarchive(std::wostream & os, unsigned int flags = 0) :
+        text_woarchive_impl<text_woarchive>(os, flags)
+    {}
+    ~text_woarchive(){}
+};
+
+} // namespace archive
+} // namespace boost
+
+// required by export
+BOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::text_woarchive)
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#endif // BOOST_NO_STD_WSTREAMBUF
+#endif // BOOST_ARCHIVE_TEXT_WOARCHIVE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/tmpdir.hpp b/contrib/libboost/boost_1_65_0/boost/archive/tmpdir.hpp
new file mode 100644
index 00000000000..400d23b9f68
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/archive/tmpdir.hpp
@@ -0,0 +1,50 @@
+#ifndef BOOST_ARCHIVE_TMPDIR_HPP
+#define BOOST_ARCHIVE_TMPDIR_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// tmpdir.hpp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+#include <cstdlib> // getenv
+#include <cstddef> // NULL
+//#include <boost/assert.hpp>
+
+#include <boost/config.hpp>
+#ifdef BOOST_NO_STDC_NAMESPACE
+namespace std {
+    using ::getenv;
+}
+#endif
+
+namespace boost {
+namespace archive {
+
+inline const char * tmpdir(){
+    const char *dirname;
+    dirname = std::getenv("TMP");
+    if(NULL == dirname)
+        dirname = std::getenv("TMPDIR");
+    if(NULL == dirname)
+        dirname = std::getenv("TEMP");
+    if(NULL == dirname){
+        //BOOST_ASSERT(false); // no temp directory found
+        dirname = ".";
+    }
+    return dirname;
+}
+
+} // archive
+} // boost
+
+#endif // BOOST_ARCHIVE_TMPDIR_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/wcslen.hpp b/contrib/libboost/boost_1_65_0/boost/archive/wcslen.hpp
new file mode 100644
index 00000000000..0b60004f095
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/archive/wcslen.hpp
@@ -0,0 +1,58 @@
+#ifndef BOOST_ARCHIVE_WCSLEN_HPP
+#define BOOST_ARCHIVE_WCSLEN_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// wcslen.hpp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+#include <cstddef> // size_t
+#include <boost/config.hpp>
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{ 
+    using ::size_t; 
+} // namespace std
+#endif
+
+#ifndef BOOST_NO_CWCHAR
+
+// a couple of libraries which include wchar_t don't include
+// wcslen
+
+#if defined(BOOST_DINKUMWARE_STDLIB) && BOOST_DINKUMWARE_STDLIB < 306 \
+|| defined(__LIBCOMO__) 
+
+namespace std {
+inline std::size_t wcslen(const wchar_t * ws)
+{
+    const wchar_t * eows = ws;
+    while(* eows != 0)
+        ++eows;
+    return eows - ws;
+}
+} // namespace std
+
+#else
+
+#ifndef BOOST_NO_CWCHAR
+#include <cwchar>
+#endif
+#ifdef BOOST_NO_STDC_NAMESPACE
+namespace std{ using ::wcslen; }
+#endif
+
+#endif // wcslen
+
+#endif //BOOST_NO_CWCHAR
+
+#endif //BOOST_ARCHIVE_WCSLEN_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/xml_archive_exception.hpp b/contrib/libboost/boost_1_65_0/boost/archive/xml_archive_exception.hpp
new file mode 100644
index 00000000000..82c53ef5d3e
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/archive/xml_archive_exception.hpp
@@ -0,0 +1,57 @@
+#ifndef BOOST_ARCHIVE_XML_ARCHIVE_EXCEPTION_HPP
+#define BOOST_ARCHIVE_XML_ARCHIVE_EXCEPTION_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// xml_archive_exception.hpp:
+
+// (C) Copyright 2007 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+#include <exception>
+#include <boost/assert.hpp>
+
+#include <boost/config.hpp> 
+#include <boost/archive/detail/decl.hpp>
+#include <boost/archive/archive_exception.hpp>
+
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+namespace boost {
+namespace archive {
+
+//////////////////////////////////////////////////////////////////////
+// exceptions thrown by xml archives
+//
+class BOOST_SYMBOL_VISIBLE xml_archive_exception : 
+    public virtual boost::archive::archive_exception
+{
+public:
+    typedef enum {
+        xml_archive_parsing_error,    // see save_register
+        xml_archive_tag_mismatch,
+        xml_archive_tag_name_error
+    } exception_code;
+    BOOST_ARCHIVE_DECL xml_archive_exception(
+        exception_code c, 
+        const char * e1 = NULL,
+        const char * e2 = NULL
+    );
+    BOOST_ARCHIVE_DECL xml_archive_exception(xml_archive_exception const &) ;
+    virtual BOOST_ARCHIVE_DECL ~xml_archive_exception() BOOST_NOEXCEPT_OR_NOTHROW ;
+};
+
+}// namespace archive
+}// namespace boost
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#endif //BOOST_XML_ARCHIVE_ARCHIVE_EXCEPTION_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/xml_iarchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/xml_iarchive.hpp
new file mode 100644
index 00000000000..abd2f9fc4e3
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/archive/xml_iarchive.hpp
@@ -0,0 +1,142 @@
+#ifndef BOOST_ARCHIVE_XML_IARCHIVE_HPP
+#define BOOST_ARCHIVE_XML_IARCHIVE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// xml_iarchive.hpp
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+#include <istream>
+
+#include <boost/scoped_ptr.hpp>
+#include <boost/archive/detail/auto_link_archive.hpp>
+#include <boost/archive/basic_text_iprimitive.hpp>
+#include <boost/archive/basic_xml_iarchive.hpp>
+#include <boost/archive/detail/register_archive.hpp>
+#include <boost/serialization/item_version_type.hpp>
+
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+#ifdef BOOST_MSVC
+#  pragma warning(push)
+#  pragma warning(disable : 4511 4512)
+#endif
+
+namespace boost { 
+namespace archive {
+
+namespace detail {
+    template<class Archive> class interface_iarchive;
+} // namespace detail
+
+template<class CharType>
+class basic_xml_grammar;
+typedef basic_xml_grammar<char> xml_grammar;
+
+template<class Archive>
+class BOOST_SYMBOL_VISIBLE xml_iarchive_impl : 
+    public basic_text_iprimitive<std::istream>,
+    public basic_xml_iarchive<Archive>
+{
+#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
+public:
+#else
+protected:
+    friend class detail::interface_iarchive<Archive>;
+    friend class basic_xml_iarchive<Archive>;
+    friend class load_access;
+#endif
+    // use boost:scoped_ptr to implement automatic deletion;
+    boost::scoped_ptr<xml_grammar> gimpl;
+
+    std::istream & get_is(){
+        return is;
+    }
+    template<class T>
+    void load(T & t){
+        basic_text_iprimitive<std::istream>::load(t);
+    }
+    void 
+    load(version_type & t){
+        unsigned int v;
+        load(v);
+        t = version_type(v);
+    }
+    void 
+    load(boost::serialization::item_version_type & t){
+        unsigned int v;
+        load(v);
+        t = boost::serialization::item_version_type(v);
+    }
+    BOOST_ARCHIVE_DECL void
+    load(char * t);
+    #ifndef BOOST_NO_INTRINSIC_WCHAR_T
+    BOOST_ARCHIVE_DECL void
+    load(wchar_t * t);
+    #endif
+    BOOST_ARCHIVE_DECL void
+    load(std::string &s);
+    #ifndef BOOST_NO_STD_WSTRING
+    BOOST_ARCHIVE_DECL void
+    load(std::wstring &ws);
+    #endif
+    template<class T>
+    void load_override(T & t){
+        basic_xml_iarchive<Archive>::load_override(t);
+    }
+    BOOST_ARCHIVE_DECL void
+    load_override(class_name_type & t);
+    BOOST_ARCHIVE_DECL void
+    init();
+    BOOST_ARCHIVE_DECL 
+    xml_iarchive_impl(std::istream & is, unsigned int flags);
+    BOOST_ARCHIVE_DECL
+    ~xml_iarchive_impl();
+};
+
+} // namespace archive
+} // namespace boost
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+#ifdef BOOST_MSVC
+#  pragma warning(push)
+#  pragma warning(disable : 4511 4512)
+#endif
+
+namespace boost { 
+namespace archive {
+
+class BOOST_SYMBOL_VISIBLE xml_iarchive : 
+    public xml_iarchive_impl<xml_iarchive>{
+public:
+    xml_iarchive(std::istream & is, unsigned int flags = 0) :
+        xml_iarchive_impl<xml_iarchive>(is, flags)
+    {}
+    ~xml_iarchive(){};
+};
+
+} // namespace archive
+} // namespace boost
+
+// required by export
+BOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::xml_iarchive)
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+#endif // BOOST_ARCHIVE_XML_IARCHIVE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/xml_oarchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/xml_oarchive.hpp
new file mode 100644
index 00000000000..eea12680372
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/archive/xml_oarchive.hpp
@@ -0,0 +1,137 @@
+#ifndef BOOST_ARCHIVE_XML_OARCHIVE_HPP
+#define BOOST_ARCHIVE_XML_OARCHIVE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// xml_oarchive.hpp
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+#include <ostream>
+
+#include <cstddef> // size_t
+#include <boost/config.hpp>
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{ 
+    using ::size_t; 
+} // namespace std
+#endif
+
+#include <boost/archive/detail/auto_link_archive.hpp>
+#include <boost/archive/basic_text_oprimitive.hpp>
+#include <boost/archive/basic_xml_oarchive.hpp>
+#include <boost/archive/detail/register_archive.hpp>
+#include <boost/serialization/item_version_type.hpp>
+
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+#ifdef BOOST_MSVC
+#  pragma warning(push)
+#  pragma warning(disable : 4511 4512)
+#endif
+
+namespace boost {
+namespace archive {
+
+namespace detail {
+    template<class Archive> class interface_oarchive;
+} // namespace detail
+
+template<class Archive>
+class BOOST_SYMBOL_VISIBLE xml_oarchive_impl : 
+    public basic_text_oprimitive<std::ostream>,
+    public basic_xml_oarchive<Archive>
+{
+#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
+public:
+#else
+protected:
+    friend class detail::interface_oarchive<Archive>;
+    friend class basic_xml_oarchive<Archive>;
+    friend class save_access;
+#endif
+    template<class T>
+    void save(const T & t){
+        basic_text_oprimitive<std::ostream>::save(t);
+    }
+    void 
+    save(const version_type & t){
+        save(static_cast<const unsigned int>(t));
+    }
+    void 
+    save(const boost::serialization::item_version_type & t){
+        save(static_cast<const unsigned int>(t));
+    }
+    BOOST_ARCHIVE_DECL void 
+    save(const char * t);
+    #ifndef BOOST_NO_INTRINSIC_WCHAR_T
+    BOOST_ARCHIVE_DECL void
+    save(const wchar_t * t);
+    #endif
+    BOOST_ARCHIVE_DECL void
+    save(const std::string &s);
+    #ifndef BOOST_NO_STD_WSTRING
+    BOOST_ARCHIVE_DECL void
+    save(const std::wstring &ws);
+    #endif
+    BOOST_ARCHIVE_DECL 
+    xml_oarchive_impl(std::ostream & os, unsigned int flags);
+    BOOST_ARCHIVE_DECL 
+    ~xml_oarchive_impl();
+public:
+    BOOST_ARCHIVE_DECL
+    void save_binary(const void *address, std::size_t count);
+};
+
+} // namespace archive
+} // namespace boost
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+#ifdef BOOST_MSVC
+#  pragma warning(push)
+#  pragma warning(disable : 4511 4512)
+#endif
+
+namespace boost { 
+namespace archive {
+
+// we use the following because we can't use
+// typedef xml_oarchive_impl<xml_oarchive_impl<...> > xml_oarchive;
+
+// do not derive from this class.  If you want to extend this functionality
+// via inhertance, derived from xml_oarchive_impl instead.  This will
+// preserve correct static polymorphism.
+class BOOST_SYMBOL_VISIBLE xml_oarchive : 
+    public xml_oarchive_impl<xml_oarchive>
+{
+public:
+    xml_oarchive(std::ostream & os, unsigned int flags = 0) :
+        xml_oarchive_impl<xml_oarchive>(os, flags)
+    {}
+    ~xml_oarchive(){}
+};
+
+} // namespace archive
+} // namespace boost
+
+// required by export
+BOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::xml_oarchive)
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+#endif // BOOST_ARCHIVE_XML_OARCHIVE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/xml_wiarchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/xml_wiarchive.hpp
new file mode 100644
index 00000000000..ac24289ac11
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/archive/xml_wiarchive.hpp
@@ -0,0 +1,149 @@
+#ifndef BOOST_ARCHIVE_XML_WIARCHIVE_HPP
+#define BOOST_ARCHIVE_XML_WIARCHIVE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// xml_wiarchive.hpp
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+#include <boost/config.hpp>
+#ifdef BOOST_NO_STD_WSTREAMBUF
+#error "wide char i/o not supported on this platform"
+#else
+
+#include <istream>
+
+#include <boost/smart_ptr/scoped_ptr.hpp>
+#include <boost/archive/detail/auto_link_warchive.hpp>
+#include <boost/archive/basic_text_iprimitive.hpp>
+#include <boost/archive/basic_xml_iarchive.hpp>
+#include <boost/archive/detail/register_archive.hpp>
+#include <boost/serialization/item_version_type.hpp>
+// #include <boost/archive/detail/utf8_codecvt_facet.hpp>
+
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+#ifdef BOOST_MSVC
+#  pragma warning(push)
+#  pragma warning(disable : 4511 4512)
+#endif
+
+namespace boost {
+namespace archive {
+
+namespace detail {
+    template<class Archive> class interface_iarchive;
+} // namespace detail
+
+template<class CharType>
+class basic_xml_grammar;
+typedef basic_xml_grammar<wchar_t> xml_wgrammar;
+
+template<class Archive>
+class BOOST_SYMBOL_VISIBLE xml_wiarchive_impl : 
+    public basic_text_iprimitive<std::wistream>,
+    public basic_xml_iarchive<Archive>
+{
+#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
+public:
+#else
+protected:
+    friend class detail::interface_iarchive<Archive>;
+    friend class basic_xml_iarchive<Archive>;
+    friend class load_access;
+#endif
+    boost::scoped_ptr<xml_wgrammar> gimpl;
+    std::wistream & get_is(){
+        return is;
+    }
+    template<class T>
+    void 
+    load(T & t){
+        basic_text_iprimitive<std::wistream>::load(t);
+    }
+    void 
+    load(version_type & t){
+        unsigned int v;
+        load(v);
+        t = version_type(v);
+    }
+    void 
+    load(boost::serialization::item_version_type & t){
+        unsigned int v;
+        load(v);
+        t = boost::serialization::item_version_type(v);
+    }
+    BOOST_WARCHIVE_DECL void
+    load(char * t);
+    #ifndef BOOST_NO_INTRINSIC_WCHAR_T
+    BOOST_WARCHIVE_DECL void
+    load(wchar_t * t);
+    #endif
+    BOOST_WARCHIVE_DECL void
+    load(std::string &s);
+    #ifndef BOOST_NO_STD_WSTRING
+    BOOST_WARCHIVE_DECL void
+    load(std::wstring &ws);
+    #endif
+    template<class T>
+    void load_override(T & t){
+        basic_xml_iarchive<Archive>::load_override(t);
+    }
+    BOOST_WARCHIVE_DECL void
+    load_override(class_name_type & t);
+    BOOST_WARCHIVE_DECL void 
+    init();
+    BOOST_WARCHIVE_DECL 
+    xml_wiarchive_impl(std::wistream & is, unsigned int flags) ;
+    BOOST_WARCHIVE_DECL 
+    ~xml_wiarchive_impl();
+};
+
+} // namespace archive
+} // namespace boost
+
+#ifdef BOOST_MSVC
+#  pragma warning(pop) 
+#endif
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#ifdef BOOST_MSVC
+#  pragma warning(push)
+#  pragma warning(disable : 4511 4512)
+#endif
+
+namespace boost { 
+namespace archive {
+
+class BOOST_SYMBOL_VISIBLE xml_wiarchive :
+    public xml_wiarchive_impl<xml_wiarchive>{
+public:
+    xml_wiarchive(std::wistream & is, unsigned int flags = 0) :
+        xml_wiarchive_impl<xml_wiarchive>(is, flags)
+    {}
+    ~xml_wiarchive(){}
+};
+
+} // namespace archive
+} // namespace boost
+
+// required by export
+BOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::xml_wiarchive)
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+#endif // BOOST_NO_STD_WSTREAMBUF
+#endif // BOOST_ARCHIVE_XML_WIARCHIVE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/xml_woarchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/xml_woarchive.hpp
new file mode 100644
index 00000000000..cb7ce68cb6f
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/archive/xml_woarchive.hpp
@@ -0,0 +1,134 @@
+#ifndef BOOST_ARCHIVE_XML_WOARCHIVE_HPP
+#define BOOST_ARCHIVE_XML_WOARCHIVE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// xml_woarchive.hpp
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+#include <boost/config.hpp>
+#ifdef BOOST_NO_STD_WSTREAMBUF
+#error "wide char i/o not supported on this platform"
+#else
+#include <cstddef> // size_t
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{ 
+    using ::size_t; 
+} // namespace std
+#endif
+
+#include <ostream>
+
+//#include <boost/smart_ptr/scoped_ptr.hpp>
+#include <boost/archive/detail/auto_link_warchive.hpp>
+#include <boost/archive/basic_text_oprimitive.hpp>
+#include <boost/archive/basic_xml_oarchive.hpp>
+#include <boost/archive/detail/register_archive.hpp>
+#include <boost/serialization/item_version_type.hpp>
+//#include <boost/archive/detail/utf8_codecvt_facet.hpp>
+
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+#ifdef BOOST_MSVC
+#  pragma warning(push)
+#  pragma warning(disable : 4511 4512)
+#endif
+
+namespace boost {
+namespace archive {
+
+namespace detail {
+    template<class Archive> class interface_oarchive;
+} // namespace detail
+
+template<class Archive>
+class BOOST_SYMBOL_VISIBLE xml_woarchive_impl :
+    public basic_text_oprimitive<std::wostream>,
+    public basic_xml_oarchive<Archive>
+{
+#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
+public:
+#else
+protected:
+    friend class detail::interface_oarchive<Archive>;
+    friend class basic_xml_oarchive<Archive>;
+    friend class save_access;
+#endif
+    //void end_preamble(){
+    //    basic_xml_oarchive<Archive>::end_preamble();
+    //}
+    template<class T>
+    void
+    save(const T & t){
+        basic_text_oprimitive<std::wostream>::save(t);
+    }
+    void
+    save(const version_type & t){
+        save(static_cast<const unsigned int>(t));
+    }
+    void 
+    save(const boost::serialization::item_version_type & t){
+        save(static_cast<const unsigned int>(t));
+    }
+    BOOST_WARCHIVE_DECL void
+    save(const char * t);
+    #ifndef BOOST_NO_INTRINSIC_WCHAR_T
+    BOOST_WARCHIVE_DECL void 
+    save(const wchar_t * t);
+    #endif
+    BOOST_WARCHIVE_DECL void 
+    save(const std::string &s);
+    #ifndef BOOST_NO_STD_WSTRING
+    BOOST_WARCHIVE_DECL void
+    save(const std::wstring &ws);
+    #endif
+    BOOST_WARCHIVE_DECL 
+    xml_woarchive_impl(std::wostream & os, unsigned int flags);
+    BOOST_WARCHIVE_DECL
+    ~xml_woarchive_impl();
+public:
+    BOOST_WARCHIVE_DECL void
+    save_binary(const void *address, std::size_t count);
+
+};
+
+// we use the following because we can't use
+// typedef xml_woarchive_impl<xml_woarchive_impl<...> > xml_woarchive;
+
+// do not derive from this class.  If you want to extend this functionality
+// via inhertance, derived from xml_woarchive_impl instead.  This will
+// preserve correct static polymorphism.
+class BOOST_SYMBOL_VISIBLE xml_woarchive :
+    public xml_woarchive_impl<xml_woarchive>
+{
+public:
+    xml_woarchive(std::wostream & os, unsigned int flags = 0) :
+        xml_woarchive_impl<xml_woarchive>(os, flags)
+    {}
+    ~xml_woarchive(){}
+};
+
+} // namespace archive
+} // namespace boost
+
+// required by export
+BOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::xml_woarchive)
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#endif // BOOST_NO_STD_WSTREAMBUF
+#endif // BOOST_ARCHIVE_XML_OARCHIVE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/foreach_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/foreach_fwd.hpp
new file mode 100644
index 00000000000..4e0bb370c2f
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/foreach_fwd.hpp
@@ -0,0 +1,51 @@
+///////////////////////////////////////////////////////////////////////////////
+// foreach.hpp header file
+//
+// Copyright 2010 Eric Niebler.
+// Distributed under the Boost Software License, Version 1.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/foreach for documentation
+//
+// Credits:
+// Kazutoshi Satoda: for suggesting the need for a _fwd header for foreach's
+//                      customization points.
+
+#ifndef BOOST_FOREACH_FWD_HPP
+#define BOOST_FOREACH_FWD_HPP
+
+// This must be at global scope, hence the uglified name
+enum boost_foreach_argument_dependent_lookup_hack
+{
+    boost_foreach_argument_dependent_lookup_hack_value
+};
+
+namespace boost
+{
+
+namespace foreach
+{
+    ///////////////////////////////////////////////////////////////////////////////
+    // boost::foreach::tag
+    //
+    typedef boost_foreach_argument_dependent_lookup_hack tag;
+
+    ///////////////////////////////////////////////////////////////////////////////
+    // boost::foreach::is_lightweight_proxy
+    //   Specialize this for user-defined collection types if they are inexpensive to copy.
+    //   This tells BOOST_FOREACH it can avoid the rvalue/lvalue detection stuff.
+    template<typename T>
+    struct is_lightweight_proxy;
+
+    ///////////////////////////////////////////////////////////////////////////////
+    // boost::foreach::is_noncopyable
+    //   Specialize this for user-defined collection types if they cannot be copied.
+    //   This also tells BOOST_FOREACH to avoid the rvalue/lvalue detection stuff.
+    template<typename T>
+    struct is_noncopyable;
+
+} // namespace foreach
+
+} // namespace boost
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/composite_key.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/composite_key.hpp
new file mode 100644
index 00000000000..787cdf83195
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/multi_index/composite_key.hpp
@@ -0,0 +1,1513 @@
+/* Copyright 2003-2015 Joaquin M Lopez Munoz.
+ * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
+ */
+
+#ifndef BOOST_MULTI_INDEX_COMPOSITE_KEY_HPP
+#define BOOST_MULTI_INDEX_COMPOSITE_KEY_HPP
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
+#include <boost/functional/hash_fwd.hpp>
+#include <boost/multi_index/detail/access_specifier.hpp>
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/identity.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/mpl/or.hpp>
+#include <boost/preprocessor/cat.hpp>
+#include <boost/preprocessor/control/expr_if.hpp>
+#include <boost/preprocessor/list/at.hpp>
+#include <boost/preprocessor/repetition/enum.hpp>
+#include <boost/preprocessor/repetition/enum_params.hpp> 
+#include <boost/static_assert.hpp>
+#include <boost/tuple/tuple.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/utility/enable_if.hpp>
+#include <functional>
+
+#if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
+#include <boost/ref.hpp>
+#endif
+
+#if !defined(BOOST_NO_SFINAE)
+#include <boost/type_traits/is_convertible.hpp>
+#endif
+
+#if !defined(BOOST_NO_CXX11_HDR_TUPLE)&&\
+    !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+#include <boost/multi_index/detail/cons_stdtuple.hpp>
+#endif
+
+/* A composite key stores n key extractors and "computes" the
+ * result on a given value as a packed reference to the value and
+ * the composite key itself. Actual invocations to the component
+ * key extractors are lazily performed when executing an operation
+ * on composite_key results (equality, comparison, hashing.)
+ * As the other key extractors in Boost.MultiIndex, composite_key<T,...>
+ * is  overloaded to work on chained pointers to T and reference_wrappers
+ * of T.
+ */
+
+/* This user_definable macro limits the number of elements of a composite
+ * key; useful for shortening resulting symbol names (MSVC++ 6.0, for
+ * instance has problems coping with very long symbol names.)
+ * NB: This cannot exceed the maximum number of arguments of
+ * boost::tuple. In Boost 1.32, the limit is 10.
+ */
+
+#if !defined(BOOST_MULTI_INDEX_LIMIT_COMPOSITE_KEY_SIZE)
+#define BOOST_MULTI_INDEX_LIMIT_COMPOSITE_KEY_SIZE 10
+#endif
+
+/* maximum number of key extractors in a composite key */
+
+#if BOOST_MULTI_INDEX_LIMIT_COMPOSITE_KEY_SIZE<10 /* max length of a tuple */
+#define BOOST_MULTI_INDEX_COMPOSITE_KEY_SIZE \
+  BOOST_MULTI_INDEX_LIMIT_COMPOSITE_KEY_SIZE
+#else
+#define BOOST_MULTI_INDEX_COMPOSITE_KEY_SIZE 10
+#endif
+
+/* BOOST_PP_ENUM of BOOST_MULTI_INDEX_COMPOSITE_KEY_SIZE elements */
+
+#define BOOST_MULTI_INDEX_CK_ENUM(macro,data)                                \
+  BOOST_PP_ENUM(BOOST_MULTI_INDEX_COMPOSITE_KEY_SIZE,macro,data)
+
+/* BOOST_PP_ENUM_PARAMS of BOOST_MULTI_INDEX_COMPOSITE_KEY_SIZE elements */
+
+#define BOOST_MULTI_INDEX_CK_ENUM_PARAMS(param)                              \
+  BOOST_PP_ENUM_PARAMS(BOOST_MULTI_INDEX_COMPOSITE_KEY_SIZE,param)
+
+/* if n==0 ->   text0
+ * otherwise -> textn=tuples::null_type
+ */
+
+#define BOOST_MULTI_INDEX_CK_TEMPLATE_PARM(z,n,text)                         \
+  typename BOOST_PP_CAT(text,n) BOOST_PP_EXPR_IF(n,=tuples::null_type)
+
+/* const textn& kn=textn() */
+
+#define BOOST_MULTI_INDEX_CK_CTOR_ARG(z,n,text)                              \
+  const BOOST_PP_CAT(text,n)& BOOST_PP_CAT(k,n) = BOOST_PP_CAT(text,n)()
+
+/* typename list(0)<list(1),n>::type */
+
+#define BOOST_MULTI_INDEX_CK_APPLY_METAFUNCTION_N(z,n,list)                  \
+  BOOST_DEDUCED_TYPENAME BOOST_PP_LIST_AT(list,0)<                           \
+    BOOST_PP_LIST_AT(list,1),n                                               \
+  >::type
+
+namespace boost{
+
+template<class T> class reference_wrapper; /* fwd decl. */
+
+namespace multi_index{
+
+namespace detail{
+
+/* n-th key extractor of a composite key */
+
+template<typename CompositeKey,int N>
+struct nth_key_from_value
+{
+  typedef typename CompositeKey::key_extractor_tuple key_extractor_tuple;
+  typedef typename mpl::eval_if_c<
+    N<tuples::length<key_extractor_tuple>::value,
+    tuples::element<N,key_extractor_tuple>,
+    mpl::identity<tuples::null_type>
+  >::type                                            type;
+};
+
+/* nth_composite_key_##name<CompositeKey,N>::type yields
+ * functor<nth_key_from_value<CompositeKey,N> >, or tuples::null_type
+ * if N exceeds the length of the composite key.
+ */
+
+#define BOOST_MULTI_INDEX_CK_NTH_COMPOSITE_KEY_FUNCTOR(name,functor)         \
+template<typename KeyFromValue>                                              \
+struct BOOST_PP_CAT(key_,name)                                               \
+{                                                                            \
+  typedef functor<typename KeyFromValue::result_type> type;                  \
+};                                                                           \
+                                                                             \
+template<>                                                                   \
+struct BOOST_PP_CAT(key_,name)<tuples::null_type>                            \
+{                                                                            \
+  typedef tuples::null_type type;                                            \
+};                                                                           \
+                                                                             \
+template<typename CompositeKey,int  N>                                       \
+struct BOOST_PP_CAT(nth_composite_key_,name)                                 \
+{                                                                            \
+  typedef typename nth_key_from_value<CompositeKey,N>::type key_from_value;  \
+  typedef typename BOOST_PP_CAT(key_,name)<key_from_value>::type type;       \
+};
+
+/* nth_composite_key_equal_to
+ * nth_composite_key_less
+ * nth_composite_key_greater
+ * nth_composite_key_hash
+ */
+
+BOOST_MULTI_INDEX_CK_NTH_COMPOSITE_KEY_FUNCTOR(equal_to,std::equal_to)
+BOOST_MULTI_INDEX_CK_NTH_COMPOSITE_KEY_FUNCTOR(less,std::less)
+BOOST_MULTI_INDEX_CK_NTH_COMPOSITE_KEY_FUNCTOR(greater,std::greater)
+BOOST_MULTI_INDEX_CK_NTH_COMPOSITE_KEY_FUNCTOR(hash,boost::hash)
+
+/* used for defining equality and comparison ops of composite_key_result */
+
+#define BOOST_MULTI_INDEX_CK_IDENTITY_ENUM_MACRO(z,n,text) text
+
+struct generic_operator_equal
+{
+  template<typename T,typename Q>
+  bool operator()(const T& x,const Q& y)const{return x==y;}
+};
+
+typedef tuple<
+  BOOST_MULTI_INDEX_CK_ENUM(
+    BOOST_MULTI_INDEX_CK_IDENTITY_ENUM_MACRO,
+    detail::generic_operator_equal)>          generic_operator_equal_tuple;
+
+struct generic_operator_less
+{
+  template<typename T,typename Q>
+  bool operator()(const T& x,const Q& y)const{return x<y;}
+};
+
+typedef tuple<
+  BOOST_MULTI_INDEX_CK_ENUM(
+    BOOST_MULTI_INDEX_CK_IDENTITY_ENUM_MACRO,
+    detail::generic_operator_less)>           generic_operator_less_tuple;
+
+/* Metaprogramming machinery for implementing equality, comparison and
+ * hashing operations of composite_key_result.
+ *
+ * equal_* checks for equality between composite_key_results and
+ * between those and tuples, accepting a tuple of basic equality functors.
+ * compare_* does lexicographical comparison.
+ * hash_* computes a combination of elementwise hash values.
+ */
+
+template
+<
+  typename KeyCons1,typename Value1,
+  typename KeyCons2, typename Value2,
+  typename EqualCons
+>
+struct equal_ckey_ckey; /* fwd decl. */
+
+template
+<
+  typename KeyCons1,typename Value1,
+  typename KeyCons2, typename Value2,
+  typename EqualCons
+>
+struct equal_ckey_ckey_terminal
+{
+  static bool compare(
+    const KeyCons1&,const Value1&,
+    const KeyCons2&,const Value2&,
+    const EqualCons&)
+  {
+    return true;
+  }
+};
+
+template
+<
+  typename KeyCons1,typename Value1,
+  typename KeyCons2, typename Value2,
+  typename EqualCons
+>
+struct equal_ckey_ckey_normal
+{
+  static bool compare(
+    const KeyCons1& c0,const Value1& v0,
+    const KeyCons2& c1,const Value2& v1,
+    const EqualCons& eq)
+  {
+    if(!eq.get_head()(c0.get_head()(v0),c1.get_head()(v1)))return false;
+    return equal_ckey_ckey<
+      BOOST_DEDUCED_TYPENAME KeyCons1::tail_type,Value1,
+      BOOST_DEDUCED_TYPENAME KeyCons2::tail_type,Value2,
+      BOOST_DEDUCED_TYPENAME EqualCons::tail_type
+    >::compare(c0.get_tail(),v0,c1.get_tail(),v1,eq.get_tail());
+  }
+};
+
+template
+<
+  typename KeyCons1,typename Value1,
+  typename KeyCons2, typename Value2,
+  typename EqualCons
+>
+struct equal_ckey_ckey:
+  mpl::if_<
+    mpl::or_<
+      is_same<KeyCons1,tuples::null_type>,
+      is_same<KeyCons2,tuples::null_type>
+    >,
+    equal_ckey_ckey_terminal<KeyCons1,Value1,KeyCons2,Value2,EqualCons>,
+    equal_ckey_ckey_normal<KeyCons1,Value1,KeyCons2,Value2,EqualCons>
+  >::type
+{
+};
+
+template
+<
+  typename KeyCons,typename Value,
+  typename ValCons,typename EqualCons
+>
+struct equal_ckey_cval; /* fwd decl. */
+
+template
+<
+  typename KeyCons,typename Value,
+  typename ValCons,typename EqualCons
+>
+struct equal_ckey_cval_terminal
+{
+  static bool compare(
+    const KeyCons&,const Value&,const ValCons&,const EqualCons&)
+  {
+    return true;
+  }
+
+  static bool compare(
+    const ValCons&,const KeyCons&,const Value&,const EqualCons&)
+  {
+    return true;
+  }
+};
+
+template
+<
+  typename KeyCons,typename Value,
+  typename ValCons,typename EqualCons
+>
+struct equal_ckey_cval_normal
+{
+  static bool compare(
+    const KeyCons& c,const Value& v,const ValCons& vc,
+    const EqualCons& eq)
+  {
+    if(!eq.get_head()(c.get_head()(v),vc.get_head()))return false;
+    return equal_ckey_cval<
+      BOOST_DEDUCED_TYPENAME KeyCons::tail_type,Value,
+      BOOST_DEDUCED_TYPENAME ValCons::tail_type,
+      BOOST_DEDUCED_TYPENAME EqualCons::tail_type
+    >::compare(c.get_tail(),v,vc.get_tail(),eq.get_tail());
+  }
+
+  static bool compare(
+    const ValCons& vc,const KeyCons& c,const Value& v,
+    const EqualCons& eq)
+  {
+    if(!eq.get_head()(vc.get_head(),c.get_head()(v)))return false;
+    return equal_ckey_cval<
+      BOOST_DEDUCED_TYPENAME KeyCons::tail_type,Value,
+      BOOST_DEDUCED_TYPENAME ValCons::tail_type,
+      BOOST_DEDUCED_TYPENAME EqualCons::tail_type
+    >::compare(vc.get_tail(),c.get_tail(),v,eq.get_tail());
+  }
+};
+
+template
+<
+  typename KeyCons,typename Value,
+  typename ValCons,typename EqualCons
+>
+struct equal_ckey_cval:
+  mpl::if_<
+    mpl::or_<
+      is_same<KeyCons,tuples::null_type>,
+      is_same<ValCons,tuples::null_type>
+    >,
+    equal_ckey_cval_terminal<KeyCons,Value,ValCons,EqualCons>,
+    equal_ckey_cval_normal<KeyCons,Value,ValCons,EqualCons>
+  >::type
+{
+};
+
+template
+<
+  typename KeyCons1,typename Value1,
+  typename KeyCons2, typename Value2,
+  typename CompareCons
+>
+struct compare_ckey_ckey; /* fwd decl. */
+
+template
+<
+  typename KeyCons1,typename Value1,
+  typename KeyCons2, typename Value2,
+  typename CompareCons
+>
+struct compare_ckey_ckey_terminal
+{
+  static bool compare(
+    const KeyCons1&,const Value1&,
+    const KeyCons2&,const Value2&,
+    const CompareCons&)
+  {
+    return false;
+  }
+};
+
+template
+<
+  typename KeyCons1,typename Value1,
+  typename KeyCons2, typename Value2,
+  typename CompareCons
+>
+struct compare_ckey_ckey_normal
+{
+  static bool compare(
+    const KeyCons1& c0,const Value1& v0,
+    const KeyCons2& c1,const Value2& v1,
+    const CompareCons& comp)
+  {
+    if(comp.get_head()(c0.get_head()(v0),c1.get_head()(v1)))return true;
+    if(comp.get_head()(c1.get_head()(v1),c0.get_head()(v0)))return false;
+    return compare_ckey_ckey<
+      BOOST_DEDUCED_TYPENAME KeyCons1::tail_type,Value1,
+      BOOST_DEDUCED_TYPENAME KeyCons2::tail_type,Value2,
+      BOOST_DEDUCED_TYPENAME CompareCons::tail_type
+    >::compare(c0.get_tail(),v0,c1.get_tail(),v1,comp.get_tail());
+  }
+};
+
+template
+<
+  typename KeyCons1,typename Value1,
+  typename KeyCons2, typename Value2,
+  typename CompareCons
+>
+struct compare_ckey_ckey:
+  mpl::if_<
+    mpl::or_<
+      is_same<KeyCons1,tuples::null_type>,
+      is_same<KeyCons2,tuples::null_type>
+    >,
+    compare_ckey_ckey_terminal<KeyCons1,Value1,KeyCons2,Value2,CompareCons>,
+    compare_ckey_ckey_normal<KeyCons1,Value1,KeyCons2,Value2,CompareCons>
+  >::type
+{
+};
+
+template
+<
+  typename KeyCons,typename Value,
+  typename ValCons,typename CompareCons
+>
+struct compare_ckey_cval; /* fwd decl. */
+
+template
+<
+  typename KeyCons,typename Value,
+  typename ValCons,typename CompareCons
+>
+struct compare_ckey_cval_terminal
+{
+  static bool compare(
+    const KeyCons&,const Value&,const ValCons&,const CompareCons&)
+  {
+    return false;
+  }
+
+  static bool compare(
+    const ValCons&,const KeyCons&,const Value&,const CompareCons&)
+  {
+    return false;
+  }
+};
+
+template
+<
+  typename KeyCons,typename Value,
+  typename ValCons,typename CompareCons
+>
+struct compare_ckey_cval_normal
+{
+  static bool compare(
+    const KeyCons& c,const Value& v,const ValCons& vc,
+    const CompareCons& comp)
+  {
+    if(comp.get_head()(c.get_head()(v),vc.get_head()))return true;
+    if(comp.get_head()(vc.get_head(),c.get_head()(v)))return false;
+    return compare_ckey_cval<
+      BOOST_DEDUCED_TYPENAME KeyCons::tail_type,Value,
+      BOOST_DEDUCED_TYPENAME ValCons::tail_type,
+      BOOST_DEDUCED_TYPENAME CompareCons::tail_type
+    >::compare(c.get_tail(),v,vc.get_tail(),comp.get_tail());
+  }
+
+  static bool compare(
+    const ValCons& vc,const KeyCons& c,const Value& v,
+    const CompareCons& comp)
+  {
+    if(comp.get_head()(vc.get_head(),c.get_head()(v)))return true;
+    if(comp.get_head()(c.get_head()(v),vc.get_head()))return false;
+    return compare_ckey_cval<
+      BOOST_DEDUCED_TYPENAME KeyCons::tail_type,Value,
+      BOOST_DEDUCED_TYPENAME ValCons::tail_type,
+      BOOST_DEDUCED_TYPENAME CompareCons::tail_type
+    >::compare(vc.get_tail(),c.get_tail(),v,comp.get_tail());
+  }
+};
+
+template
+<
+  typename KeyCons,typename Value,
+  typename ValCons,typename CompareCons
+>
+struct compare_ckey_cval:
+  mpl::if_<
+    mpl::or_<
+      is_same<KeyCons,tuples::null_type>,
+      is_same<ValCons,tuples::null_type>
+    >,
+    compare_ckey_cval_terminal<KeyCons,Value,ValCons,CompareCons>,
+    compare_ckey_cval_normal<KeyCons,Value,ValCons,CompareCons>
+  >::type
+{
+};
+
+template<typename KeyCons,typename Value,typename HashCons>
+struct hash_ckey; /* fwd decl. */
+
+template<typename KeyCons,typename Value,typename HashCons>
+struct hash_ckey_terminal
+{
+  static std::size_t hash(
+    const KeyCons&,const Value&,const HashCons&,std::size_t carry)
+  {
+    return carry;
+  }
+};
+
+template<typename KeyCons,typename Value,typename HashCons>
+struct hash_ckey_normal
+{
+  static std::size_t hash(
+    const KeyCons& c,const Value& v,const HashCons& h,std::size_t carry=0)
+  {
+    /* same hashing formula as boost::hash_combine */
+
+    carry^=h.get_head()(c.get_head()(v))+0x9e3779b9+(carry<<6)+(carry>>2);
+    return hash_ckey<
+      BOOST_DEDUCED_TYPENAME KeyCons::tail_type,Value,
+      BOOST_DEDUCED_TYPENAME HashCons::tail_type
+    >::hash(c.get_tail(),v,h.get_tail(),carry);
+  }
+};
+
+template<typename KeyCons,typename Value,typename HashCons>
+struct hash_ckey:
+  mpl::if_<
+    is_same<KeyCons,tuples::null_type>,
+    hash_ckey_terminal<KeyCons,Value,HashCons>,
+    hash_ckey_normal<KeyCons,Value,HashCons>
+  >::type
+{
+};
+
+template<typename ValCons,typename HashCons>
+struct hash_cval; /* fwd decl. */
+
+template<typename ValCons,typename HashCons>
+struct hash_cval_terminal
+{
+  static std::size_t hash(const ValCons&,const HashCons&,std::size_t carry)
+  {
+    return carry;
+  }
+};
+
+template<typename ValCons,typename HashCons>
+struct hash_cval_normal
+{
+  static std::size_t hash(
+    const ValCons& vc,const HashCons& h,std::size_t carry=0)
+  {
+    carry^=h.get_head()(vc.get_head())+0x9e3779b9+(carry<<6)+(carry>>2);
+    return hash_cval<
+      BOOST_DEDUCED_TYPENAME ValCons::tail_type,
+      BOOST_DEDUCED_TYPENAME HashCons::tail_type
+    >::hash(vc.get_tail(),h.get_tail(),carry);
+  }
+};
+
+template<typename ValCons,typename HashCons>
+struct hash_cval:
+  mpl::if_<
+    is_same<ValCons,tuples::null_type>,
+    hash_cval_terminal<ValCons,HashCons>,
+    hash_cval_normal<ValCons,HashCons>
+  >::type
+{
+};
+
+} /* namespace multi_index::detail */
+
+/* composite_key_result */
+
+#if defined(BOOST_MSVC)
+#pragma warning(push)
+#pragma warning(disable:4512)
+#endif
+
+template<typename CompositeKey>
+struct composite_key_result
+{
+  typedef CompositeKey                            composite_key_type;
+  typedef typename composite_key_type::value_type value_type;
+
+  composite_key_result(
+    const composite_key_type& composite_key_,const value_type& value_):
+    composite_key(composite_key_),value(value_)
+  {}
+
+  const composite_key_type& composite_key;
+  const value_type&         value;
+};
+
+#if defined(BOOST_MSVC)
+#pragma warning(pop)
+#endif
+
+/* composite_key */
+
+template<
+  typename Value,
+  BOOST_MULTI_INDEX_CK_ENUM(BOOST_MULTI_INDEX_CK_TEMPLATE_PARM,KeyFromValue)
+>
+struct composite_key:
+  private tuple<BOOST_MULTI_INDEX_CK_ENUM_PARAMS(KeyFromValue)>
+{
+private:
+  typedef tuple<BOOST_MULTI_INDEX_CK_ENUM_PARAMS(KeyFromValue)> super;
+
+public:
+  typedef super                               key_extractor_tuple;
+  typedef Value                               value_type;
+  typedef composite_key_result<composite_key> result_type;
+
+  composite_key(
+    BOOST_MULTI_INDEX_CK_ENUM(BOOST_MULTI_INDEX_CK_CTOR_ARG,KeyFromValue)):
+    super(BOOST_MULTI_INDEX_CK_ENUM_PARAMS(k))
+  {}
+
+  composite_key(const key_extractor_tuple& x):super(x){}
+
+  const key_extractor_tuple& key_extractors()const{return *this;}
+  key_extractor_tuple&       key_extractors(){return *this;}
+
+  template<typename ChainedPtr>
+
+#if !defined(BOOST_NO_SFINAE)
+  typename disable_if<
+    is_convertible<const ChainedPtr&,const value_type&>,result_type>::type
+#else
+  result_type
+#endif
+
+  operator()(const ChainedPtr& x)const
+  {
+    return operator()(*x);
+  }
+
+  result_type operator()(const value_type& x)const
+  {
+    return result_type(*this,x);
+  }
+
+  result_type operator()(const reference_wrapper<const value_type>& x)const
+  {
+    return result_type(*this,x.get());
+  }
+
+  result_type operator()(const reference_wrapper<value_type>& x)const
+  {
+    return result_type(*this,x.get());
+  }
+};
+
+/* comparison operators */
+
+/* == */
+
+template<typename CompositeKey1,typename CompositeKey2>
+inline bool operator==(
+  const composite_key_result<CompositeKey1>& x,
+  const composite_key_result<CompositeKey2>& y)
+{
+  typedef typename CompositeKey1::key_extractor_tuple key_extractor_tuple1;
+  typedef typename CompositeKey1::value_type          value_type1;
+  typedef typename CompositeKey2::key_extractor_tuple key_extractor_tuple2;
+  typedef typename CompositeKey2::value_type          value_type2;
+
+  BOOST_STATIC_ASSERT(
+    tuples::length<key_extractor_tuple1>::value==
+    tuples::length<key_extractor_tuple2>::value);
+
+  return detail::equal_ckey_ckey<
+    key_extractor_tuple1,value_type1,
+    key_extractor_tuple2,value_type2,
+    detail::generic_operator_equal_tuple
+  >::compare(
+    x.composite_key.key_extractors(),x.value,
+    y.composite_key.key_extractors(),y.value,
+    detail::generic_operator_equal_tuple());
+}
+
+template<
+  typename CompositeKey,
+  BOOST_MULTI_INDEX_CK_ENUM_PARAMS(typename Value)
+>
+inline bool operator==(
+  const composite_key_result<CompositeKey>& x,
+  const tuple<BOOST_MULTI_INDEX_CK_ENUM_PARAMS(Value)>& y)
+{
+  typedef typename CompositeKey::key_extractor_tuple     key_extractor_tuple;
+  typedef typename CompositeKey::value_type              value_type;
+  typedef tuple<BOOST_MULTI_INDEX_CK_ENUM_PARAMS(Value)> key_tuple;
+  
+  BOOST_STATIC_ASSERT(
+    tuples::length<key_extractor_tuple>::value==
+    tuples::length<key_tuple>::value);
+
+  return detail::equal_ckey_cval<
+    key_extractor_tuple,value_type,
+    key_tuple,detail::generic_operator_equal_tuple
+  >::compare(
+    x.composite_key.key_extractors(),x.value,
+    y,detail::generic_operator_equal_tuple());
+}
+
+template
+<
+  BOOST_MULTI_INDEX_CK_ENUM_PARAMS(typename Value),
+  typename CompositeKey
+>
+inline bool operator==(
+  const tuple<BOOST_MULTI_INDEX_CK_ENUM_PARAMS(Value)>& x,
+  const composite_key_result<CompositeKey>& y)
+{
+  typedef typename CompositeKey::key_extractor_tuple     key_extractor_tuple;
+  typedef typename CompositeKey::value_type              value_type;
+  typedef tuple<BOOST_MULTI_INDEX_CK_ENUM_PARAMS(Value)> key_tuple;
+  
+  BOOST_STATIC_ASSERT(
+    tuples::length<key_extractor_tuple>::value==
+    tuples::length<key_tuple>::value);
+
+  return detail::equal_ckey_cval<
+    key_extractor_tuple,value_type,
+    key_tuple,detail::generic_operator_equal_tuple
+  >::compare(
+    x,y.composite_key.key_extractors(),
+    y.value,detail::generic_operator_equal_tuple());
+}
+
+#if !defined(BOOST_NO_CXX11_HDR_TUPLE)&&\
+    !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+template<typename CompositeKey,typename... Values>
+inline bool operator==(
+  const composite_key_result<CompositeKey>& x,
+  const std::tuple<Values...>& y)
+{
+  typedef typename CompositeKey::key_extractor_tuple key_extractor_tuple;
+  typedef typename CompositeKey::value_type          value_type;
+  typedef std::tuple<Values...>                      key_tuple;
+  typedef typename detail::cons_stdtuple_ctor<
+    key_tuple>::result_type                          cons_key_tuple;
+  
+  BOOST_STATIC_ASSERT(
+    static_cast<std::size_t>(tuples::length<key_extractor_tuple>::value)==
+    std::tuple_size<key_tuple>::value);
+
+  return detail::equal_ckey_cval<
+    key_extractor_tuple,value_type,
+    cons_key_tuple,detail::generic_operator_equal_tuple
+  >::compare(
+    x.composite_key.key_extractors(),x.value,
+    detail::make_cons_stdtuple(y),detail::generic_operator_equal_tuple());
+}
+
+template<typename CompositeKey,typename... Values>
+inline bool operator==(
+  const std::tuple<Values...>& x,
+  const composite_key_result<CompositeKey>& y)
+{
+  typedef typename CompositeKey::key_extractor_tuple key_extractor_tuple;
+  typedef typename CompositeKey::value_type          value_type;
+  typedef std::tuple<Values...>                      key_tuple;
+  typedef typename detail::cons_stdtuple_ctor<
+    key_tuple>::result_type                          cons_key_tuple;
+
+  BOOST_STATIC_ASSERT(
+    static_cast<std::size_t>(tuples::length<key_extractor_tuple>::value)==
+    std::tuple_size<key_tuple>::value);
+
+  return detail::equal_ckey_cval<
+    key_extractor_tuple,value_type,
+    cons_key_tuple,detail::generic_operator_equal_tuple
+  >::compare(
+    detail::make_cons_stdtuple(x),y.composite_key.key_extractors(),
+    y.value,detail::generic_operator_equal_tuple());
+}
+#endif
+
+/* < */
+
+template<typename CompositeKey1,typename CompositeKey2>
+inline bool operator<(
+  const composite_key_result<CompositeKey1>& x,
+  const composite_key_result<CompositeKey2>& y)
+{
+  typedef typename CompositeKey1::key_extractor_tuple key_extractor_tuple1;
+  typedef typename CompositeKey1::value_type          value_type1;
+  typedef typename CompositeKey2::key_extractor_tuple key_extractor_tuple2;
+  typedef typename CompositeKey2::value_type          value_type2;
+
+  return detail::compare_ckey_ckey<
+   key_extractor_tuple1,value_type1,
+   key_extractor_tuple2,value_type2,
+   detail::generic_operator_less_tuple
+  >::compare(
+    x.composite_key.key_extractors(),x.value,
+    y.composite_key.key_extractors(),y.value,
+    detail::generic_operator_less_tuple());
+}
+
+template
+<
+  typename CompositeKey,
+  BOOST_MULTI_INDEX_CK_ENUM_PARAMS(typename Value)
+>
+inline bool operator<(
+  const composite_key_result<CompositeKey>& x,
+  const tuple<BOOST_MULTI_INDEX_CK_ENUM_PARAMS(Value)>& y)
+{
+  typedef typename CompositeKey::key_extractor_tuple     key_extractor_tuple;
+  typedef typename CompositeKey::value_type              value_type;
+  typedef tuple<BOOST_MULTI_INDEX_CK_ENUM_PARAMS(Value)> key_tuple;
+  
+  return detail::compare_ckey_cval<
+    key_extractor_tuple,value_type,
+    key_tuple,detail::generic_operator_less_tuple
+  >::compare(
+    x.composite_key.key_extractors(),x.value,
+    y,detail::generic_operator_less_tuple());
+}
+
+template
+<
+  BOOST_MULTI_INDEX_CK_ENUM_PARAMS(typename Value),
+  typename CompositeKey
+>
+inline bool operator<(
+  const tuple<BOOST_MULTI_INDEX_CK_ENUM_PARAMS(Value)>& x,
+  const composite_key_result<CompositeKey>& y)
+{
+  typedef typename CompositeKey::key_extractor_tuple     key_extractor_tuple;
+  typedef typename CompositeKey::value_type              value_type;
+  typedef tuple<BOOST_MULTI_INDEX_CK_ENUM_PARAMS(Value)> key_tuple;
+  
+  return detail::compare_ckey_cval<
+    key_extractor_tuple,value_type,
+    key_tuple,detail::generic_operator_less_tuple
+  >::compare(
+    x,y.composite_key.key_extractors(),
+    y.value,detail::generic_operator_less_tuple());
+}
+
+#if !defined(BOOST_NO_CXX11_HDR_TUPLE)&&\
+    !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+template<typename CompositeKey,typename... Values>
+inline bool operator<(
+  const composite_key_result<CompositeKey>& x,
+  const std::tuple<Values...>& y)
+{
+  typedef typename CompositeKey::key_extractor_tuple key_extractor_tuple;
+  typedef typename CompositeKey::value_type          value_type;
+  typedef std::tuple<Values...>                      key_tuple;
+  typedef typename detail::cons_stdtuple_ctor<
+    key_tuple>::result_type                          cons_key_tuple;
+  
+  return detail::compare_ckey_cval<
+    key_extractor_tuple,value_type,
+    cons_key_tuple,detail::generic_operator_less_tuple
+  >::compare(
+    x.composite_key.key_extractors(),x.value,
+    detail::make_cons_stdtuple(y),detail::generic_operator_less_tuple());
+}
+
+template<typename CompositeKey,typename... Values>
+inline bool operator<(
+  const std::tuple<Values...>& x,
+  const composite_key_result<CompositeKey>& y)
+{
+  typedef typename CompositeKey::key_extractor_tuple key_extractor_tuple;
+  typedef typename CompositeKey::value_type          value_type;
+  typedef std::tuple<Values...>                      key_tuple;
+  typedef typename detail::cons_stdtuple_ctor<
+    key_tuple>::result_type                          cons_key_tuple;
+  
+  return detail::compare_ckey_cval<
+    key_extractor_tuple,value_type,
+    cons_key_tuple,detail::generic_operator_less_tuple
+  >::compare(
+    detail::make_cons_stdtuple(x),y.composite_key.key_extractors(),
+    y.value,detail::generic_operator_less_tuple());
+}
+#endif
+
+/* rest of comparison operators */
+
+#define BOOST_MULTI_INDEX_CK_COMPLETE_COMP_OPS(t1,t2,a1,a2)                  \
+template<t1,t2> inline bool operator!=(const a1& x,const a2& y)              \
+{                                                                            \
+  return !(x==y);                                                            \
+}                                                                            \
+                                                                             \
+template<t1,t2> inline bool operator>(const a1& x,const a2& y)               \
+{                                                                            \
+  return y<x;                                                                \
+}                                                                            \
+                                                                             \
+template<t1,t2> inline bool operator>=(const a1& x,const a2& y)              \
+{                                                                            \
+  return !(x<y);                                                             \
+}                                                                            \
+                                                                             \
+template<t1,t2> inline bool operator<=(const a1& x,const a2& y)              \
+{                                                                            \
+  return !(y<x);                                                             \
+}
+
+BOOST_MULTI_INDEX_CK_COMPLETE_COMP_OPS(
+  typename CompositeKey1,
+  typename CompositeKey2,
+  composite_key_result<CompositeKey1>,
+  composite_key_result<CompositeKey2>
+)
+
+BOOST_MULTI_INDEX_CK_COMPLETE_COMP_OPS(
+  typename CompositeKey,
+  BOOST_MULTI_INDEX_CK_ENUM_PARAMS(typename Value),
+  composite_key_result<CompositeKey>,
+  tuple<BOOST_MULTI_INDEX_CK_ENUM_PARAMS(Value)>
+)
+
+BOOST_MULTI_INDEX_CK_COMPLETE_COMP_OPS(
+  BOOST_MULTI_INDEX_CK_ENUM_PARAMS(typename Value),
+  typename CompositeKey,
+  tuple<BOOST_MULTI_INDEX_CK_ENUM_PARAMS(Value)>,
+  composite_key_result<CompositeKey>
+)
+
+#if !defined(BOOST_NO_CXX11_HDR_TUPLE)&&\
+    !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+BOOST_MULTI_INDEX_CK_COMPLETE_COMP_OPS(
+  typename CompositeKey,
+  typename... Values,
+  composite_key_result<CompositeKey>,
+  std::tuple<Values...>
+)
+
+BOOST_MULTI_INDEX_CK_COMPLETE_COMP_OPS(
+  typename CompositeKey,
+  typename... Values,
+  std::tuple<Values...>,
+  composite_key_result<CompositeKey>
+)
+#endif
+
+/* composite_key_equal_to */
+
+template
+<
+  BOOST_MULTI_INDEX_CK_ENUM(BOOST_MULTI_INDEX_CK_TEMPLATE_PARM,Pred)
+>
+struct composite_key_equal_to:
+  private tuple<BOOST_MULTI_INDEX_CK_ENUM_PARAMS(Pred)>
+{
+private:
+  typedef tuple<BOOST_MULTI_INDEX_CK_ENUM_PARAMS(Pred)> super;
+
+public:
+  typedef super key_eq_tuple;
+
+  composite_key_equal_to(
+    BOOST_MULTI_INDEX_CK_ENUM(BOOST_MULTI_INDEX_CK_CTOR_ARG,Pred)):
+    super(BOOST_MULTI_INDEX_CK_ENUM_PARAMS(k))
+  {}
+
+  composite_key_equal_to(const key_eq_tuple& x):super(x){}
+
+  const key_eq_tuple& key_eqs()const{return *this;}
+  key_eq_tuple&       key_eqs(){return *this;}
+
+  template<typename CompositeKey1,typename CompositeKey2>
+  bool operator()(
+    const composite_key_result<CompositeKey1> & x,
+    const composite_key_result<CompositeKey2> & y)const
+  {
+    typedef typename CompositeKey1::key_extractor_tuple key_extractor_tuple1;
+    typedef typename CompositeKey1::value_type          value_type1;
+    typedef typename CompositeKey2::key_extractor_tuple key_extractor_tuple2;
+    typedef typename CompositeKey2::value_type          value_type2;
+
+    BOOST_STATIC_ASSERT(
+      tuples::length<key_extractor_tuple1>::value<=
+      tuples::length<key_eq_tuple>::value&&
+      tuples::length<key_extractor_tuple1>::value==
+      tuples::length<key_extractor_tuple2>::value);
+
+    return detail::equal_ckey_ckey<
+      key_extractor_tuple1,value_type1,
+      key_extractor_tuple2,value_type2,
+      key_eq_tuple
+    >::compare(
+      x.composite_key.key_extractors(),x.value,
+      y.composite_key.key_extractors(),y.value,
+      key_eqs());
+  }
+  
+  template
+  <
+    typename CompositeKey,
+    BOOST_MULTI_INDEX_CK_ENUM_PARAMS(typename Value)
+  >
+  bool operator()(
+    const composite_key_result<CompositeKey>& x,
+    const tuple<BOOST_MULTI_INDEX_CK_ENUM_PARAMS(Value)>& y)const
+  {
+    typedef typename CompositeKey::key_extractor_tuple     key_extractor_tuple;
+    typedef typename CompositeKey::value_type              value_type;
+    typedef tuple<BOOST_MULTI_INDEX_CK_ENUM_PARAMS(Value)> key_tuple;
+
+    BOOST_STATIC_ASSERT(
+      tuples::length<key_extractor_tuple>::value<=
+      tuples::length<key_eq_tuple>::value&&
+      tuples::length<key_extractor_tuple>::value==
+      tuples::length<key_tuple>::value);
+
+    return detail::equal_ckey_cval<
+      key_extractor_tuple,value_type,
+      key_tuple,key_eq_tuple
+    >::compare(x.composite_key.key_extractors(),x.value,y,key_eqs());
+  }
+
+  template
+  <
+    BOOST_MULTI_INDEX_CK_ENUM_PARAMS(typename Value),
+    typename CompositeKey
+  >
+  bool operator()(
+    const tuple<BOOST_MULTI_INDEX_CK_ENUM_PARAMS(Value)>& x,
+    const composite_key_result<CompositeKey>& y)const
+  {
+    typedef typename CompositeKey::key_extractor_tuple     key_extractor_tuple;
+    typedef typename CompositeKey::value_type              value_type;
+    typedef tuple<BOOST_MULTI_INDEX_CK_ENUM_PARAMS(Value)> key_tuple;
+
+    BOOST_STATIC_ASSERT(
+      tuples::length<key_tuple>::value<=
+      tuples::length<key_eq_tuple>::value&&
+      tuples::length<key_tuple>::value==
+      tuples::length<key_extractor_tuple>::value);
+
+    return detail::equal_ckey_cval<
+      key_extractor_tuple,value_type,
+      key_tuple,key_eq_tuple
+    >::compare(x,y.composite_key.key_extractors(),y.value,key_eqs());
+  }
+
+#if !defined(BOOST_NO_CXX11_HDR_TUPLE)&&\
+    !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+  template<typename CompositeKey,typename... Values>
+  bool operator()(
+    const composite_key_result<CompositeKey>& x,
+    const std::tuple<Values...>& y)const
+  {
+    typedef typename CompositeKey::key_extractor_tuple key_extractor_tuple;
+    typedef typename CompositeKey::value_type          value_type;
+    typedef std::tuple<Values...>                      key_tuple;
+    typedef typename detail::cons_stdtuple_ctor<
+      key_tuple>::result_type                          cons_key_tuple;
+
+    BOOST_STATIC_ASSERT(
+      tuples::length<key_extractor_tuple>::value<=
+      tuples::length<key_eq_tuple>::value&&
+      static_cast<std::size_t>(tuples::length<key_extractor_tuple>::value)==
+      std::tuple_size<key_tuple>::value);
+
+    return detail::equal_ckey_cval<
+      key_extractor_tuple,value_type,
+      cons_key_tuple,key_eq_tuple
+    >::compare(
+      x.composite_key.key_extractors(),x.value,
+      detail::make_cons_stdtuple(y),key_eqs());
+  }
+
+  template<typename CompositeKey,typename... Values>
+  bool operator()(
+    const std::tuple<Values...>& x,
+    const composite_key_result<CompositeKey>& y)const
+  {
+    typedef typename CompositeKey::key_extractor_tuple key_extractor_tuple;
+    typedef typename CompositeKey::value_type          value_type;
+    typedef std::tuple<Values...>                      key_tuple;
+    typedef typename detail::cons_stdtuple_ctor<
+      key_tuple>::result_type                          cons_key_tuple;
+
+    BOOST_STATIC_ASSERT(
+      std::tuple_size<key_tuple>::value<=
+      static_cast<std::size_t>(tuples::length<key_eq_tuple>::value)&&
+      std::tuple_size<key_tuple>::value==
+      static_cast<std::size_t>(tuples::length<key_extractor_tuple>::value));
+
+    return detail::equal_ckey_cval<
+      key_extractor_tuple,value_type,
+      cons_key_tuple,key_eq_tuple
+    >::compare(
+      detail::make_cons_stdtuple(x),y.composite_key.key_extractors(),
+      y.value,key_eqs());
+  }
+#endif
+};
+
+/* composite_key_compare */
+
+template
+<
+  BOOST_MULTI_INDEX_CK_ENUM(BOOST_MULTI_INDEX_CK_TEMPLATE_PARM,Compare)
+>
+struct composite_key_compare:
+  private tuple<BOOST_MULTI_INDEX_CK_ENUM_PARAMS(Compare)>
+{
+private:
+  typedef tuple<BOOST_MULTI_INDEX_CK_ENUM_PARAMS(Compare)> super;
+
+public:
+  typedef super key_comp_tuple;
+
+  composite_key_compare(
+    BOOST_MULTI_INDEX_CK_ENUM(BOOST_MULTI_INDEX_CK_CTOR_ARG,Compare)):
+    super(BOOST_MULTI_INDEX_CK_ENUM_PARAMS(k))
+  {}
+
+  composite_key_compare(const key_comp_tuple& x):super(x){}
+
+  const key_comp_tuple& key_comps()const{return *this;}
+  key_comp_tuple&       key_comps(){return *this;}
+
+  template<typename CompositeKey1,typename CompositeKey2>
+  bool operator()(
+    const composite_key_result<CompositeKey1> & x,
+    const composite_key_result<CompositeKey2> & y)const
+  {
+    typedef typename CompositeKey1::key_extractor_tuple key_extractor_tuple1;
+    typedef typename CompositeKey1::value_type          value_type1;
+    typedef typename CompositeKey2::key_extractor_tuple key_extractor_tuple2;
+    typedef typename CompositeKey2::value_type          value_type2;
+
+    BOOST_STATIC_ASSERT(
+      tuples::length<key_extractor_tuple1>::value<=
+      tuples::length<key_comp_tuple>::value||
+      tuples::length<key_extractor_tuple2>::value<=
+      tuples::length<key_comp_tuple>::value);
+
+    return detail::compare_ckey_ckey<
+      key_extractor_tuple1,value_type1,
+      key_extractor_tuple2,value_type2,
+      key_comp_tuple
+    >::compare(
+      x.composite_key.key_extractors(),x.value,
+      y.composite_key.key_extractors(),y.value,
+      key_comps());
+  }
+  
+#if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
+  template<typename CompositeKey,typename Value>
+  bool operator()(
+    const composite_key_result<CompositeKey>& x,
+    const Value& y)const
+  {
+    return operator()(x,boost::make_tuple(boost::cref(y)));
+  }
+#endif
+
+  template
+  <
+    typename CompositeKey,
+    BOOST_MULTI_INDEX_CK_ENUM_PARAMS(typename Value)
+  >
+  bool operator()(
+    const composite_key_result<CompositeKey>& x,
+    const tuple<BOOST_MULTI_INDEX_CK_ENUM_PARAMS(Value)>& y)const
+  {
+    typedef typename CompositeKey::key_extractor_tuple     key_extractor_tuple;
+    typedef typename CompositeKey::value_type              value_type;
+    typedef tuple<BOOST_MULTI_INDEX_CK_ENUM_PARAMS(Value)> key_tuple;
+
+    BOOST_STATIC_ASSERT(
+      tuples::length<key_extractor_tuple>::value<=
+      tuples::length<key_comp_tuple>::value||
+      tuples::length<key_tuple>::value<=
+      tuples::length<key_comp_tuple>::value);
+
+    return detail::compare_ckey_cval<
+      key_extractor_tuple,value_type,
+      key_tuple,key_comp_tuple
+    >::compare(x.composite_key.key_extractors(),x.value,y,key_comps());
+  }
+
+#if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
+  template<typename Value,typename CompositeKey>
+  bool operator()(
+    const Value& x,
+    const composite_key_result<CompositeKey>& y)const
+  {
+    return operator()(boost::make_tuple(boost::cref(x)),y);
+  }
+#endif
+
+  template
+  <
+    BOOST_MULTI_INDEX_CK_ENUM_PARAMS(typename Value),
+    typename CompositeKey
+  >
+  bool operator()(
+    const tuple<BOOST_MULTI_INDEX_CK_ENUM_PARAMS(Value)>& x,
+    const composite_key_result<CompositeKey>& y)const
+  {
+    typedef typename CompositeKey::key_extractor_tuple     key_extractor_tuple;
+    typedef typename CompositeKey::value_type              value_type;
+    typedef tuple<BOOST_MULTI_INDEX_CK_ENUM_PARAMS(Value)> key_tuple;
+
+    BOOST_STATIC_ASSERT(
+      tuples::length<key_tuple>::value<=
+      tuples::length<key_comp_tuple>::value||
+      tuples::length<key_extractor_tuple>::value<=
+      tuples::length<key_comp_tuple>::value);
+
+    return detail::compare_ckey_cval<
+      key_extractor_tuple,value_type,
+      key_tuple,key_comp_tuple
+    >::compare(x,y.composite_key.key_extractors(),y.value,key_comps());
+  }
+
+#if !defined(BOOST_NO_CXX11_HDR_TUPLE)&&\
+    !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+  template<typename CompositeKey,typename... Values>
+  bool operator()(
+    const composite_key_result<CompositeKey>& x,
+    const std::tuple<Values...>& y)const
+  {
+    typedef typename CompositeKey::key_extractor_tuple key_extractor_tuple;
+    typedef typename CompositeKey::value_type          value_type;
+    typedef std::tuple<Values...>                      key_tuple;
+    typedef typename detail::cons_stdtuple_ctor<
+      key_tuple>::result_type                          cons_key_tuple;
+
+    BOOST_STATIC_ASSERT(
+      tuples::length<key_extractor_tuple>::value<=
+      tuples::length<key_comp_tuple>::value||
+      std::tuple_size<key_tuple>::value<=
+      static_cast<std::size_t>(tuples::length<key_comp_tuple>::value));
+
+    return detail::compare_ckey_cval<
+      key_extractor_tuple,value_type,
+      cons_key_tuple,key_comp_tuple
+    >::compare(
+      x.composite_key.key_extractors(),x.value,
+      detail::make_cons_stdtuple(y),key_comps());
+  }
+
+  template<typename CompositeKey,typename... Values>
+  bool operator()(
+    const std::tuple<Values...>& x,
+    const composite_key_result<CompositeKey>& y)const
+  {
+    typedef typename CompositeKey::key_extractor_tuple key_extractor_tuple;
+    typedef typename CompositeKey::value_type          value_type;
+    typedef std::tuple<Values...>                      key_tuple;
+    typedef typename detail::cons_stdtuple_ctor<
+      key_tuple>::result_type                          cons_key_tuple;
+
+    BOOST_STATIC_ASSERT(
+      std::tuple_size<key_tuple>::value<=
+      static_cast<std::size_t>(tuples::length<key_comp_tuple>::value)||
+      tuples::length<key_extractor_tuple>::value<=
+      tuples::length<key_comp_tuple>::value);
+
+    return detail::compare_ckey_cval<
+      key_extractor_tuple,value_type,
+      cons_key_tuple,key_comp_tuple
+    >::compare(
+      detail::make_cons_stdtuple(x),y.composite_key.key_extractors(),
+      y.value,key_comps());
+  }
+#endif
+};
+
+/* composite_key_hash */
+
+template
+<
+  BOOST_MULTI_INDEX_CK_ENUM(BOOST_MULTI_INDEX_CK_TEMPLATE_PARM,Hash)
+>
+struct composite_key_hash:
+  private tuple<BOOST_MULTI_INDEX_CK_ENUM_PARAMS(Hash)>
+{
+private:
+  typedef tuple<BOOST_MULTI_INDEX_CK_ENUM_PARAMS(Hash)> super;
+
+public:
+  typedef super key_hasher_tuple;
+
+  composite_key_hash(
+    BOOST_MULTI_INDEX_CK_ENUM(BOOST_MULTI_INDEX_CK_CTOR_ARG,Hash)):
+    super(BOOST_MULTI_INDEX_CK_ENUM_PARAMS(k))
+  {}
+
+  composite_key_hash(const key_hasher_tuple& x):super(x){}
+
+  const key_hasher_tuple& key_hash_functions()const{return *this;}
+  key_hasher_tuple&       key_hash_functions(){return *this;}
+
+  template<typename CompositeKey>
+  std::size_t operator()(const composite_key_result<CompositeKey> & x)const
+  {
+    typedef typename CompositeKey::key_extractor_tuple key_extractor_tuple;
+    typedef typename CompositeKey::value_type          value_type;
+
+    BOOST_STATIC_ASSERT(
+      tuples::length<key_extractor_tuple>::value==
+      tuples::length<key_hasher_tuple>::value);
+
+    return detail::hash_ckey<
+      key_extractor_tuple,value_type,
+      key_hasher_tuple
+    >::hash(x.composite_key.key_extractors(),x.value,key_hash_functions());
+  }
+  
+  template<BOOST_MULTI_INDEX_CK_ENUM_PARAMS(typename Value)>
+  std::size_t operator()(
+    const tuple<BOOST_MULTI_INDEX_CK_ENUM_PARAMS(Value)>& x)const
+  {
+    typedef tuple<BOOST_MULTI_INDEX_CK_ENUM_PARAMS(Value)> key_tuple;
+
+    BOOST_STATIC_ASSERT(
+      tuples::length<key_tuple>::value==
+      tuples::length<key_hasher_tuple>::value);
+
+    return detail::hash_cval<
+      key_tuple,key_hasher_tuple
+    >::hash(x,key_hash_functions());
+  }
+
+#if !defined(BOOST_NO_CXX11_HDR_TUPLE)&&\
+    !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+  template<typename... Values>
+  std::size_t operator()(const std::tuple<Values...>& x)const
+  {
+    typedef std::tuple<Values...>                key_tuple;
+    typedef typename detail::cons_stdtuple_ctor<
+      key_tuple>::result_type                    cons_key_tuple;
+
+    BOOST_STATIC_ASSERT(
+      std::tuple_size<key_tuple>::value==
+      static_cast<std::size_t>(tuples::length<key_hasher_tuple>::value));
+
+    return detail::hash_cval<
+      cons_key_tuple,key_hasher_tuple
+    >::hash(detail::make_cons_stdtuple(x),key_hash_functions());
+  }
+#endif
+};
+
+/* Instantiations of the former functors with "natural" basic components:
+ * composite_key_result_equal_to uses std::equal_to of the values.
+ * composite_key_result_less     uses std::less.
+ * composite_key_result_greater  uses std::greater.
+ * composite_key_result_hash     uses boost::hash.
+ */
+
+#define BOOST_MULTI_INDEX_CK_RESULT_EQUAL_TO_SUPER                           \
+composite_key_equal_to<                                                      \
+    BOOST_MULTI_INDEX_CK_ENUM(                                               \
+      BOOST_MULTI_INDEX_CK_APPLY_METAFUNCTION_N,                             \
+      /* the argument is a PP list */                                        \
+      (detail::nth_composite_key_equal_to,                                   \
+        (BOOST_DEDUCED_TYPENAME CompositeKeyResult::composite_key_type,      \
+          BOOST_PP_NIL)))                                                    \
+  >
+
+template<typename CompositeKeyResult>
+struct composite_key_result_equal_to:
+BOOST_MULTI_INDEX_PRIVATE_IF_USING_DECL_FOR_TEMPL_FUNCTIONS
+BOOST_MULTI_INDEX_CK_RESULT_EQUAL_TO_SUPER
+{
+private:
+  typedef BOOST_MULTI_INDEX_CK_RESULT_EQUAL_TO_SUPER super;
+
+public:
+  typedef CompositeKeyResult  first_argument_type;
+  typedef first_argument_type second_argument_type;
+  typedef bool                result_type;
+
+  using super::operator();
+};
+
+#define BOOST_MULTI_INDEX_CK_RESULT_LESS_SUPER                               \
+composite_key_compare<                                                       \
+    BOOST_MULTI_INDEX_CK_ENUM(                                               \
+      BOOST_MULTI_INDEX_CK_APPLY_METAFUNCTION_N,                             \
+      /* the argument is a PP list */                                        \
+      (detail::nth_composite_key_less,                                       \
+        (BOOST_DEDUCED_TYPENAME CompositeKeyResult::composite_key_type,      \
+          BOOST_PP_NIL)))                                                    \
+  >
+
+template<typename CompositeKeyResult>
+struct composite_key_result_less:
+BOOST_MULTI_INDEX_PRIVATE_IF_USING_DECL_FOR_TEMPL_FUNCTIONS
+BOOST_MULTI_INDEX_CK_RESULT_LESS_SUPER
+{
+private:
+  typedef BOOST_MULTI_INDEX_CK_RESULT_LESS_SUPER super;
+
+public:
+  typedef CompositeKeyResult  first_argument_type;
+  typedef first_argument_type second_argument_type;
+  typedef bool                result_type;
+
+  using super::operator();
+};
+
+#define BOOST_MULTI_INDEX_CK_RESULT_GREATER_SUPER                            \
+composite_key_compare<                                                       \
+    BOOST_MULTI_INDEX_CK_ENUM(                                               \
+      BOOST_MULTI_INDEX_CK_APPLY_METAFUNCTION_N,                             \
+      /* the argument is a PP list */                                        \
+      (detail::nth_composite_key_greater,                                    \
+        (BOOST_DEDUCED_TYPENAME CompositeKeyResult::composite_key_type,      \
+          BOOST_PP_NIL)))                                                    \
+  >
+
+template<typename CompositeKeyResult>
+struct composite_key_result_greater:
+BOOST_MULTI_INDEX_PRIVATE_IF_USING_DECL_FOR_TEMPL_FUNCTIONS
+BOOST_MULTI_INDEX_CK_RESULT_GREATER_SUPER
+{
+private:
+  typedef BOOST_MULTI_INDEX_CK_RESULT_GREATER_SUPER super;
+
+public:
+  typedef CompositeKeyResult  first_argument_type;
+  typedef first_argument_type second_argument_type;
+  typedef bool                result_type;
+
+  using super::operator();
+};
+
+#define BOOST_MULTI_INDEX_CK_RESULT_HASH_SUPER                               \
+composite_key_hash<                                                          \
+    BOOST_MULTI_INDEX_CK_ENUM(                                               \
+      BOOST_MULTI_INDEX_CK_APPLY_METAFUNCTION_N,                             \
+      /* the argument is a PP list */                                        \
+      (detail::nth_composite_key_hash,                                       \
+        (BOOST_DEDUCED_TYPENAME CompositeKeyResult::composite_key_type,      \
+          BOOST_PP_NIL)))                                                    \
+  >
+
+template<typename CompositeKeyResult>
+struct composite_key_result_hash:
+BOOST_MULTI_INDEX_PRIVATE_IF_USING_DECL_FOR_TEMPL_FUNCTIONS
+BOOST_MULTI_INDEX_CK_RESULT_HASH_SUPER
+{
+private:
+  typedef BOOST_MULTI_INDEX_CK_RESULT_HASH_SUPER super;
+
+public:
+  typedef CompositeKeyResult argument_type;
+  typedef std::size_t        result_type;
+
+  using super::operator();
+};
+
+} /* namespace multi_index */
+
+} /* namespace boost */
+
+/* Specializations of std::equal_to, std::less, std::greater and boost::hash
+ * for composite_key_results enabling interoperation with tuples of values.
+ */
+
+namespace std{
+
+template<typename CompositeKey>
+struct equal_to<boost::multi_index::composite_key_result<CompositeKey> >:
+  boost::multi_index::composite_key_result_equal_to<
+    boost::multi_index::composite_key_result<CompositeKey>
+  >
+{
+};
+
+template<typename CompositeKey>
+struct less<boost::multi_index::composite_key_result<CompositeKey> >:
+  boost::multi_index::composite_key_result_less<
+    boost::multi_index::composite_key_result<CompositeKey>
+  >
+{
+};
+
+template<typename CompositeKey>
+struct greater<boost::multi_index::composite_key_result<CompositeKey> >:
+  boost::multi_index::composite_key_result_greater<
+    boost::multi_index::composite_key_result<CompositeKey>
+  >
+{
+};
+
+} /* namespace std */
+
+namespace boost{
+
+template<typename CompositeKey>
+struct hash<boost::multi_index::composite_key_result<CompositeKey> >:
+  boost::multi_index::composite_key_result_hash<
+    boost::multi_index::composite_key_result<CompositeKey>
+  >
+{
+};
+
+} /* namespace boost */
+
+#undef BOOST_MULTI_INDEX_CK_RESULT_HASH_SUPER
+#undef BOOST_MULTI_INDEX_CK_RESULT_GREATER_SUPER
+#undef BOOST_MULTI_INDEX_CK_RESULT_LESS_SUPER
+#undef BOOST_MULTI_INDEX_CK_RESULT_EQUAL_TO_SUPER
+#undef BOOST_MULTI_INDEX_CK_COMPLETE_COMP_OPS
+#undef BOOST_MULTI_INDEX_CK_IDENTITY_ENUM_MACRO
+#undef BOOST_MULTI_INDEX_CK_NTH_COMPOSITE_KEY_FUNCTOR
+#undef BOOST_MULTI_INDEX_CK_APPLY_METAFUNCTION_N
+#undef BOOST_MULTI_INDEX_CK_CTOR_ARG
+#undef BOOST_MULTI_INDEX_CK_TEMPLATE_PARM
+#undef BOOST_MULTI_INDEX_CK_ENUM_PARAMS
+#undef BOOST_MULTI_INDEX_CK_ENUM
+#undef BOOST_MULTI_INDEX_COMPOSITE_KEY_SIZE
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/access_specifier.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/access_specifier.hpp
new file mode 100644
index 00000000000..f3346e836d4
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/access_specifier.hpp
@@ -0,0 +1,54 @@
+/* Copyright 2003-2013 Joaquin M Lopez Munoz.
+ * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
+ */
+
+#ifndef BOOST_MULTI_INDEX_DETAIL_ACCESS_SPECIFIER_HPP
+#define BOOST_MULTI_INDEX_DETAIL_ACCESS_SPECIFIER_HPP
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
+
+/* In those compilers that do not accept the member template friend syntax,
+ * some protected and private sections might need to be specified as
+ * public.
+ */
+
+#if defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
+#define BOOST_MULTI_INDEX_PROTECTED_IF_MEMBER_TEMPLATE_FRIENDS public
+#define BOOST_MULTI_INDEX_PRIVATE_IF_MEMBER_TEMPLATE_FRIENDS public
+#else
+#define BOOST_MULTI_INDEX_PROTECTED_IF_MEMBER_TEMPLATE_FRIENDS protected
+#define BOOST_MULTI_INDEX_PRIVATE_IF_MEMBER_TEMPLATE_FRIENDS private
+#endif
+
+/* GCC does not correctly support in-class using declarations for template
+ * functions. See http://gcc.gnu.org/bugzilla/show_bug.cgi?id=9810
+ * MSVC 7.1/8.0 seem to have a similar problem, though the conditions in
+ * which the error happens are not that simple. I have yet to isolate this
+ * into a snippet suitable for bug reporting.
+ * Sun Studio also has this problem, which might be related, from the
+ * information gathered at Sun forums, with a known issue notified at the
+ * internal bug report 6421933. The bug is present up to Studio Express 2,
+ * the latest preview version of the future Sun Studio 12. As of this writing
+ * (October 2006) it is not known whether a fix will finally make it into the
+ * official Sun Studio 12.
+ */
+
+#if BOOST_WORKAROUND(__GNUC__,==3)&&(__GNUC_MINOR__<4)||\
+    BOOST_WORKAROUND(BOOST_MSVC,==1310)||\
+    BOOST_WORKAROUND(BOOST_MSVC,==1400)||\
+    BOOST_WORKAROUND(__SUNPRO_CC,BOOST_TESTED_AT(0x590))
+#define BOOST_MULTI_INDEX_PRIVATE_IF_USING_DECL_FOR_TEMPL_FUNCTIONS public
+#else
+#define BOOST_MULTI_INDEX_PRIVATE_IF_USING_DECL_FOR_TEMPL_FUNCTIONS private
+#endif
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/adl_swap.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/adl_swap.hpp
new file mode 100644
index 00000000000..02b06442290
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/adl_swap.hpp
@@ -0,0 +1,44 @@
+/* Copyright 2003-2013 Joaquin M Lopez Munoz.
+ * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
+ */
+
+#ifndef BOOST_MULTI_INDEX_DETAIL_ADL_SWAP_HPP
+#define BOOST_MULTI_INDEX_DETAIL_ADL_SWAP_HPP
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
+#include <algorithm>
+
+namespace boost{
+
+namespace multi_index{
+
+namespace detail{
+
+template<typename T>
+void adl_swap(T& x,T& y)
+{
+
+#if !defined(BOOST_FUNCTION_SCOPE_USING_DECLARATION_BREAKS_ADL)
+  using std::swap;
+  swap(x,y);
+#else
+  std::swap(x,y);
+#endif
+
+}
+
+} /* namespace multi_index::detail */
+
+} /* namespace multi_index */
+
+} /* namespace boost */
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/archive_constructed.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/archive_constructed.hpp
new file mode 100644
index 00000000000..0a7a26e0d4e
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/archive_constructed.hpp
@@ -0,0 +1,83 @@
+/* Copyright 2003-2016 Joaquin M Lopez Munoz.
+ * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
+ */
+
+#ifndef BOOST_MULTI_INDEX_DETAIL_ARCHIVE_CONSTRUCTED_HPP
+#define BOOST_MULTI_INDEX_DETAIL_ARCHIVE_CONSTRUCTED_HPP
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
+#include <boost/detail/no_exceptions_support.hpp>
+#include <boost/noncopyable.hpp>
+#include <boost/serialization/serialization.hpp>
+#include <boost/type_traits/aligned_storage.hpp>
+#include <boost/type_traits/alignment_of.hpp> 
+
+namespace boost{
+
+namespace multi_index{
+
+namespace detail{
+
+/* constructs a stack-based object from a serialization archive */
+
+template<typename T>
+struct archive_constructed:private noncopyable
+{
+  template<class Archive>
+  archive_constructed(Archive& ar,const unsigned int version)
+  {
+    serialization::load_construct_data_adl(ar,&get(),version);
+    BOOST_TRY{
+      ar>>get();
+    }
+    BOOST_CATCH(...){
+      (&get())->~T();
+      BOOST_RETHROW;
+    }
+    BOOST_CATCH_END
+  }
+
+  template<class Archive>
+  archive_constructed(const char* name,Archive& ar,const unsigned int version)
+  {
+    serialization::load_construct_data_adl(ar,&get(),version);
+    BOOST_TRY{
+      ar>>serialization::make_nvp(name,get());
+    }
+    BOOST_CATCH(...){
+      (&get())->~T();
+      BOOST_RETHROW;
+    }
+    BOOST_CATCH_END
+  }
+
+  ~archive_constructed()
+  {
+    (&get())->~T();
+  }
+
+#include <boost/multi_index/detail/ignore_wstrict_aliasing.hpp>
+
+  T& get(){return *reinterpret_cast<T*>(&space);}
+
+#include <boost/multi_index/detail/restore_wstrict_aliasing.hpp>
+
+private:
+  typename aligned_storage<sizeof(T),alignment_of<T>::value>::type space;
+};
+
+} /* namespace multi_index::detail */
+
+} /* namespace multi_index */
+
+} /* namespace boost */
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/auto_space.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/auto_space.hpp
new file mode 100644
index 00000000000..9d78c3a363f
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/auto_space.hpp
@@ -0,0 +1,91 @@
+/* Copyright 2003-2013 Joaquin M Lopez Munoz.
+ * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
+ */
+
+#ifndef BOOST_MULTI_INDEX_DETAIL_AUTO_SPACE_HPP
+#define BOOST_MULTI_INDEX_DETAIL_AUTO_SPACE_HPP
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
+#include <algorithm>
+#include <boost/detail/allocator_utilities.hpp>
+#include <boost/multi_index/detail/adl_swap.hpp>
+#include <boost/noncopyable.hpp>
+#include <memory>
+
+namespace boost{
+
+namespace multi_index{
+
+namespace detail{
+
+/* auto_space provides uninitialized space suitably to store
+ * a given number of elements of a given type.
+ */
+
+/* NB: it is not clear whether using an allocator to handle
+ * zero-sized arrays of elements is conformant or not. GCC 3.3.1
+ * and prior fail here, other stdlibs handle the issue gracefully.
+ * To be on the safe side, the case n==0 is given special treatment.
+ * References:
+ *   GCC Bugzilla, "standard allocator crashes when deallocating segment
+ *    "of zero length", http://gcc.gnu.org/bugzilla/show_bug.cgi?id=14176
+ *   C++ Standard Library Defect Report List (Revision 28), issue 199
+ *     "What does allocate(0) return?",
+ *     http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#199
+ */
+
+template<typename T,typename Allocator=std::allocator<T> >
+struct auto_space:private noncopyable
+{
+  typedef typename boost::detail::allocator::rebind_to<
+    Allocator,T
+  >::type::pointer pointer;
+
+  explicit auto_space(const Allocator& al=Allocator(),std::size_t n=1):
+  al_(al),n_(n),data_(n_?al_.allocate(n_):pointer(0))
+  {}
+
+  ~auto_space()
+  {
+    if(n_)al_.deallocate(data_,n_);
+  }
+
+  Allocator get_allocator()const{return al_;}
+
+  pointer data()const{return data_;}
+
+  void swap(auto_space& x)
+  {
+    if(al_!=x.al_)adl_swap(al_,x.al_);
+    std::swap(n_,x.n_);
+    std::swap(data_,x.data_);
+  }
+    
+private:
+  typename boost::detail::allocator::rebind_to<
+    Allocator,T>::type                          al_;
+  std::size_t                                   n_;
+  pointer                                       data_;
+};
+
+template<typename T,typename Allocator>
+void swap(auto_space<T,Allocator>& x,auto_space<T,Allocator>& y)
+{
+  x.swap(y);
+}
+
+} /* namespace multi_index::detail */
+
+} /* namespace multi_index */
+
+} /* namespace boost */
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/base_type.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/base_type.hpp
new file mode 100644
index 00000000000..8c9b62b716a
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/base_type.hpp
@@ -0,0 +1,74 @@
+/* Copyright 2003-2013 Joaquin M Lopez Munoz.
+ * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
+ */
+
+#ifndef BOOST_MULTI_INDEX_DETAIL_BASE_TYPE_HPP
+#define BOOST_MULTI_INDEX_DETAIL_BASE_TYPE_HPP
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
+#include <boost/detail/workaround.hpp>
+#include <boost/mpl/at.hpp>
+#include <boost/mpl/apply.hpp>
+#include <boost/mpl/size.hpp>
+#include <boost/multi_index/detail/index_base.hpp>
+#include <boost/multi_index/detail/is_index_list.hpp>
+#include <boost/static_assert.hpp>
+
+namespace boost{
+
+namespace multi_index{
+
+namespace detail{
+
+/* MPL machinery to construct a linear hierarchy of indices out of
+ * a index list.
+ */
+
+struct index_applier
+{
+  template<typename IndexSpecifierMeta,typename SuperMeta>
+  struct apply
+  {
+    typedef typename IndexSpecifierMeta::type            index_specifier;
+    typedef typename index_specifier::
+      BOOST_NESTED_TEMPLATE index_class<SuperMeta>::type type;
+  }; 
+};
+
+template<int N,typename Value,typename IndexSpecifierList,typename Allocator>
+struct nth_layer
+{
+  BOOST_STATIC_CONSTANT(int,length=mpl::size<IndexSpecifierList>::value);
+
+  typedef typename  mpl::eval_if_c<
+    N==length,
+    mpl::identity<index_base<Value,IndexSpecifierList,Allocator> >,
+    mpl::apply2<
+      index_applier,
+      mpl::at_c<IndexSpecifierList,N>,
+      nth_layer<N+1,Value,IndexSpecifierList,Allocator>
+    >
+  >::type type;
+};
+
+template<typename Value,typename IndexSpecifierList,typename Allocator>
+struct multi_index_base_type:nth_layer<0,Value,IndexSpecifierList,Allocator>
+{
+  BOOST_STATIC_ASSERT(detail::is_index_list<IndexSpecifierList>::value);
+};
+
+} /* namespace multi_index::detail */
+
+} /* namespace multi_index */
+
+} /* namespace boost */
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/bidir_node_iterator.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/bidir_node_iterator.hpp
new file mode 100644
index 00000000000..9be5ec84b43
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/bidir_node_iterator.hpp
@@ -0,0 +1,114 @@
+/* Copyright 2003-2014 Joaquin M Lopez Munoz.
+ * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
+ */
+
+#ifndef BOOST_MULTI_INDEX_DETAIL_BIDIR_NODE_ITERATOR_HPP
+#define BOOST_MULTI_INDEX_DETAIL_BIDIR_NODE_ITERATOR_HPP
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
+#include <boost/operators.hpp>
+
+#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
+#include <boost/serialization/nvp.hpp>
+#include <boost/serialization/split_member.hpp>
+#endif
+
+namespace boost{
+
+namespace multi_index{
+
+namespace detail{
+
+/* Iterator class for node-based indices with bidirectional
+ * iterators (ordered and sequenced indices.)
+ */
+
+template<typename Node>
+class bidir_node_iterator:
+  public bidirectional_iterator_helper<
+    bidir_node_iterator<Node>,
+    typename Node::value_type,
+    std::ptrdiff_t,
+    const typename Node::value_type*,
+    const typename Node::value_type&>
+{
+public:
+  /* coverity[uninit_ctor]: suppress warning */
+  bidir_node_iterator(){}
+  explicit bidir_node_iterator(Node* node_):node(node_){}
+
+  const typename Node::value_type& operator*()const
+  {
+    return node->value();
+  }
+
+  bidir_node_iterator& operator++()
+  {
+    Node::increment(node);
+    return *this;
+  }
+
+  bidir_node_iterator& operator--()
+  {
+    Node::decrement(node);
+    return *this;
+  }
+
+#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
+  /* Serialization. As for why the following is public,
+   * see explanation in safe_mode_iterator notes in safe_mode.hpp.
+   */
+
+  BOOST_SERIALIZATION_SPLIT_MEMBER()
+
+  typedef typename Node::base_type node_base_type;
+
+  template<class Archive>
+  void save(Archive& ar,const unsigned int)const
+  {
+    node_base_type* bnode=node;
+    ar<<serialization::make_nvp("pointer",bnode);
+  }
+
+  template<class Archive>
+  void load(Archive& ar,const unsigned int)
+  {
+    node_base_type* bnode;
+    ar>>serialization::make_nvp("pointer",bnode);
+    node=static_cast<Node*>(bnode);
+  }
+#endif
+
+  /* get_node is not to be used by the user */
+
+  typedef Node node_type;
+
+  Node* get_node()const{return node;}
+
+private:
+  Node* node;
+};
+
+template<typename Node>
+bool operator==(
+  const bidir_node_iterator<Node>& x,
+  const bidir_node_iterator<Node>& y)
+{
+  return x.get_node()==y.get_node();
+}
+
+} /* namespace multi_index::detail */
+
+} /* namespace multi_index */
+
+} /* namespace boost */
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/bucket_array.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/bucket_array.hpp
new file mode 100644
index 00000000000..d9fa434d9a9
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/bucket_array.hpp
@@ -0,0 +1,243 @@
+/* Copyright 2003-2015 Joaquin M Lopez Munoz.
+ * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
+ */
+
+#ifndef BOOST_MULTI_INDEX_DETAIL_BUCKET_ARRAY_HPP
+#define BOOST_MULTI_INDEX_DETAIL_BUCKET_ARRAY_HPP
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
+#include <algorithm>
+#include <boost/multi_index/detail/auto_space.hpp>
+#include <boost/multi_index/detail/hash_index_node.hpp>
+#include <boost/noncopyable.hpp>
+#include <boost/preprocessor/repetition/repeat.hpp>
+#include <boost/preprocessor/seq/elem.hpp>
+#include <boost/preprocessor/seq/enum.hpp>
+#include <boost/preprocessor/seq/size.hpp>
+#include <cstddef>
+#include <limits.h>
+
+#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
+#include <boost/archive/archive_exception.hpp>
+#include <boost/serialization/access.hpp>
+#include <boost/throw_exception.hpp> 
+#endif
+
+namespace boost{
+
+namespace multi_index{
+
+namespace detail{
+
+/* bucket structure for use by hashed indices */
+
+#define BOOST_MULTI_INDEX_BA_SIZES_32BIT                                  \
+(53ul)(97ul)(193ul)(389ul)(769ul)                                         \
+(1543ul)(3079ul)(6151ul)(12289ul)(24593ul)                                \
+(49157ul)(98317ul)(196613ul)(393241ul)(786433ul)                          \
+(1572869ul)(3145739ul)(6291469ul)(12582917ul)(25165843ul)                 \
+(50331653ul)(100663319ul)(201326611ul)(402653189ul)(805306457ul)          \
+(1610612741ul)(3221225473ul)
+
+#if ((((ULONG_MAX>>16)>>16)>>16)>>15)==0 /* unsigned long less than 64 bits */
+#define BOOST_MULTI_INDEX_BA_SIZES                                         \
+BOOST_MULTI_INDEX_BA_SIZES_32BIT                                           \
+(4294967291ul)
+#else
+  /* obtained with aid from
+   *   http://javaboutique.internet.com/prime_numb/
+   *   http://www.rsok.com/~jrm/next_ten_primes.html
+   * and verified with
+   *   http://www.alpertron.com.ar/ECM.HTM
+   */
+
+#define BOOST_MULTI_INDEX_BA_SIZES                                         \
+BOOST_MULTI_INDEX_BA_SIZES_32BIT                                           \
+(6442450939ul)(12884901893ul)(25769803751ul)(51539607551ul)                \
+(103079215111ul)(206158430209ul)(412316860441ul)(824633720831ul)           \
+(1649267441651ul)(3298534883309ul)(6597069766657ul)(13194139533299ul)      \
+(26388279066623ul)(52776558133303ul)(105553116266489ul)(211106232532969ul) \
+(422212465066001ul)(844424930131963ul)(1688849860263953ul)                 \
+(3377699720527861ul)(6755399441055731ul)(13510798882111483ul)              \
+(27021597764222939ul)(54043195528445957ul)(108086391056891903ul)           \
+(216172782113783843ul)(432345564227567621ul)(864691128455135207ul)         \
+(1729382256910270481ul)(3458764513820540933ul)(6917529027641081903ul)      \
+(13835058055282163729ul)(18446744073709551557ul)
+#endif
+
+template<bool _=true> /* templatized to have in-header static var defs */
+class bucket_array_base:private noncopyable
+{
+protected:
+  static const std::size_t sizes[
+    BOOST_PP_SEQ_SIZE(BOOST_MULTI_INDEX_BA_SIZES)];
+
+  static std::size_t size_index(std::size_t n)
+  {
+    const std::size_t *bound=std::lower_bound(sizes,sizes+sizes_length,n);
+    if(bound==sizes+sizes_length)--bound;
+    return bound-sizes;
+  }
+
+#define BOOST_MULTI_INDEX_BA_POSITION_CASE(z,n,_)                    \
+  case n:return hash%BOOST_PP_SEQ_ELEM(n,BOOST_MULTI_INDEX_BA_SIZES);
+
+  static std::size_t position(std::size_t hash,std::size_t size_index_)
+  {
+    /* Accelerate hash%sizes[size_index_] by replacing with a switch on
+     * hash%Ci expressions, each Ci a compile-time constant, which the
+     * compiler can implement without using integer division.
+     */
+
+    switch(size_index_){
+      default: /* never used */
+      BOOST_PP_REPEAT(
+        BOOST_PP_SEQ_SIZE(BOOST_MULTI_INDEX_BA_SIZES),
+        BOOST_MULTI_INDEX_BA_POSITION_CASE,~)
+    }
+  }
+
+private:
+  static const std::size_t sizes_length;
+};
+
+template<bool _>
+const std::size_t bucket_array_base<_>::sizes[]={
+  BOOST_PP_SEQ_ENUM(BOOST_MULTI_INDEX_BA_SIZES)
+};
+
+template<bool _>
+const std::size_t bucket_array_base<_>::sizes_length=
+  sizeof(bucket_array_base<_>::sizes)/
+  sizeof(bucket_array_base<_>::sizes[0]);
+
+#undef BOOST_MULTI_INDEX_BA_POSITION_CASE
+#undef BOOST_MULTI_INDEX_BA_SIZES
+#undef BOOST_MULTI_INDEX_BA_SIZES_32BIT
+
+template<typename Allocator>
+class bucket_array:bucket_array_base<>
+{
+  typedef bucket_array_base<>                        super;
+  typedef hashed_index_base_node_impl<
+    typename boost::detail::allocator::rebind_to<
+      Allocator,
+      char
+    >::type
+  >                                                  base_node_impl_type;
+
+public:
+  typedef typename base_node_impl_type::base_pointer base_pointer;
+  typedef typename base_node_impl_type::pointer      pointer;
+
+  bucket_array(const Allocator& al,pointer end_,std::size_t size_):
+    size_index_(super::size_index(size_)),
+    spc(al,super::sizes[size_index_]+1)
+  {
+    clear(end_);
+  }
+
+  std::size_t size()const
+  {
+    return super::sizes[size_index_];
+  }
+
+  std::size_t position(std::size_t hash)const
+  {
+    return super::position(hash,size_index_);
+  }
+
+  base_pointer begin()const{return buckets();}
+  base_pointer end()const{return buckets()+size();}
+  base_pointer at(std::size_t n)const{return buckets()+n;}
+
+  void clear(pointer end_)
+  {
+    for(base_pointer x=begin(),y=end();x!=y;++x)x->prior()=pointer(0);
+    end()->prior()=end_->prior()=end_;
+    end_->next()=end();
+ }
+
+  void swap(bucket_array& x)
+  {
+    std::swap(size_index_,x.size_index_);
+    spc.swap(x.spc);
+  }
+
+private:
+  std::size_t                               size_index_;
+  auto_space<base_node_impl_type,Allocator> spc;
+
+  base_pointer buckets()const
+  {
+    return spc.data();
+  }
+
+#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
+  friend class boost::serialization::access;
+  
+  /* bucket_arrays do not emit any kind of serialization info. They are
+   * fed to Boost.Serialization as hashed index iterators need to track
+   * them during serialization.
+   */
+
+  template<class Archive>
+  void serialize(Archive&,const unsigned int)
+  {
+  }
+#endif
+};
+
+template<typename Allocator>
+void swap(bucket_array<Allocator>& x,bucket_array<Allocator>& y)
+{
+  x.swap(y);
+}
+
+} /* namespace multi_index::detail */
+
+} /* namespace multi_index */
+
+#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
+/* bucket_arrays never get constructed directly by Boost.Serialization,
+ * as archives are always fed pointers to previously existent
+ * arrays. So, if this is called it means we are dealing with a
+ * somehow invalid archive.
+ */
+
+#if defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)
+namespace serialization{
+#else
+namespace multi_index{
+namespace detail{
+#endif
+
+template<class Archive,typename Allocator>
+inline void load_construct_data(
+  Archive&,boost::multi_index::detail::bucket_array<Allocator>*,
+  const unsigned int)
+{
+  throw_exception(
+    archive::archive_exception(archive::archive_exception::other_exception));
+}
+
+#if defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)
+} /* namespace serialization */
+#else
+} /* namespace multi_index::detail */
+} /* namespace multi_index */
+#endif
+
+#endif
+
+} /* namespace boost */
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/cons_stdtuple.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/cons_stdtuple.hpp
new file mode 100644
index 00000000000..855c5e06aa9
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/cons_stdtuple.hpp
@@ -0,0 +1,93 @@
+/* Copyright 2003-2014 Joaquin M Lopez Munoz.
+ * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
+ */
+
+#ifndef BOOST_MULTI_INDEX_DETAIL_CONS_STDTUPLE_HPP
+#define BOOST_MULTI_INDEX_DETAIL_CONS_STDTUPLE_HPP
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
+#include <boost/mpl/if.hpp>
+#include <boost/tuple/tuple.hpp>
+#include <tuple>
+
+namespace boost{
+
+namespace multi_index{
+
+namespace detail{
+
+/* std::tuple wrapper providing the cons-based interface of boost::tuple for
+ * composite_key interoperability.
+ */
+
+template<typename StdTuple,std::size_t N>
+struct cons_stdtuple;
+
+struct cons_stdtuple_ctor_terminal
+{
+  typedef boost::tuples::null_type result_type;
+
+  template<typename StdTuple>
+  static result_type create(const StdTuple&)
+  {
+    return boost::tuples::null_type();
+  }
+};
+
+template<typename StdTuple,std::size_t N>
+struct cons_stdtuple_ctor_normal
+{
+  typedef cons_stdtuple<StdTuple,N> result_type;
+
+  static result_type create(const StdTuple& t)
+  {
+    return result_type(t);
+  }
+};
+
+template<typename StdTuple,std::size_t N=0>
+struct cons_stdtuple_ctor:
+  boost::mpl::if_c<
+    N<std::tuple_size<StdTuple>::value,
+    cons_stdtuple_ctor_normal<StdTuple,N>,
+    cons_stdtuple_ctor_terminal
+  >::type
+{};
+
+template<typename StdTuple,std::size_t N>
+struct cons_stdtuple
+{
+  typedef typename std::tuple_element<N,StdTuple>::type head_type;
+  typedef cons_stdtuple_ctor<StdTuple,N+1>              tail_ctor;
+  typedef typename tail_ctor::result_type               tail_type;
+  
+  cons_stdtuple(const StdTuple& t_):t(t_){}
+
+  const head_type& get_head()const{return std::get<N>(t);}
+  tail_type get_tail()const{return tail_ctor::create(t);}
+    
+  const StdTuple& t;
+};
+
+template<typename StdTuple>
+typename cons_stdtuple_ctor<StdTuple>::result_type
+make_cons_stdtuple(const StdTuple& t)
+{
+  return cons_stdtuple_ctor<StdTuple>::create(t);
+}
+
+} /* namespace multi_index::detail */
+
+} /* namespace multi_index */
+
+} /* namespace boost */
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/converter.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/converter.hpp
new file mode 100644
index 00000000000..3e04a3e8295
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/converter.hpp
@@ -0,0 +1,52 @@
+/* Copyright 2003-2013 Joaquin M Lopez Munoz.
+ * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
+ */
+
+#ifndef BOOST_MULTI_INDEX_DETAIL_CONVERTER_HPP
+#define BOOST_MULTI_INDEX_DETAIL_CONVERTER_HPP
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+namespace boost{
+
+namespace multi_index{
+
+namespace detail{
+
+/* converter offers means to access indices of a given multi_index_container
+ * and for convertibilty between index iterators, so providing a
+ * localized access point for get() and project() functions.
+ */
+
+template<typename MultiIndexContainer,typename Index>
+struct converter
+{
+  static const Index& index(const MultiIndexContainer& x){return x;}
+  static Index&       index(MultiIndexContainer& x){return x;}
+
+  static typename Index::const_iterator const_iterator(
+    const MultiIndexContainer& x,typename MultiIndexContainer::node_type* node)
+  {
+    return x.Index::make_iterator(node);
+  }
+
+  static typename Index::iterator iterator(
+    MultiIndexContainer& x,typename MultiIndexContainer::node_type* node)
+  {
+    return x.Index::make_iterator(node);
+  }
+};
+
+} /* namespace multi_index::detail */
+
+} /* namespace multi_index */
+
+} /* namespace boost */
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/copy_map.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/copy_map.hpp
new file mode 100644
index 00000000000..9a34b259cf3
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/copy_map.hpp
@@ -0,0 +1,142 @@
+/* Copyright 2003-2015 Joaquin M Lopez Munoz.
+ * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
+ */
+
+#ifndef BOOST_MULTI_INDEX_DETAIL_COPY_MAP_HPP
+#define BOOST_MULTI_INDEX_DETAIL_COPY_MAP_HPP
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
+#include <algorithm>
+#include <boost/detail/no_exceptions_support.hpp>
+#include <boost/multi_index/detail/auto_space.hpp>
+#include <boost/multi_index/detail/raw_ptr.hpp>
+#include <boost/noncopyable.hpp>
+#include <cstddef>
+#include <functional>
+
+namespace boost{
+
+namespace multi_index{
+
+namespace detail{
+
+/* copy_map is used as an auxiliary structure during copy_() operations.
+ * When a container with n nodes is replicated, node_map holds the pairings
+ * between original and copied nodes, and provides a fast way to find a
+ * copied node from an original one.
+ * The semantics of the class are not simple, and no attempt has been made
+ * to enforce it: multi_index_container handles it right. On the other hand,
+ * the const interface, which is the one provided to index implementations,
+ * only allows for:
+ *   - Enumeration of pairs of (original,copied) nodes (excluding the headers),
+ *   - fast retrieval of copied nodes (including the headers.)
+ */
+
+template <typename Node>
+struct copy_map_entry
+{
+  copy_map_entry(Node* f,Node* s):first(f),second(s){}
+
+  Node* first;
+  Node* second;
+
+  bool operator<(const copy_map_entry<Node>& x)const
+  {
+    return std::less<Node*>()(first,x.first);
+  }
+};
+
+template <typename Node,typename Allocator>
+class copy_map:private noncopyable
+{
+public:
+  typedef const copy_map_entry<Node>* const_iterator;
+
+  copy_map(
+    const Allocator& al,std::size_t size,Node* header_org,Node* header_cpy):
+    al_(al),size_(size),spc(al_,size_),n(0),
+    header_org_(header_org),header_cpy_(header_cpy),released(false)
+  {}
+
+  ~copy_map()
+  {
+    if(!released){
+      for(std::size_t i=0;i<n;++i){
+        boost::detail::allocator::destroy(&(spc.data()+i)->second->value());
+        deallocate((spc.data()+i)->second);
+      }
+    }
+  }
+
+  const_iterator begin()const{return raw_ptr<const_iterator>(spc.data());}
+  const_iterator end()const{return raw_ptr<const_iterator>(spc.data()+n);}
+
+  void clone(Node* node)
+  {
+    (spc.data()+n)->first=node;
+    (spc.data()+n)->second=raw_ptr<Node*>(al_.allocate(1));
+    BOOST_TRY{
+      boost::detail::allocator::construct(
+        &(spc.data()+n)->second->value(),node->value());
+    }
+    BOOST_CATCH(...){
+      deallocate((spc.data()+n)->second);
+      BOOST_RETHROW;
+    }
+    BOOST_CATCH_END
+    ++n;
+
+    if(n==size_){
+      std::sort(
+        raw_ptr<copy_map_entry<Node>*>(spc.data()),
+        raw_ptr<copy_map_entry<Node>*>(spc.data())+size_);
+    }
+  }
+
+  Node* find(Node* node)const
+  {
+    if(node==header_org_)return header_cpy_;
+    return std::lower_bound(
+      begin(),end(),copy_map_entry<Node>(node,0))->second;
+  }
+
+  void release()
+  {
+    released=true;
+  }
+
+private:
+  typedef typename boost::detail::allocator::rebind_to<
+    Allocator,Node
+  >::type                                               allocator_type;
+  typedef typename allocator_type::pointer              allocator_pointer;
+
+  allocator_type                                        al_;
+  std::size_t                                           size_;
+  auto_space<copy_map_entry<Node>,Allocator>            spc;
+  std::size_t                                           n;
+  Node*                                                 header_org_;
+  Node*                                                 header_cpy_;
+  bool                                                  released;
+
+  void deallocate(Node* node)
+  {
+    al_.deallocate(static_cast<allocator_pointer>(node),1);
+  }
+};
+
+} /* namespace multi_index::detail */
+
+} /* namespace multi_index */
+
+} /* namespace boost */
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/do_not_copy_elements_tag.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/do_not_copy_elements_tag.hpp
new file mode 100644
index 00000000000..f0fa7304253
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/do_not_copy_elements_tag.hpp
@@ -0,0 +1,34 @@
+/* Copyright 2003-2013 Joaquin M Lopez Munoz.
+ * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
+ */
+
+#ifndef BOOST_MULTI_INDEX_DETAIL_DO_NOT_COPY_ELEMENTS_TAG_HPP
+#define BOOST_MULTI_INDEX_DETAIL_DO_NOT_COPY_ELEMENTS_TAG_HPP
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+namespace boost{
+
+namespace multi_index{
+
+namespace detail{
+
+/* Used to mark a special ctor variant that copies the internal objects of
+ * a container but not its elements.
+ */
+
+struct do_not_copy_elements_tag{};
+
+} /* namespace multi_index::detail */
+
+} /* namespace multi_index */
+
+} /* namespace boost */
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/duplicates_iterator.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/duplicates_iterator.hpp
new file mode 100644
index 00000000000..cbebf264045
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/duplicates_iterator.hpp
@@ -0,0 +1,120 @@
+/* Copyright 2003-2013 Joaquin M Lopez Munoz.
+ * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
+ */
+
+#ifndef BOOST_MULTI_INDEX_DETAIL_DUPLICATES_ITERATOR_HPP
+#define BOOST_MULTI_INDEX_DETAIL_DUPLICATES_ITERATOR_HPP
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
+#include <cstddef>
+#include <iterator>
+
+namespace boost{
+
+namespace multi_index{
+
+namespace detail{
+
+/* duplicates_operator is given a range of ordered elements and
+ * passes only over those which are duplicated.
+ */
+
+template<typename Node,typename Predicate>
+class duplicates_iterator
+{
+public:
+  typedef typename Node::value_type        value_type;
+  typedef std::ptrdiff_t                   difference_type;
+  typedef const typename Node::value_type* pointer;
+  typedef const typename Node::value_type& reference;
+  typedef std::forward_iterator_tag        iterator_category;
+
+  duplicates_iterator(Node* node_,Node* end_,Predicate pred_):
+    node(node_),begin_chunk(0),end(end_),pred(pred_)
+  {
+    advance();
+  }
+
+  duplicates_iterator(Node* end_,Predicate pred_):
+    node(end_),begin_chunk(end_),end(end_),pred(pred_)
+  {
+  }
+
+  reference operator*()const
+  {
+    return node->value();
+  }
+
+  pointer operator->()const
+  {
+    return &node->value();
+  }
+
+  duplicates_iterator& operator++()
+  {
+    Node::increment(node);
+    sync();
+    return *this;
+  }
+
+  duplicates_iterator operator++(int)
+  {
+    duplicates_iterator tmp(*this);
+    ++(*this);
+    return tmp;
+  }
+
+  Node* get_node()const{return node;}
+
+private:
+  void sync()
+  {
+    if(node!=end&&pred(begin_chunk->value(),node->value()))advance();
+  }
+
+  void advance()
+  {
+    for(Node* node2=node;node!=end;node=node2){
+      Node::increment(node2);
+      if(node2!=end&&!pred(node->value(),node2->value()))break;
+    }
+    begin_chunk=node;
+  }
+
+  Node*     node;
+  Node*     begin_chunk;
+  Node*     end;
+  Predicate pred;
+};
+
+template<typename Node,typename Predicate>
+bool operator==(
+  const duplicates_iterator<Node,Predicate>& x,
+  const duplicates_iterator<Node,Predicate>& y)
+{
+  return x.get_node()==y.get_node();
+}
+
+template<typename Node,typename Predicate>
+bool operator!=(
+  const duplicates_iterator<Node,Predicate>& x,
+  const duplicates_iterator<Node,Predicate>& y)
+{
+  return !(x==y);
+}
+
+} /* namespace multi_index::detail */
+
+} /* namespace multi_index */
+
+} /* namespace boost */
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/has_tag.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/has_tag.hpp
new file mode 100644
index 00000000000..217b61143af
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/has_tag.hpp
@@ -0,0 +1,42 @@
+/* Copyright 2003-2013 Joaquin M Lopez Munoz.
+ * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
+ */
+
+#ifndef BOOST_MULTI_INDEX_DETAIL_HAS_TAG_HPP
+#define BOOST_MULTI_INDEX_DETAIL_HAS_TAG_HPP
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
+#include <boost/mpl/contains.hpp>
+
+namespace boost{
+
+namespace multi_index{
+
+namespace detail{
+
+/* determines whether an index type has a given tag in its tag list */
+
+template<typename Tag>
+struct has_tag
+{
+  template<typename Index>
+  struct apply:mpl::contains<BOOST_DEDUCED_TYPENAME Index::tag_list,Tag>
+  {
+  }; 
+};
+
+} /* namespace multi_index::detail */
+
+} /* namespace multi_index */
+
+} /* namespace boost */
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/hash_index_args.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/hash_index_args.hpp
new file mode 100644
index 00000000000..81902f5a4a5
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/hash_index_args.hpp
@@ -0,0 +1,105 @@
+/* Copyright 2003-2013 Joaquin M Lopez Munoz.
+ * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
+ */
+
+#ifndef BOOST_MULTI_INDEX_DETAIL_HASH_INDEX_ARGS_HPP
+#define BOOST_MULTI_INDEX_DETAIL_HASH_INDEX_ARGS_HPP
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
+#include <boost/functional/hash.hpp>
+#include <boost/mpl/aux_/na.hpp>
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/identity.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/multi_index/tag.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <functional>
+
+namespace boost{
+
+namespace multi_index{
+
+namespace detail{
+
+/* Hashed index specifiers can be instantiated in two forms:
+ *
+ *   (hashed_unique|hashed_non_unique)<
+ *     KeyFromValue,
+ *     Hash=boost::hash<KeyFromValue::result_type>,
+ *     Pred=std::equal_to<KeyFromValue::result_type> >
+ *   (hashed_unique|hashed_non_unique)<
+ *     TagList,
+ *     KeyFromValue,
+ *     Hash=boost::hash<KeyFromValue::result_type>,
+ *     Pred=std::equal_to<KeyFromValue::result_type> >
+ *
+ * hashed_index_args implements the machinery to accept this
+ * argument-dependent polymorphism.
+ */
+
+template<typename KeyFromValue>
+struct index_args_default_hash
+{
+  typedef ::boost::hash<typename KeyFromValue::result_type> type;
+};
+
+template<typename KeyFromValue>
+struct index_args_default_pred
+{
+  typedef std::equal_to<typename KeyFromValue::result_type> type;
+};
+
+template<typename Arg1,typename Arg2,typename Arg3,typename Arg4>
+struct hashed_index_args
+{
+  typedef is_tag<Arg1> full_form;
+
+  typedef typename mpl::if_<
+    full_form,
+    Arg1,
+    tag< > >::type                                   tag_list_type;
+  typedef typename mpl::if_<
+    full_form,
+    Arg2,
+    Arg1>::type                                      key_from_value_type;
+  typedef typename mpl::if_<
+    full_form,
+    Arg3,
+    Arg2>::type                                      supplied_hash_type;
+  typedef typename mpl::eval_if<
+    mpl::is_na<supplied_hash_type>,
+    index_args_default_hash<key_from_value_type>,
+    mpl::identity<supplied_hash_type>
+  >::type                                            hash_type;
+  typedef typename mpl::if_<
+    full_form,
+    Arg4,
+    Arg3>::type                                      supplied_pred_type;
+  typedef typename mpl::eval_if<
+    mpl::is_na<supplied_pred_type>,
+    index_args_default_pred<key_from_value_type>,
+    mpl::identity<supplied_pred_type>
+  >::type                                            pred_type;
+
+  BOOST_STATIC_ASSERT(is_tag<tag_list_type>::value);
+  BOOST_STATIC_ASSERT(!mpl::is_na<key_from_value_type>::value);
+  BOOST_STATIC_ASSERT(!mpl::is_na<hash_type>::value);
+  BOOST_STATIC_ASSERT(!mpl::is_na<pred_type>::value);
+};
+
+} /* namespace multi_index::detail */
+
+} /* namespace multi_index */
+
+} /* namespace boost */
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/hash_index_iterator.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/hash_index_iterator.hpp
new file mode 100644
index 00000000000..8d063002a1d
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/hash_index_iterator.hpp
@@ -0,0 +1,166 @@
+/* Copyright 2003-2014 Joaquin M Lopez Munoz.
+ * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
+ */
+
+#ifndef BOOST_MULTI_INDEX_DETAIL_HASH_INDEX_ITERATOR_HPP
+#define BOOST_MULTI_INDEX_DETAIL_HASH_INDEX_ITERATOR_HPP
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
+#include <boost/operators.hpp>
+
+#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
+#include <boost/serialization/nvp.hpp>
+#include <boost/serialization/split_member.hpp>
+#include <boost/serialization/version.hpp>
+#endif
+
+namespace boost{
+
+namespace multi_index{
+
+namespace detail{
+
+/* Iterator class for hashed indices.
+ */
+
+struct hashed_index_global_iterator_tag{};
+struct hashed_index_local_iterator_tag{};
+
+template<typename Node,typename BucketArray,typename Category>
+class hashed_index_iterator:
+  public forward_iterator_helper<
+    hashed_index_iterator<Node,BucketArray,Category>,
+    typename Node::value_type,
+    std::ptrdiff_t,
+    const typename Node::value_type*,
+    const typename Node::value_type&>
+{
+public:
+  /* coverity[uninit_ctor]: suppress warning */
+  hashed_index_iterator(){}
+  hashed_index_iterator(Node* node_):node(node_){}
+
+  const typename Node::value_type& operator*()const
+  {
+    return node->value();
+  }
+
+  hashed_index_iterator& operator++()
+  {
+    this->increment(Category());
+    return *this;
+  }
+
+#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
+  /* Serialization. As for why the following is public,
+   * see explanation in safe_mode_iterator notes in safe_mode.hpp.
+   */
+  
+  BOOST_SERIALIZATION_SPLIT_MEMBER()
+
+  typedef typename Node::base_type node_base_type;
+
+  template<class Archive>
+  void save(Archive& ar,const unsigned int)const
+  {
+    node_base_type* bnode=node;
+    ar<<serialization::make_nvp("pointer",bnode);
+  }
+
+  template<class Archive>
+  void load(Archive& ar,const unsigned int version)
+  {
+    load(ar,version,Category());
+  }
+
+  template<class Archive>
+  void load(
+    Archive& ar,const unsigned int version,hashed_index_global_iterator_tag)
+  {
+    node_base_type* bnode;
+    ar>>serialization::make_nvp("pointer",bnode);
+    node=static_cast<Node*>(bnode);
+    if(version<1){
+      BucketArray* throw_away; /* consume unused ptr */
+      ar>>serialization::make_nvp("pointer",throw_away);
+    }
+  }
+
+  template<class Archive>
+  void load(
+    Archive& ar,const unsigned int version,hashed_index_local_iterator_tag)
+  {
+    node_base_type* bnode;
+    ar>>serialization::make_nvp("pointer",bnode);
+    node=static_cast<Node*>(bnode);
+    if(version<1){
+      BucketArray* buckets;
+      ar>>serialization::make_nvp("pointer",buckets);
+      if(buckets&&node&&node->impl()==buckets->end()->prior()){
+        /* end local_iterators used to point to end node, now they are null */
+        node=0;
+      }
+    }
+  }
+#endif
+
+  /* get_node is not to be used by the user */
+
+  typedef Node node_type;
+
+  Node* get_node()const{return node;}
+
+private:
+
+  void increment(hashed_index_global_iterator_tag)
+  {
+    Node::increment(node);
+  }
+
+  void increment(hashed_index_local_iterator_tag)
+  {
+    Node::increment_local(node);
+  }
+
+  Node* node;
+};
+
+template<typename Node,typename BucketArray,typename Category>
+bool operator==(
+  const hashed_index_iterator<Node,BucketArray,Category>& x,
+  const hashed_index_iterator<Node,BucketArray,Category>& y)
+{
+  return x.get_node()==y.get_node();
+}
+
+} /* namespace multi_index::detail */
+
+} /* namespace multi_index */
+
+#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
+/* class version = 1 : hashed_index_iterator does no longer serialize a bucket
+ * array pointer.
+ */
+
+namespace serialization {
+template<typename Node,typename BucketArray,typename Category>
+struct version<
+  boost::multi_index::detail::hashed_index_iterator<Node,BucketArray,Category>
+>
+{
+  BOOST_STATIC_CONSTANT(int,value=1);
+};
+} /* namespace serialization */
+#endif
+
+} /* namespace boost */
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/hash_index_node.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/hash_index_node.hpp
new file mode 100644
index 00000000000..7788e810ac9
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/hash_index_node.hpp
@@ -0,0 +1,778 @@
+/* Copyright 2003-2015 Joaquin M Lopez Munoz.
+ * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
+ */
+
+#ifndef BOOST_MULTI_INDEX_DETAIL_HASH_INDEX_NODE_HPP
+#define BOOST_MULTI_INDEX_DETAIL_HASH_INDEX_NODE_HPP
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
+#include <boost/detail/allocator_utilities.hpp>
+#include <boost/multi_index/detail/raw_ptr.hpp>
+#include <utility>
+
+namespace boost{
+
+namespace multi_index{
+
+namespace detail{
+
+/* Certain C++ requirements on unordered associative containers (see LWG issue
+ * #579) imply a data structure where nodes are linked in a single list, which
+ * in its turn forces implementors to add additional overhed per node to
+ * associate each with its corresponding bucket. Others resort to storing hash
+ * values, we use an alternative structure providing unconditional O(1)
+ * manipulation, even in situations of unfair hash distribution, plus some
+ * lookup speedups. For unique indices we maintain a doubly linked list of
+ * nodes except that if N is the first node of a bucket its associated
+ * bucket node is embedded between N and the preceding node in the following
+ * manner:
+ *
+ *        +---+   +---+       +---+   +---+
+ *     <--+   |<--+   |    <--+   |<--+   |
+ *   ...  | B0|   | B1|  ...  | B1|   | B2|  ...
+ *        |   |-+ |   +-->    |   |-+ |   +-->
+ *        +-+-+ | +---+       +-+-+ | +---+
+ *              |   ^               |   ^
+ *              |   |               |   |
+ *              | +-+               | +-+
+ *              | |                 | |
+ *              v |                 v |  
+ *       --+---+---+---+--   --+---+---+---+--
+ *     ... |   | B1|   |  ...  |   | B2|   | ...
+ *       --+---+---+---+--   --+---+---+---+--
+ *
+ *
+ * The fist and last nodes of buckets can be checked with
+ *
+ *   first node of a bucket: Npn != N
+ *   last node of a bucket:  Nnp != N
+ *
+ * (n and p short for ->next(), ->prior(), bucket nodes have prior pointers
+ * only). Pure insert and erase (without lookup) can be unconditionally done
+ * in O(1).
+ * For non-unique indices we add the following additional complexity: when
+ * there is a group of 3 or more equivalent elements, they are linked as
+ * follows:
+ *
+ *         +-----------------------+
+ *         |                       v
+ *   +---+ | +---+       +---+   +---+
+ *   |   | +-+   |       |   |<--+   |
+ *   | F |   | S |  ...  | P |   | L |
+ *   |   +-->|   |       |   +-+ |   |
+ *   +---+   +---+       +---+ | +---+
+ *     ^                       |
+ *     +-----------------------+
+ * 
+ * F, S, P and L are the first, second, penultimate and last node in the
+ * group, respectively (S and P can coincide if the group has size 3.) This
+ * arrangement is used to skip equivalent elements in O(1) when doing lookup,
+ * while preserving O(1) insert/erase. The following invariants identify
+ * special positions (some of the operations have to be carefully implemented
+ * as Xnn is not valid if Xn points to a bucket):
+ *
+ *   first node of a bucket: Npnp  == N
+ *   last node of a bucket:  Nnpp  == N
+ *   first node of a group:  Nnp != N && Nnppn == N
+ *   second node of a group: Npn != N && Nppnn == N
+ *   n-1 node of a group:    Nnp != N && Nnnpp == N
+ *   last node of a group:   Npn != N && Npnnp == N
+ * 
+ * The memory overhead is one pointer per bucket plus two pointers per node,
+ * probably unbeatable. The resulting structure is bidirectonally traversable,
+ * though currently we are just providing forward iteration.
+ */
+
+template<typename Allocator>
+struct hashed_index_node_impl;
+
+/* half-header (only prior() pointer) to use for the bucket array */
+
+template<typename Allocator>
+struct hashed_index_base_node_impl
+{
+  typedef typename
+  boost::detail::allocator::rebind_to<
+      Allocator,hashed_index_base_node_impl
+  >::type::pointer                          base_pointer;
+  typedef typename
+  boost::detail::allocator::rebind_to<
+    Allocator,hashed_index_base_node_impl
+  >::type::const_pointer                    const_base_pointer;
+  typedef typename
+  boost::detail::allocator::rebind_to<
+    Allocator,
+    hashed_index_node_impl<Allocator>
+  >::type::pointer                          pointer;
+  typedef typename
+  boost::detail::allocator::rebind_to<
+    Allocator,
+    hashed_index_node_impl<Allocator>
+  >::type::const_pointer                    const_pointer;
+
+  pointer& prior(){return prior_;}
+  pointer  prior()const{return prior_;}
+
+private:
+  pointer prior_;
+};
+
+/* full header (prior() and next()) for the nodes */
+
+template<typename Allocator>
+struct hashed_index_node_impl:hashed_index_base_node_impl<Allocator>
+{
+private:
+  typedef hashed_index_base_node_impl<Allocator> super;
+
+public:  
+  typedef typename super::base_pointer           base_pointer;
+  typedef typename super::const_base_pointer     const_base_pointer;
+  typedef typename super::pointer                pointer;
+  typedef typename super::const_pointer          const_pointer;
+
+  base_pointer& next(){return next_;}
+  base_pointer  next()const{return next_;}
+
+  static pointer pointer_from(base_pointer x)
+  {
+    return static_cast<pointer>(
+      static_cast<hashed_index_node_impl*>(
+        raw_ptr<super*>(x)));
+  }
+
+  static base_pointer base_pointer_from(pointer x)
+  {
+    return static_cast<base_pointer>(
+      raw_ptr<hashed_index_node_impl*>(x));
+  }
+
+private:
+  base_pointer next_;
+};
+
+/* Boost.MultiIndex requires machinery to reverse unlink operations. A simple
+ * way to make a pointer-manipulation function undoable is to templatize
+ * its internal pointer assignments with a functor that, besides doing the
+ * assignment, keeps track of the original pointer values and can later undo
+ * the operations in reverse order.
+ */
+
+struct default_assigner
+{
+  template<typename T> void operator()(T& x,const T& val){x=val;}
+};
+
+template<typename Node>
+struct unlink_undo_assigner
+{
+  typedef typename Node::base_pointer base_pointer;
+  typedef typename Node::pointer      pointer;
+
+  unlink_undo_assigner():pointer_track_count(0),base_pointer_track_count(0){}
+
+  void operator()(pointer& x,pointer val)
+  {
+    pointer_tracks[pointer_track_count].x=&x;
+    pointer_tracks[pointer_track_count++].val=x;
+    x=val;
+  }
+
+  void operator()(base_pointer& x,base_pointer val)
+  {
+    base_pointer_tracks[base_pointer_track_count].x=&x;
+    base_pointer_tracks[base_pointer_track_count++].val=x;
+    x=val;
+  }
+
+  void operator()() /* undo op */
+  {
+    /* in the absence of aliasing, restitution order is immaterial */
+
+    while(pointer_track_count--){
+      *(pointer_tracks[pointer_track_count].x)=
+        pointer_tracks[pointer_track_count].val;
+    }
+    while(base_pointer_track_count--){
+      *(base_pointer_tracks[base_pointer_track_count].x)=
+        base_pointer_tracks[base_pointer_track_count].val;
+    }
+  }
+
+  struct pointer_track     {pointer*      x; pointer      val;};
+  struct base_pointer_track{base_pointer* x; base_pointer val;};
+
+  /* We know the maximum number of pointer and base pointer assignments that
+   * the two unlink versions do, so we can statically reserve the needed
+   * storage.
+   */
+
+  pointer_track      pointer_tracks[3];
+  int                pointer_track_count;
+  base_pointer_track base_pointer_tracks[2];
+  int                base_pointer_track_count;
+};
+
+/* algorithmic stuff for unique and non-unique variants */
+
+struct hashed_unique_tag{};
+struct hashed_non_unique_tag{};
+
+template<typename Node,typename Category>
+struct hashed_index_node_alg;
+
+template<typename Node>
+struct hashed_index_node_alg<Node,hashed_unique_tag>
+{
+  typedef typename Node::base_pointer       base_pointer;
+  typedef typename Node::const_base_pointer const_base_pointer;
+  typedef typename Node::pointer            pointer;
+  typedef typename Node::const_pointer      const_pointer;
+
+  static bool is_first_of_bucket(pointer x)
+  {
+    return x->prior()->next()!=base_pointer_from(x);
+  }
+
+  static pointer after(pointer x)
+  {
+    return is_last_of_bucket(x)?x->next()->prior():pointer_from(x->next());
+  }
+
+  static pointer after_local(pointer x)
+  {
+    return is_last_of_bucket(x)?pointer(0):pointer_from(x->next());
+  }
+
+  static pointer next_to_inspect(pointer x)
+  {
+    return is_last_of_bucket(x)?pointer(0):pointer_from(x->next());
+  }
+
+  static void link(pointer x,base_pointer buc,pointer end)
+  {
+    if(buc->prior()==pointer(0)){ /* empty bucket */
+      x->prior()=end->prior();
+      x->next()=end->prior()->next();
+      x->prior()->next()=buc;
+      buc->prior()=x;
+      end->prior()=x;
+    }
+    else{
+      x->prior()=buc->prior()->prior();
+      x->next()=base_pointer_from(buc->prior());
+      buc->prior()=x;
+      x->next()->prior()=x;
+    }
+  }
+
+  static void unlink(pointer x)
+  {
+    default_assigner assign;
+    unlink(x,assign);
+  }
+
+  typedef unlink_undo_assigner<Node> unlink_undo;
+
+  template<typename Assigner>
+  static void unlink(pointer x,Assigner& assign)
+  {
+    if(is_first_of_bucket(x)){
+      if(is_last_of_bucket(x)){
+        assign(x->prior()->next()->prior(),pointer(0));
+        assign(x->prior()->next(),x->next());
+        assign(x->next()->prior()->prior(),x->prior());
+      }
+      else{
+        assign(x->prior()->next()->prior(),pointer_from(x->next()));
+        assign(x->next()->prior(),x->prior());
+      }
+    }
+    else if(is_last_of_bucket(x)){
+      assign(x->prior()->next(),x->next());
+      assign(x->next()->prior()->prior(),x->prior());
+    }
+    else{
+      assign(x->prior()->next(),x->next());
+      assign(x->next()->prior(),x->prior());
+    }
+  }
+
+  /* used only at rehashing */
+
+  static void append(pointer x,pointer end)
+  {
+    x->prior()=end->prior();
+    x->next()=end->prior()->next();
+    x->prior()->next()=base_pointer_from(x);
+    end->prior()=x;
+  }
+
+  static bool unlink_last(pointer end)
+  {
+    /* returns true iff bucket is emptied */
+
+    pointer x=end->prior();
+    if(x->prior()->next()==base_pointer_from(x)){
+      x->prior()->next()=x->next();
+      end->prior()=x->prior();
+      return false;
+    }
+    else{
+      x->prior()->next()->prior()=pointer(0);
+      x->prior()->next()=x->next();
+      end->prior()=x->prior();
+      return true;
+    }
+  }
+
+private:
+  static pointer pointer_from(base_pointer x)
+  {
+    return Node::pointer_from(x);
+  }
+
+  static base_pointer base_pointer_from(pointer x)
+  {
+    return Node::base_pointer_from(x);
+  }
+
+  static bool is_last_of_bucket(pointer x)
+  {
+    return x->next()->prior()!=x;
+  }
+};
+
+template<typename Node>
+struct hashed_index_node_alg<Node,hashed_non_unique_tag>
+{
+  typedef typename Node::base_pointer       base_pointer;
+  typedef typename Node::const_base_pointer const_base_pointer;
+  typedef typename Node::pointer            pointer;
+  typedef typename Node::const_pointer      const_pointer;
+
+  static bool is_first_of_bucket(pointer x)
+  {
+    return x->prior()->next()->prior()==x;
+  }
+
+  static bool is_first_of_group(pointer x)
+  {
+    return
+      x->next()->prior()!=x&&
+      x->next()->prior()->prior()->next()==base_pointer_from(x);
+  }
+
+  static pointer after(pointer x)
+  {
+    if(x->next()->prior()==x)return pointer_from(x->next());
+    if(x->next()->prior()->prior()==x)return x->next()->prior();
+    if(x->next()->prior()->prior()->next()==base_pointer_from(x))
+      return pointer_from(x->next());
+    return pointer_from(x->next())->next()->prior();
+  }
+
+  static pointer after_local(pointer x)
+  {
+    if(x->next()->prior()==x)return pointer_from(x->next());
+    if(x->next()->prior()->prior()==x)return pointer(0);
+    if(x->next()->prior()->prior()->next()==base_pointer_from(x))
+      return pointer_from(x->next());
+    return pointer_from(x->next())->next()->prior();
+  }
+
+  static pointer next_to_inspect(pointer x)
+  {
+    if(x->next()->prior()==x)return pointer_from(x->next());
+    if(x->next()->prior()->prior()==x)return pointer(0);
+    if(x->next()->prior()->next()->prior()!=x->next()->prior())
+      return pointer(0);
+    return pointer_from(x->next()->prior()->next());
+  }
+
+  static void link(pointer x,base_pointer buc,pointer end)
+  {
+    if(buc->prior()==pointer(0)){ /* empty bucket */
+      x->prior()=end->prior();
+      x->next()=end->prior()->next();
+      x->prior()->next()=buc;
+      buc->prior()=x;
+      end->prior()=x;
+    }
+    else{
+      x->prior()=buc->prior()->prior();
+      x->next()=base_pointer_from(buc->prior());
+      buc->prior()=x;
+      x->next()->prior()=x;
+    }
+  };
+
+  static void link(pointer x,pointer first,pointer last)
+  {
+    x->prior()=first->prior();
+    x->next()=base_pointer_from(first);
+    if(is_first_of_bucket(first)){
+      x->prior()->next()->prior()=x;
+    }
+    else{
+      x->prior()->next()=base_pointer_from(x);
+    }
+
+    if(first==last){
+      last->prior()=x;
+    }
+    else if(first->next()==base_pointer_from(last)){
+      first->prior()=last;
+      first->next()=base_pointer_from(x);
+    }
+    else{
+      pointer second=pointer_from(first->next()),
+              lastbutone=last->prior();
+      second->prior()=first;
+      first->prior()=last;
+      lastbutone->next()=base_pointer_from(x);
+    }
+  }
+
+  static void unlink(pointer x)
+  {
+    default_assigner assign;
+    unlink(x,assign);
+  }
+
+  typedef unlink_undo_assigner<Node> unlink_undo;
+
+  template<typename Assigner>
+  static void unlink(pointer x,Assigner& assign)
+  {
+    if(x->prior()->next()==base_pointer_from(x)){
+      if(x->next()->prior()==x){
+        left_unlink(x,assign);
+        right_unlink(x,assign);
+      }
+      else if(x->next()->prior()->prior()==x){           /* last of bucket */
+        left_unlink(x,assign);
+        right_unlink_last_of_bucket(x,assign);
+      }
+      else if(x->next()->prior()->prior()->next()==
+              base_pointer_from(x)){                /* first of group size */
+        left_unlink(x,assign);
+        right_unlink_first_of_group(x,assign);
+      }
+      else{                                                /* n-1 of group */
+        unlink_last_but_one_of_group(x,assign);
+      }
+    }
+    else if(x->prior()->next()->prior()==x){            /* first of bucket */
+      if(x->next()->prior()==x){
+        left_unlink_first_of_bucket(x,assign);
+        right_unlink(x,assign);
+      }
+      else if(x->next()->prior()->prior()==x){           /* last of bucket */
+        assign(x->prior()->next()->prior(),pointer(0));
+        assign(x->prior()->next(),x->next());
+        assign(x->next()->prior()->prior(),x->prior());
+      }
+      else{                                              /* first of group */
+        left_unlink_first_of_bucket(x,assign);
+        right_unlink_first_of_group(x,assign);
+      }
+    }
+    else if(x->next()->prior()->prior()==x){   /* last of group and bucket */
+      left_unlink_last_of_group(x,assign);
+      right_unlink_last_of_bucket(x,assign);
+    }
+    else if(pointer_from(x->prior()->prior()->next())
+            ->next()==base_pointer_from(x)){            /* second of group */
+      unlink_second_of_group(x,assign);
+    }
+    else{                              /* last of group, ~(last of bucket) */
+      left_unlink_last_of_group(x,assign);
+      right_unlink(x,assign);
+    }
+  }
+
+  /* used only at rehashing */
+
+  static void link_range(
+    pointer first,pointer last,base_pointer buc,pointer cend)
+  {
+    if(buc->prior()==pointer(0)){ /* empty bucket */
+      first->prior()=cend->prior();
+      last->next()=cend->prior()->next();
+      first->prior()->next()=buc;
+      buc->prior()=first;
+      cend->prior()=last;
+    }
+    else{
+      first->prior()=buc->prior()->prior();
+      last->next()=base_pointer_from(buc->prior());
+      buc->prior()=first;
+      last->next()->prior()=last;
+    }
+  }
+
+  static void append_range(pointer first,pointer last,pointer cend)
+  {
+    first->prior()=cend->prior();
+    last->next()=cend->prior()->next();
+    first->prior()->next()=base_pointer_from(first);
+    cend->prior()=last;
+  }
+
+  static std::pair<pointer,bool> unlink_last_group(pointer end)
+  {
+    /* returns first of group true iff bucket is emptied */
+
+    pointer x=end->prior();
+    if(x->prior()->next()==base_pointer_from(x)){
+      x->prior()->next()=x->next();
+      end->prior()=x->prior();
+      return std::make_pair(x,false);
+    }
+    else if(x->prior()->next()->prior()==x){
+      x->prior()->next()->prior()=pointer(0);
+      x->prior()->next()=x->next();
+      end->prior()=x->prior();
+      return std::make_pair(x,true);
+    }
+    else{
+      pointer y=pointer_from(x->prior()->next());
+
+      if(y->prior()->next()==base_pointer_from(y)){
+        y->prior()->next()=x->next();
+        end->prior()=y->prior();
+        return std::make_pair(y,false);
+      }
+      else{
+        y->prior()->next()->prior()=pointer(0);
+        y->prior()->next()=x->next();
+        end->prior()=y->prior();
+        return std::make_pair(y,true);
+      }
+    }
+  }
+
+  static void unlink_range(pointer first,pointer last)
+  {
+    if(is_first_of_bucket(first)){
+      if(is_last_of_bucket(last)){
+        first->prior()->next()->prior()=pointer(0);
+        first->prior()->next()=last->next();
+        last->next()->prior()->prior()=first->prior();
+      }
+      else{
+        first->prior()->next()->prior()=pointer_from(last->next());
+        last->next()->prior()=first->prior();
+      }
+    }
+    else if(is_last_of_bucket(last)){
+      first->prior()->next()=last->next();
+      last->next()->prior()->prior()=first->prior();
+    }
+    else{
+      first->prior()->next()=last->next();
+      last->next()->prior()=first->prior();
+    }
+  }
+
+private:
+  static pointer pointer_from(base_pointer x)
+  {
+    return Node::pointer_from(x);
+  }
+
+  static base_pointer base_pointer_from(pointer x)
+  {
+    return Node::base_pointer_from(x);
+  }
+
+  static bool is_last_of_bucket(pointer x)
+  {
+    return x->next()->prior()->prior()==x;
+  }
+
+  template<typename Assigner>
+  static void left_unlink(pointer x,Assigner& assign)
+  {
+    assign(x->prior()->next(),x->next());
+  }
+  
+  template<typename Assigner>
+  static void right_unlink(pointer x,Assigner& assign)
+  {
+    assign(x->next()->prior(),x->prior());
+  }
+
+  template<typename Assigner>
+  static void left_unlink_first_of_bucket(pointer x,Assigner& assign)
+  {
+    assign(x->prior()->next()->prior(),pointer_from(x->next()));
+  }
+
+  template<typename Assigner>
+  static void right_unlink_last_of_bucket(pointer x,Assigner& assign)
+  {
+    assign(x->next()->prior()->prior(),x->prior());
+  }
+
+  template<typename Assigner>
+  static void right_unlink_first_of_group(pointer x,Assigner& assign)
+  {
+    pointer second=pointer_from(x->next()),
+            last=second->prior(),
+            lastbutone=last->prior();
+    if(second==lastbutone){
+      assign(second->next(),base_pointer_from(last));
+      assign(second->prior(),x->prior());
+    }
+    else{
+      assign(lastbutone->next(),base_pointer_from(second));
+      assign(second->next()->prior(),last);
+      assign(second->prior(),x->prior());
+    }
+  }
+
+  template<typename Assigner>
+  static void left_unlink_last_of_group(pointer x,Assigner& assign)
+  {
+    pointer lastbutone=x->prior(),
+            first=pointer_from(lastbutone->next()),
+            second=pointer_from(first->next());
+    if(lastbutone==second){
+      assign(lastbutone->prior(),first);
+      assign(lastbutone->next(),x->next());
+    }
+    else{
+      assign(second->prior(),lastbutone);
+      assign(lastbutone->prior()->next(),base_pointer_from(first));
+      assign(lastbutone->next(),x->next());
+    }
+  }
+
+  template<typename Assigner>
+  static void unlink_last_but_one_of_group(pointer x,Assigner& assign)
+  {
+    pointer first=pointer_from(x->next()),
+            second=pointer_from(first->next()),
+            last=second->prior();
+    if(second==x){
+      assign(last->prior(),first);
+      assign(first->next(),base_pointer_from(last));
+    }
+    else{
+      assign(last->prior(),x->prior());
+      assign(x->prior()->next(),base_pointer_from(first));
+    }
+  }
+
+  template<typename Assigner>
+  static void unlink_second_of_group(pointer x,Assigner& assign)
+  {
+    pointer last=x->prior(),
+            lastbutone=last->prior(),
+            first=pointer_from(lastbutone->next());
+    if(lastbutone==x){
+      assign(first->next(),base_pointer_from(last));
+      assign(last->prior(),first);
+    }
+    else{
+      assign(first->next(),x->next());
+      assign(x->next()->prior(),last);
+    }
+  }
+};
+
+template<typename Super>
+struct hashed_index_node_trampoline:
+  hashed_index_node_impl<
+    typename boost::detail::allocator::rebind_to<
+      typename Super::allocator_type,
+      char
+    >::type
+  >
+{
+  typedef typename boost::detail::allocator::rebind_to<
+    typename Super::allocator_type,
+    char
+  >::type                                               impl_allocator_type;
+  typedef hashed_index_node_impl<impl_allocator_type>   impl_type;
+};
+
+template<typename Super,typename Category>
+struct hashed_index_node:
+  Super,hashed_index_node_trampoline<Super>
+{
+private:
+  typedef hashed_index_node_trampoline<Super> trampoline;
+
+public:
+  typedef typename trampoline::impl_type          impl_type;
+  typedef hashed_index_node_alg<
+    impl_type,Category>                           node_alg;
+  typedef typename trampoline::base_pointer       impl_base_pointer;
+  typedef typename trampoline::const_base_pointer const_impl_base_pointer;
+  typedef typename trampoline::pointer            impl_pointer;
+  typedef typename trampoline::const_pointer      const_impl_pointer;
+
+  impl_pointer&      prior(){return trampoline::prior();}
+  impl_pointer       prior()const{return trampoline::prior();}
+  impl_base_pointer& next(){return trampoline::next();}
+  impl_base_pointer  next()const{return trampoline::next();}
+
+  impl_pointer impl()
+  {
+    return static_cast<impl_pointer>(
+      static_cast<impl_type*>(static_cast<trampoline*>(this)));
+  }
+
+  const_impl_pointer impl()const
+  {
+    return static_cast<const_impl_pointer>(
+      static_cast<const impl_type*>(static_cast<const trampoline*>(this)));
+  }
+
+  static hashed_index_node* from_impl(impl_pointer x)
+  {
+    return
+      static_cast<hashed_index_node*>(
+        static_cast<trampoline*>(
+          raw_ptr<impl_type*>(x)));
+  }
+
+  static const hashed_index_node* from_impl(const_impl_pointer x)
+  {
+    return 
+      static_cast<const hashed_index_node*>(
+        static_cast<const trampoline*>(
+          raw_ptr<const impl_type*>(x)));
+  }
+
+  /* interoperability with hashed_index_iterator */
+
+  static void increment(hashed_index_node*& x)
+  {
+    x=from_impl(node_alg::after(x->impl()));
+  }
+
+  static void increment_local(hashed_index_node*& x)
+  {
+    x=from_impl(node_alg::after_local(x->impl()));
+  }
+};
+
+} /* namespace multi_index::detail */
+
+} /* namespace multi_index */
+
+} /* namespace boost */
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/header_holder.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/header_holder.hpp
new file mode 100644
index 00000000000..ca8a9b2edb1
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/header_holder.hpp
@@ -0,0 +1,50 @@
+/* Copyright 2003-2008 Joaquin M Lopez Munoz.
+ * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
+ */
+
+#ifndef BOOST_MULTI_INDEX_DETAIL_HEADER_HOLDER_HPP
+#define BOOST_MULTI_INDEX_DETAIL_HEADER_HOLDER_HPP
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/noncopyable.hpp>
+
+namespace boost{
+
+namespace multi_index{
+
+namespace detail{
+
+/* A utility class used to hold a pointer to the header node.
+ * The base from member idiom is used because index classes, which are
+ * superclasses of multi_index_container, need this header in construction
+ * time. The allocation is made by the allocator of the multi_index_container
+ * class --hence, this allocator needs also be stored resorting
+ * to the base from member trick.
+ */
+
+template<typename NodeTypePtr,typename Final>
+struct header_holder:private noncopyable
+{
+  header_holder():member(final().allocate_node()){}
+  ~header_holder(){final().deallocate_node(&*member);}
+
+  NodeTypePtr member;
+
+private:
+  Final& final(){return *static_cast<Final*>(this);}
+};
+
+} /* namespace multi_index::detail */
+
+} /* namespace multi_index */
+
+} /* namespace boost */
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/ignore_wstrict_aliasing.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/ignore_wstrict_aliasing.hpp
new file mode 100644
index 00000000000..ae398456d1f
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/ignore_wstrict_aliasing.hpp
@@ -0,0 +1,18 @@
+/* Copyright 2003-2016 Joaquin M Lopez Munoz.
+ * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
+ */
+
+#include <boost/config.hpp>
+
+#if defined(BOOST_GCC)&&(BOOST_GCC>=4*10000+6*100)
+#if !defined(BOOST_MULTI_INDEX_DETAIL_RESTORE_WSTRICT_ALIASING)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#else
+#pragma GCC diagnostic pop
+#endif
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/index_base.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/index_base.hpp
new file mode 100644
index 00000000000..99000ed4813
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/index_base.hpp
@@ -0,0 +1,293 @@
+/* Copyright 2003-2014 Joaquin M Lopez Munoz.
+ * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
+ */
+
+#ifndef BOOST_MULTI_INDEX_DETAIL_INDEX_BASE_HPP
+#define BOOST_MULTI_INDEX_DETAIL_INDEX_BASE_HPP
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
+#include <boost/detail/allocator_utilities.hpp>
+#include <boost/detail/no_exceptions_support.hpp>
+#include <boost/detail/workaround.hpp>
+#include <boost/move/core.hpp>
+#include <boost/move/utility.hpp>
+#include <boost/mpl/vector.hpp>
+#include <boost/multi_index/detail/copy_map.hpp>
+#include <boost/multi_index/detail/do_not_copy_elements_tag.hpp>
+#include <boost/multi_index/detail/node_type.hpp>
+#include <boost/multi_index/detail/vartempl_support.hpp>
+#include <boost/multi_index_container_fwd.hpp>
+#include <boost/tuple/tuple.hpp>
+#include <utility>
+
+#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
+#include <boost/multi_index/detail/index_loader.hpp>
+#include <boost/multi_index/detail/index_saver.hpp>
+#endif
+
+namespace boost{
+
+namespace multi_index{
+
+namespace detail{
+
+/* The role of this class is threefold:
+ *   - tops the linear hierarchy of indices.
+ *   - terminates some cascading backbone function calls (insert_, etc.),
+ *   - grants access to the backbone functions of the final
+ *     multi_index_container class (for access restriction reasons, these
+ *     cannot be called directly from the index classes.)
+ */
+
+struct lvalue_tag{};
+struct rvalue_tag{};
+struct emplaced_tag{};
+
+template<typename Value,typename IndexSpecifierList,typename Allocator>
+class index_base
+{
+protected:
+  typedef index_node_base<Value,Allocator>    node_type;
+  typedef typename multi_index_node_type<
+    Value,IndexSpecifierList,Allocator>::type final_node_type;
+  typedef multi_index_container<
+    Value,IndexSpecifierList,Allocator>       final_type;
+  typedef tuples::null_type                   ctor_args_list;
+  typedef typename 
+  boost::detail::allocator::rebind_to<
+    Allocator,
+    typename Allocator::value_type
+  >::type                                     final_allocator_type;
+  typedef mpl::vector0<>                      index_type_list;
+  typedef mpl::vector0<>                      iterator_type_list;
+  typedef mpl::vector0<>                      const_iterator_type_list;
+  typedef copy_map<
+    final_node_type,
+    final_allocator_type>                     copy_map_type;
+
+#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
+  typedef index_saver<
+    node_type,
+    final_allocator_type>                     index_saver_type;
+  typedef index_loader<
+    node_type,
+    final_node_type,
+    final_allocator_type>                     index_loader_type;
+#endif
+
+private:
+  typedef Value                               value_type;
+
+protected:
+  explicit index_base(const ctor_args_list&,const Allocator&){}
+
+  index_base(
+    const index_base<Value,IndexSpecifierList,Allocator>&,
+    do_not_copy_elements_tag)
+  {}
+
+  void copy_(
+    const index_base<Value,IndexSpecifierList,Allocator>&,const copy_map_type&)
+  {}
+
+  final_node_type* insert_(const value_type& v,final_node_type*& x,lvalue_tag)
+  {
+    x=final().allocate_node();
+    BOOST_TRY{
+      boost::detail::allocator::construct(&x->value(),v);
+    }
+    BOOST_CATCH(...){
+      final().deallocate_node(x);
+      BOOST_RETHROW;
+    }
+    BOOST_CATCH_END
+    return x;
+  }
+
+  final_node_type* insert_(const value_type& v,final_node_type*& x,rvalue_tag)
+  {
+    x=final().allocate_node();
+    BOOST_TRY{
+      /* This shoud have used a modified, T&&-compatible version of
+       * boost::detail::allocator::construct, but 
+       * <boost/detail/allocator_utilities.hpp> is too old and venerable to
+       * mess with; besides, it is a general internal utility and the imperfect
+       * perfect forwarding emulation of Boost.Move might break other libs.
+       */
+
+      new (&x->value()) value_type(boost::move(const_cast<value_type&>(v)));
+    }
+    BOOST_CATCH(...){
+      final().deallocate_node(x);
+      BOOST_RETHROW;
+    }
+    BOOST_CATCH_END
+    return x;
+  }
+
+  final_node_type* insert_(const value_type&,final_node_type*& x,emplaced_tag)
+  {
+    return x;
+  }
+
+  final_node_type* insert_(
+    const value_type& v,node_type*,final_node_type*& x,lvalue_tag)
+  {
+    return insert_(v,x,lvalue_tag());
+  }
+
+  final_node_type* insert_(
+    const value_type& v,node_type*,final_node_type*& x,rvalue_tag)
+  {
+    return insert_(v,x,rvalue_tag());
+  }
+
+  final_node_type* insert_(
+    const value_type&,node_type*,final_node_type*& x,emplaced_tag)
+  {
+    return x;
+  }
+
+  void erase_(node_type* x)
+  {
+    boost::detail::allocator::destroy(&x->value());
+  }
+
+  void delete_node_(node_type* x)
+  {
+    boost::detail::allocator::destroy(&x->value());
+  }
+
+  void clear_(){}
+
+  void swap_(index_base<Value,IndexSpecifierList,Allocator>&){}
+
+  void swap_elements_(index_base<Value,IndexSpecifierList,Allocator>&){}
+
+  bool replace_(const value_type& v,node_type* x,lvalue_tag)
+  {
+    x->value()=v;
+    return true;
+  }
+
+  bool replace_(const value_type& v,node_type* x,rvalue_tag)
+  {
+    x->value()=boost::move(const_cast<value_type&>(v));
+    return true;
+  }
+
+  bool modify_(node_type*){return true;}
+
+  bool modify_rollback_(node_type*){return true;}
+
+#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
+  /* serialization */
+
+  template<typename Archive>
+  void save_(Archive&,const unsigned int,const index_saver_type&)const{}
+
+  template<typename Archive>
+  void load_(Archive&,const unsigned int,const index_loader_type&){}
+#endif
+
+#if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING)
+  /* invariant stuff */
+
+  bool invariant_()const{return true;}
+#endif
+
+  /* access to backbone memfuns of Final class */
+
+  final_type&       final(){return *static_cast<final_type*>(this);}
+  const final_type& final()const{return *static_cast<const final_type*>(this);}
+
+  final_node_type* final_header()const{return final().header();}
+
+  bool        final_empty_()const{return final().empty_();}
+  std::size_t final_size_()const{return final().size_();}
+  std::size_t final_max_size_()const{return final().max_size_();}
+
+  std::pair<final_node_type*,bool> final_insert_(const value_type& x)
+    {return final().insert_(x);}
+  std::pair<final_node_type*,bool> final_insert_rv_(const value_type& x)
+    {return final().insert_rv_(x);}
+  template<typename T>
+  std::pair<final_node_type*,bool> final_insert_ref_(const T& t)
+    {return final().insert_ref_(t);}
+  template<typename T>
+  std::pair<final_node_type*,bool> final_insert_ref_(T& t)
+    {return final().insert_ref_(t);}
+
+  template<BOOST_MULTI_INDEX_TEMPLATE_PARAM_PACK>
+  std::pair<final_node_type*,bool> final_emplace_(
+    BOOST_MULTI_INDEX_FUNCTION_PARAM_PACK)
+  {
+    return final().emplace_(BOOST_MULTI_INDEX_FORWARD_PARAM_PACK);
+  }
+
+  std::pair<final_node_type*,bool> final_insert_(
+    const value_type& x,final_node_type* position)
+    {return final().insert_(x,position);}
+  std::pair<final_node_type*,bool> final_insert_rv_(
+    const value_type& x,final_node_type* position)
+    {return final().insert_rv_(x,position);}
+  template<typename T>
+  std::pair<final_node_type*,bool> final_insert_ref_(
+    const T& t,final_node_type* position)
+    {return final().insert_ref_(t,position);}
+  template<typename T>
+  std::pair<final_node_type*,bool> final_insert_ref_(
+    T& t,final_node_type* position)
+    {return final().insert_ref_(t,position);}
+
+  template<BOOST_MULTI_INDEX_TEMPLATE_PARAM_PACK>
+  std::pair<final_node_type*,bool> final_emplace_hint_(
+    final_node_type* position,BOOST_MULTI_INDEX_FUNCTION_PARAM_PACK)
+  {
+    return final().emplace_hint_(
+      position,BOOST_MULTI_INDEX_FORWARD_PARAM_PACK);
+  }
+
+  void final_erase_(final_node_type* x){final().erase_(x);}
+
+  void final_delete_node_(final_node_type* x){final().delete_node_(x);}
+  void final_delete_all_nodes_(){final().delete_all_nodes_();}
+  void final_clear_(){final().clear_();}
+
+  void final_swap_(final_type& x){final().swap_(x);}
+
+  bool final_replace_(
+    const value_type& k,final_node_type* x)
+    {return final().replace_(k,x);}
+  bool final_replace_rv_(
+    const value_type& k,final_node_type* x)
+    {return final().replace_rv_(k,x);}
+
+  template<typename Modifier>
+  bool final_modify_(Modifier& mod,final_node_type* x)
+    {return final().modify_(mod,x);}
+
+  template<typename Modifier,typename Rollback>
+  bool final_modify_(Modifier& mod,Rollback& back,final_node_type* x)
+    {return final().modify_(mod,back,x);}
+
+#if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING)
+  void final_check_invariant_()const{final().check_invariant_();}
+#endif
+};
+
+} /* namespace multi_index::detail */
+
+} /* namespace multi_index */
+
+} /* namespace boost */
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/index_loader.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/index_loader.hpp
new file mode 100644
index 00000000000..71418a10e19
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/index_loader.hpp
@@ -0,0 +1,139 @@
+/* Copyright 2003-2015 Joaquin M Lopez Munoz.
+ * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
+ */
+
+#ifndef BOOST_MULTI_INDEX_DETAIL_INDEX_LOADER_HPP
+#define BOOST_MULTI_INDEX_DETAIL_INDEX_LOADER_HPP
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
+#include <algorithm>
+#include <boost/archive/archive_exception.hpp>
+#include <boost/noncopyable.hpp>
+#include <boost/multi_index/detail/auto_space.hpp>
+#include <boost/multi_index/detail/raw_ptr.hpp>
+#include <boost/serialization/nvp.hpp>
+#include <boost/throw_exception.hpp> 
+#include <cstddef>
+
+namespace boost{
+
+namespace multi_index{
+
+namespace detail{
+
+/* Counterpart of index_saver (check index_saver.hpp for serialization
+ * details.)* multi_index_container is in charge of supplying the info about
+ * the base sequence, and each index can subsequently load itself using the
+ * const interface of index_loader.
+ */
+
+template<typename Node,typename FinalNode,typename Allocator>
+class index_loader:private noncopyable
+{
+public:
+  index_loader(const Allocator& al,std::size_t size):
+    spc(al,size),size_(size),n(0),sorted(false)
+  {
+  }
+
+  template<class Archive>
+  void add(Node* node,Archive& ar,const unsigned int)
+  {
+    ar>>serialization::make_nvp("position",*node);
+    entries()[n++]=node;
+  }
+
+  template<class Archive>
+  void add_track(Node* node,Archive& ar,const unsigned int)
+  {
+    ar>>serialization::make_nvp("position",*node);
+  }
+
+  /* A rearranger is passed two nodes, and is expected to
+   * reposition the second after the first.
+   * If the first node is 0, then the second should be moved
+   * to the beginning of the sequence.
+   */
+
+  template<typename Rearranger,class Archive>
+  void load(Rearranger r,Archive& ar,const unsigned int)const
+  {
+    FinalNode* prev=unchecked_load_node(ar);
+    if(!prev)return;
+
+    if(!sorted){
+      std::sort(entries(),entries()+size_);
+      sorted=true;
+    }
+
+    check_node(prev);
+
+    for(;;){
+      for(;;){
+        FinalNode* node=load_node(ar);
+        if(!node)break;
+
+        if(node==prev)prev=0;
+        r(prev,node);
+
+        prev=node;
+      }
+      prev=load_node(ar);
+      if(!prev)break;
+    }
+  }
+
+private:
+  Node** entries()const{return raw_ptr<Node**>(spc.data());}
+
+  /* We try to delay sorting as much as possible just in case it
+   * is not necessary, hence this version of load_node.
+   */
+
+  template<class Archive>
+  FinalNode* unchecked_load_node(Archive& ar)const
+  {
+    Node* node=0;
+    ar>>serialization::make_nvp("pointer",node);
+    return static_cast<FinalNode*>(node);
+  }
+
+  template<class Archive>
+  FinalNode* load_node(Archive& ar)const
+  {
+    Node* node=0;
+    ar>>serialization::make_nvp("pointer",node);
+    check_node(node);
+    return static_cast<FinalNode*>(node);
+  }
+
+  void check_node(Node* node)const
+  {
+    if(node!=0&&!std::binary_search(entries(),entries()+size_,node)){
+      throw_exception(
+        archive::archive_exception(
+          archive::archive_exception::other_exception));
+    }
+  }
+
+  auto_space<Node*,Allocator> spc;
+  std::size_t                 size_;
+  std::size_t                 n;
+  mutable bool                sorted;
+};
+
+} /* namespace multi_index::detail */
+
+} /* namespace multi_index */
+
+} /* namespace boost */
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/index_matcher.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/index_matcher.hpp
new file mode 100644
index 00000000000..34d1f9d5a8d
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/index_matcher.hpp
@@ -0,0 +1,249 @@
+/* Copyright 2003-2015 Joaquin M Lopez Munoz.
+ * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
+ */
+
+#ifndef BOOST_MULTI_INDEX_DETAIL_INDEX_MATCHER_HPP
+#define BOOST_MULTI_INDEX_DETAIL_INDEX_MATCHER_HPP
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
+#include <algorithm>
+#include <boost/noncopyable.hpp>
+#include <boost/multi_index/detail/auto_space.hpp>
+#include <boost/multi_index/detail/raw_ptr.hpp>
+#include <cstddef>
+#include <functional>
+
+namespace boost{
+
+namespace multi_index{
+
+namespace detail{
+
+/* index_matcher compares a sequence of elements against a
+ * base sequence, identifying those elements that belong to the
+ * longest subsequence which is ordered with respect to the base.
+ * For instance, if the base sequence is:
+ *
+ *   0 1 2 3 4 5 6 7 8 9
+ *
+ * and the compared sequence (not necesarilly the same length):
+ *
+ *   1 4 2 3 0 7 8 9
+ *
+ * the elements of the longest ordered subsequence are:
+ *
+ *   1 2 3 7 8 9
+ * 
+ * The algorithm for obtaining such a subsequence is called
+ * Patience Sorting, described in ch. 1 of:
+ *   Aldous, D., Diaconis, P.: "Longest increasing subsequences: from
+ *   patience sorting to the Baik-Deift-Johansson Theorem", Bulletin
+ *   of the American Mathematical Society, vol. 36, no 4, pp. 413-432,
+ *   July 1999.
+ *   http://www.ams.org/bull/1999-36-04/S0273-0979-99-00796-X/
+ *   S0273-0979-99-00796-X.pdf
+ *
+ * This implementation is not fully generic since it assumes that
+ * the sequences given are pointed to by index iterators (having a
+ * get_node() memfun.)
+ */
+
+namespace index_matcher{
+
+/* The algorithm stores the nodes of the base sequence and a number
+ * of "piles" that are dynamically updated during the calculation
+ * stage. From a logical point of view, nodes form an independent
+ * sequence from piles. They are stored together so as to minimize
+ * allocated memory.
+ */
+
+struct entry
+{
+  entry(void* node_,std::size_t pos_=0):node(node_),pos(pos_){}
+
+  /* node stuff */
+
+  void*       node;
+  std::size_t pos;
+  entry*      previous;
+  bool        ordered;
+
+  struct less_by_node
+  {
+    bool operator()(
+      const entry& x,const entry& y)const
+    {
+      return std::less<void*>()(x.node,y.node);
+    }
+  };
+
+  /* pile stuff */
+
+  std::size_t pile_top;
+  entry*      pile_top_entry;
+
+  struct less_by_pile_top
+  {
+    bool operator()(
+      const entry& x,const entry& y)const
+    {
+      return x.pile_top<y.pile_top;
+    }
+  };
+};
+
+/* common code operating on void *'s */
+
+template<typename Allocator>
+class algorithm_base:private noncopyable
+{
+protected:
+  algorithm_base(const Allocator& al,std::size_t size):
+    spc(al,size),size_(size),n_(0),sorted(false)
+  {
+  }
+
+  void add(void* node)
+  {
+    entries()[n_]=entry(node,n_);
+    ++n_;
+  }
+
+  void begin_algorithm()const
+  {
+    if(!sorted){
+      std::sort(entries(),entries()+size_,entry::less_by_node());
+      sorted=true;
+    }
+    num_piles=0;
+  }
+
+  void add_node_to_algorithm(void* node)const
+  {
+    entry* ent=
+      std::lower_bound(
+        entries(),entries()+size_,
+        entry(node),entry::less_by_node()); /* localize entry */
+    ent->ordered=false;
+    std::size_t n=ent->pos;                 /* get its position */
+
+    entry dummy(0);
+    dummy.pile_top=n;
+
+    entry* pile_ent=                        /* find the first available pile */
+      std::lower_bound(                     /* to stack the entry            */
+        entries(),entries()+num_piles,
+        dummy,entry::less_by_pile_top());
+
+    pile_ent->pile_top=n;                   /* stack the entry */
+    pile_ent->pile_top_entry=ent;        
+
+    /* if not the first pile, link entry to top of the preceding pile */
+    if(pile_ent>&entries()[0]){ 
+      ent->previous=(pile_ent-1)->pile_top_entry;
+    }
+
+    if(pile_ent==&entries()[num_piles]){    /* new pile? */
+      ++num_piles;
+    }
+  }
+
+  void finish_algorithm()const
+  {
+    if(num_piles>0){
+      /* Mark those elements which are in their correct position, i.e. those
+       * belonging to the longest increasing subsequence. These are those
+       * elements linked from the top of the last pile.
+       */
+
+      entry* ent=entries()[num_piles-1].pile_top_entry;
+      for(std::size_t n=num_piles;n--;){
+        ent->ordered=true;
+        ent=ent->previous;
+      }
+    }
+  }
+
+  bool is_ordered(void * node)const
+  {
+    return std::lower_bound(
+      entries(),entries()+size_,
+      entry(node),entry::less_by_node())->ordered;
+  }
+
+private:
+  entry* entries()const{return raw_ptr<entry*>(spc.data());}
+
+  auto_space<entry,Allocator> spc;
+  std::size_t                 size_;
+  std::size_t                 n_;
+  mutable bool                sorted;
+  mutable std::size_t         num_piles;
+};
+
+/* The algorithm has three phases:
+ *   - Initialization, during which the nodes of the base sequence are added.
+ *   - Execution.
+ *   - Results querying, through the is_ordered memfun.
+ */
+
+template<typename Node,typename Allocator>
+class algorithm:private algorithm_base<Allocator>
+{
+  typedef algorithm_base<Allocator> super;
+
+public:
+  algorithm(const Allocator& al,std::size_t size):super(al,size){}
+
+  void add(Node* node)
+  {
+    super::add(node);
+  }
+
+  template<typename IndexIterator>
+  void execute(IndexIterator first,IndexIterator last)const
+  {
+    super::begin_algorithm();
+
+    for(IndexIterator it=first;it!=last;++it){
+      add_node_to_algorithm(get_node(it));
+    }
+
+    super::finish_algorithm();
+  }
+
+  bool is_ordered(Node* node)const
+  {
+    return super::is_ordered(node);
+  }
+
+private:
+  void add_node_to_algorithm(Node* node)const
+  {
+    super::add_node_to_algorithm(node);
+  }
+
+  template<typename IndexIterator>
+  static Node* get_node(IndexIterator it)
+  {
+    return static_cast<Node*>(it.get_node());
+  }
+};
+
+} /* namespace multi_index::detail::index_matcher */
+
+} /* namespace multi_index::detail */
+
+} /* namespace multi_index */
+
+} /* namespace boost */
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/index_node_base.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/index_node_base.hpp
new file mode 100644
index 00000000000..1a1f0cae4be
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/index_node_base.hpp
@@ -0,0 +1,135 @@
+/* Copyright 2003-2016 Joaquin M Lopez Munoz.
+ * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
+ */
+
+#ifndef BOOST_MULTI_INDEX_DETAIL_INDEX_NODE_BASE_HPP
+#define BOOST_MULTI_INDEX_DETAIL_INDEX_NODE_BASE_HPP
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
+#include <boost/type_traits/aligned_storage.hpp>
+#include <boost/type_traits/alignment_of.hpp> 
+
+#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
+#include <boost/archive/archive_exception.hpp>
+#include <boost/serialization/access.hpp>
+#include <boost/throw_exception.hpp> 
+#endif
+
+namespace boost{
+
+namespace multi_index{
+
+namespace detail{
+
+/* index_node_base tops the node hierarchy of multi_index_container. It holds
+ * the value of the element contained.
+ */
+
+template<typename Value>
+struct pod_value_holder
+{
+  typename aligned_storage<
+    sizeof(Value),
+    alignment_of<Value>::value
+  >::type                      space;
+};
+
+template<typename Value,typename Allocator>
+struct index_node_base:private pod_value_holder<Value>
+{
+  typedef index_node_base base_type; /* used for serialization purposes */
+  typedef Value           value_type;
+  typedef Allocator       allocator_type;
+
+#include <boost/multi_index/detail/ignore_wstrict_aliasing.hpp>
+
+  value_type& value()
+  {
+    return *reinterpret_cast<value_type*>(&this->space);
+  }
+
+  const value_type& value()const
+  {
+    return *reinterpret_cast<const value_type*>(&this->space);
+  }
+
+#include <boost/multi_index/detail/restore_wstrict_aliasing.hpp>
+
+  static index_node_base* from_value(const value_type* p)
+  {
+    return static_cast<index_node_base *>(
+      reinterpret_cast<pod_value_holder<Value>*>( /* std 9.2.17 */
+        const_cast<value_type*>(p))); 
+  }
+
+private:
+#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
+  friend class boost::serialization::access;
+  
+  /* nodes do not emit any kind of serialization info. They are
+   * fed to Boost.Serialization so that pointers to nodes are
+   * tracked correctly.
+   */
+
+  template<class Archive>
+  void serialize(Archive&,const unsigned int)
+  {
+  }
+#endif
+};
+
+template<typename Node,typename Value>
+Node* node_from_value(const Value* p)
+{
+  typedef typename Node::allocator_type allocator_type;
+  return static_cast<Node*>(
+    index_node_base<Value,allocator_type>::from_value(p));
+}
+
+} /* namespace multi_index::detail */
+
+} /* namespace multi_index */
+
+#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
+/* Index nodes never get constructed directly by Boost.Serialization,
+ * as archives are always fed pointers to previously existent
+ * nodes. So, if this is called it means we are dealing with a
+ * somehow invalid archive.
+ */
+
+#if defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)
+namespace serialization{
+#else
+namespace multi_index{
+namespace detail{
+#endif
+
+template<class Archive,typename Value,typename Allocator>
+inline void load_construct_data(
+  Archive&,boost::multi_index::detail::index_node_base<Value,Allocator>*,
+  const unsigned int)
+{
+  throw_exception(
+    archive::archive_exception(archive::archive_exception::other_exception));
+}
+
+#if defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)
+} /* namespace serialization */
+#else
+} /* namespace multi_index::detail */
+} /* namespace multi_index */
+#endif
+
+#endif
+
+} /* namespace boost */
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/index_saver.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/index_saver.hpp
new file mode 100644
index 00000000000..ae09d4eba4f
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/index_saver.hpp
@@ -0,0 +1,135 @@
+/* Copyright 2003-2013 Joaquin M Lopez Munoz.
+ * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
+ */
+
+#ifndef BOOST_MULTI_INDEX_DETAIL_INDEX_SAVER_HPP
+#define BOOST_MULTI_INDEX_DETAIL_INDEX_SAVER_HPP
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
+#include <boost/multi_index/detail/index_matcher.hpp>
+#include <boost/noncopyable.hpp>
+#include <boost/serialization/nvp.hpp>
+#include <cstddef>
+
+namespace boost{
+
+namespace multi_index{
+
+namespace detail{
+
+/* index_saver accepts a base sequence of previously saved elements
+ * and saves a possibly reordered subsequence in an efficient manner,
+ * serializing only the information needed to rearrange the subsequence
+ * based on the original order of the base.
+ * multi_index_container is in charge of supplying the info about the
+ * base sequence, and each index can subsequently save itself using the
+ * const interface of index_saver.
+ */
+
+template<typename Node,typename Allocator>
+class index_saver:private noncopyable
+{
+public:
+  index_saver(const Allocator& al,std::size_t size):alg(al,size){}
+
+  template<class Archive>
+  void add(Node* node,Archive& ar,const unsigned int)
+  {
+    ar<<serialization::make_nvp("position",*node);
+    alg.add(node);
+  }
+
+  template<class Archive>
+  void add_track(Node* node,Archive& ar,const unsigned int)
+  {
+    ar<<serialization::make_nvp("position",*node);
+  }
+
+  template<typename IndexIterator,class Archive>
+  void save(
+    IndexIterator first,IndexIterator last,Archive& ar,
+    const unsigned int)const
+  {
+    /* calculate ordered positions */
+
+    alg.execute(first,last);
+
+    /* Given a consecutive subsequence of displaced elements
+     * x1,...,xn, the following information is serialized:
+     *
+     *   p0,p1,...,pn,0
+     *
+     * where pi is a pointer to xi and p0 is a pointer to the element
+     * preceding x1. Crealy, from this information is possible to
+     * restore the original order on loading time. If x1 is the first
+     * element in the sequence, the following is serialized instead:
+     *
+     *   p1,p1,...,pn,0
+     *
+     * For each subsequence of n elements, n+2 pointers are serialized.
+     * An optimization policy is applied: consider for instance the
+     * sequence
+     *
+     *   a,B,c,D
+     * 
+     * where B and D are displaced, but c is in its correct position.
+     * Applying the schema described above we would serialize 6 pointers:
+     *
+     *  p(a),p(B),0
+     *  p(c),p(D),0
+     * 
+     * but this can be reduced to 5 pointers by treating c as a displaced
+     * element:
+     *
+     *  p(a),p(B),p(c),p(D),0
+     */
+
+    std::size_t last_saved=3; /* distance to last pointer saved */
+    for(IndexIterator it=first,prev=first;it!=last;prev=it++,++last_saved){
+      if(!alg.is_ordered(get_node(it))){
+        if(last_saved>1)save_node(get_node(prev),ar);
+        save_node(get_node(it),ar);
+        last_saved=0;
+      }
+      else if(last_saved==2)save_node(null_node(),ar);
+    }
+    if(last_saved<=2)save_node(null_node(),ar);
+
+    /* marks the end of the serialization info for [first,last) */
+
+    save_node(null_node(),ar);
+  }
+
+private:
+  template<typename IndexIterator>
+  static Node* get_node(IndexIterator it)
+  {
+    return it.get_node();
+  }
+
+  static Node* null_node(){return 0;}
+
+  template<typename Archive>
+  static void save_node(Node* node,Archive& ar)
+  {
+    ar<<serialization::make_nvp("pointer",node);
+  }
+
+  index_matcher::algorithm<Node,Allocator> alg;
+};
+
+} /* namespace multi_index::detail */
+
+} /* namespace multi_index */
+
+} /* namespace boost */
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/invariant_assert.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/invariant_assert.hpp
new file mode 100644
index 00000000000..c6c547c7c33
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/invariant_assert.hpp
@@ -0,0 +1,21 @@
+/* Copyright 2003-2013 Joaquin M Lopez Munoz.
+ * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
+ */
+
+#ifndef BOOST_MULTI_INDEX_DETAIL_INVARIANT_ASSERT_HPP
+#define BOOST_MULTI_INDEX_DETAIL_INVARIANT_ASSERT_HPP
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#if !defined(BOOST_MULTI_INDEX_INVARIANT_ASSERT)
+#include <boost/assert.hpp>
+#define BOOST_MULTI_INDEX_INVARIANT_ASSERT BOOST_ASSERT
+#endif
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/is_index_list.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/is_index_list.hpp
new file mode 100644
index 00000000000..f6a24218b81
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/is_index_list.hpp
@@ -0,0 +1,40 @@
+/* Copyright 2003-2013 Joaquin M Lopez Munoz.
+ * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
+ */
+
+#ifndef BOOST_MULTI_INDEX_DETAIL_IS_INDEX_LIST_HPP
+#define BOOST_MULTI_INDEX_DETAIL_IS_INDEX_LIST_HPP
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
+#include <boost/mpl/empty.hpp>
+#include <boost/mpl/is_sequence.hpp>
+
+namespace boost{
+
+namespace multi_index{
+
+namespace detail{
+
+template<typename T>
+struct is_index_list
+{
+  BOOST_STATIC_CONSTANT(bool,mpl_sequence=mpl::is_sequence<T>::value);
+  BOOST_STATIC_CONSTANT(bool,non_empty=!mpl::empty<T>::value);
+  BOOST_STATIC_CONSTANT(bool,value=mpl_sequence&&non_empty);
+};
+
+} /* namespace multi_index::detail */
+
+} /* namespace multi_index */
+
+} /* namespace boost */
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/is_transparent.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/is_transparent.hpp
new file mode 100644
index 00000000000..72036d257e2
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/is_transparent.hpp
@@ -0,0 +1,135 @@
+/* Copyright 2003-2014 Joaquin M Lopez Munoz.
+ * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
+ */
+
+#ifndef BOOST_MULTI_INDEX_DETAIL_IS_TRANSPARENT_HPP
+#define BOOST_MULTI_INDEX_DETAIL_IS_TRANSPARENT_HPP
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
+#include <boost/mpl/bool.hpp>
+#include <boost/type_traits/intrinsics.hpp>
+
+namespace boost{
+
+namespace multi_index{
+
+namespace detail{
+
+/* Metafunction that checks if f(arg,arg2) executes without argument type
+ * conversion. By default (i.e. when it cannot be determined) it evaluates to
+ * true.
+ */
+
+template<typename F,typename Arg1,typename Arg2,typename=void>
+struct is_transparent:mpl::true_{};
+
+} /* namespace multi_index::detail */
+
+} /* namespace multi_index */
+
+} /* namespace boost */
+
+#if !defined(BOOST_NO_SFINAE)&&!defined(BOOST_NO_SFINAE_EXPR)&& \
+    !defined(BOOST_NO_CXX11_DECLTYPE)&& \
+    (defined(BOOST_NO_CXX11_FINAL)||defined(BOOST_IS_FINAL))
+
+#include <boost/mpl/and.hpp>
+#include <boost/mpl/not.hpp>
+#include <boost/mpl/or.hpp>
+#include <boost/type_traits/function_traits.hpp>
+#include <boost/type_traits/is_class.hpp>
+#include <boost/type_traits/is_final.hpp>
+#include <boost/type_traits/is_function.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/remove_pointer.hpp>
+#include <boost/utility/declval.hpp>
+#include <boost/utility/enable_if.hpp>
+
+namespace boost{
+
+namespace multi_index{
+
+namespace detail{
+
+struct not_is_transparent_result_type{};
+
+template<typename F,typename Arg1,typename Arg2>
+struct is_transparent_class_helper:F
+{
+  using F::operator();
+  template<typename T,typename Q>
+  not_is_transparent_result_type operator()(const T&,const Q&)const;
+};
+
+template<typename F,typename Arg1,typename Arg2,typename=void>
+struct is_transparent_class:mpl::true_{};
+
+template<typename F,typename Arg1,typename Arg2>
+struct is_transparent_class<
+  F,Arg1,Arg2,
+  typename enable_if<
+    is_same<
+      decltype(
+        declval<const is_transparent_class_helper<F,Arg1,Arg2> >()(
+          declval<const Arg1&>(),declval<const Arg2&>())
+      ),
+      not_is_transparent_result_type
+    >
+  >::type
+>:mpl::false_{};
+
+template<typename F,typename Arg1,typename Arg2>
+struct is_transparent<
+  F,Arg1,Arg2,
+  typename enable_if<
+    mpl::and_<
+      is_class<F>,
+      mpl::not_<is_final<F> > /* is_transparent_class_helper derives from F */
+    >
+  >::type
+>:is_transparent_class<F,Arg1,Arg2>{};
+
+template<typename F,typename Arg1,typename Arg2,typename=void>
+struct is_transparent_function:mpl::true_{};
+
+template<typename F,typename Arg1,typename Arg2>
+struct is_transparent_function<
+  F,Arg1,Arg2,
+  typename enable_if<
+    mpl::or_<
+      mpl::not_<mpl::or_<
+        is_same<typename function_traits<F>::arg1_type,const Arg1&>,
+        is_same<typename function_traits<F>::arg1_type,Arg1>
+      > >,
+      mpl::not_<mpl::or_<
+        is_same<typename function_traits<F>::arg2_type,const Arg2&>,
+        is_same<typename function_traits<F>::arg2_type,Arg2>
+      > >
+    >
+  >::type
+>:mpl::false_{};
+
+template<typename F,typename Arg1,typename Arg2>
+struct is_transparent<
+  F,Arg1,Arg2,
+  typename enable_if<
+    is_function<typename remove_pointer<F>::type>
+  >::type
+>:is_transparent_function<typename remove_pointer<F>::type,Arg1,Arg2>{};
+
+} /* namespace multi_index::detail */
+
+} /* namespace multi_index */
+
+} /* namespace boost */
+
+#endif
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/iter_adaptor.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/iter_adaptor.hpp
new file mode 100644
index 00000000000..7a032350b36
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/iter_adaptor.hpp
@@ -0,0 +1,321 @@
+/* Copyright 2003-2013 Joaquin M Lopez Munoz.
+ * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
+ */
+
+#ifndef BOOST_MULTI_INDEX_DETAIL_ITER_ADAPTOR_HPP
+#define BOOST_MULTI_INDEX_DETAIL_ITER_ADAPTOR_HPP
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
+#include <boost/mpl/apply.hpp>
+#include <boost/operators.hpp>
+
+namespace boost{
+
+namespace multi_index{
+
+namespace detail{
+
+/* Poor man's version of boost::iterator_adaptor. Used instead of the
+ * original as compile times for the latter are significantly higher.
+ * The interface is not replicated exactly, only to the extent necessary
+ * for internal consumption.
+ */
+
+/* NB. The purpose of the (non-inclass) global operators ==, < and - defined
+ * above is to partially alleviate a problem of MSVC++ 6.0 by * which
+ * friend-injected operators on T are not visible if T is instantiated only
+ * in template code where T is a dependent type.
+ */
+
+class iter_adaptor_access
+{
+public:
+  template<class Class>
+    static typename Class::reference dereference(const Class& x)
+  {
+    return x.dereference();
+  }
+
+  template<class Class>
+  static bool equal(const Class& x,const Class& y)
+  {
+    return x.equal(y);
+  }
+
+  template<class Class>
+  static void increment(Class& x)
+  {
+    x.increment();
+  }
+
+  template<class Class>
+  static void decrement(Class& x)
+  {
+    x.decrement();
+  }
+
+  template<class Class>
+  static void advance(Class& x,typename Class::difference_type n)
+  {
+    x.advance(n);
+  }
+
+  template<class Class>
+  static typename Class::difference_type distance_to(
+    const Class& x,const Class& y)
+  {
+    return x.distance_to(y);
+  }
+};
+
+template<typename Category>
+struct iter_adaptor_selector;
+
+template<class Derived,class Base>
+class forward_iter_adaptor_base:
+  public forward_iterator_helper<
+    Derived,
+    typename Base::value_type,
+    typename Base::difference_type,
+    typename Base::pointer,
+    typename Base::reference>
+{
+public:
+  typedef typename Base::reference reference;
+
+  reference operator*()const
+  {
+    return iter_adaptor_access::dereference(final());
+  }
+
+  friend bool operator==(const Derived& x,const Derived& y)
+  {
+    return iter_adaptor_access::equal(x,y);
+  }
+
+  Derived& operator++()
+  {
+    iter_adaptor_access::increment(final());
+    return final();
+  }
+
+private:
+  Derived& final(){return *static_cast<Derived*>(this);}
+  const Derived& final()const{return *static_cast<const Derived*>(this);}
+};
+
+template<class Derived,class Base>
+bool operator==(
+  const forward_iter_adaptor_base<Derived,Base>& x,
+  const forward_iter_adaptor_base<Derived,Base>& y)
+{
+  return iter_adaptor_access::equal(
+    static_cast<const Derived&>(x),static_cast<const Derived&>(y));
+}
+
+template<>
+struct iter_adaptor_selector<std::forward_iterator_tag>
+{
+  template<class Derived,class Base>
+  struct apply
+  {
+    typedef forward_iter_adaptor_base<Derived,Base> type;
+  };
+};
+
+template<class Derived,class Base>
+class bidirectional_iter_adaptor_base:
+  public bidirectional_iterator_helper<
+    Derived,
+    typename Base::value_type,
+    typename Base::difference_type,
+    typename Base::pointer,
+    typename Base::reference>
+{
+public:
+  typedef typename Base::reference reference;
+
+  reference operator*()const
+  {
+    return iter_adaptor_access::dereference(final());
+  }
+
+  friend bool operator==(const Derived& x,const Derived& y)
+  {
+    return iter_adaptor_access::equal(x,y);
+  }
+
+  Derived& operator++()
+  {
+    iter_adaptor_access::increment(final());
+    return final();
+  }
+
+  Derived& operator--()
+  {
+    iter_adaptor_access::decrement(final());
+    return final();
+  }
+
+private:
+  Derived& final(){return *static_cast<Derived*>(this);}
+  const Derived& final()const{return *static_cast<const Derived*>(this);}
+};
+
+template<class Derived,class Base>
+bool operator==(
+  const bidirectional_iter_adaptor_base<Derived,Base>& x,
+  const bidirectional_iter_adaptor_base<Derived,Base>& y)
+{
+  return iter_adaptor_access::equal(
+    static_cast<const Derived&>(x),static_cast<const Derived&>(y));
+}
+
+template<>
+struct iter_adaptor_selector<std::bidirectional_iterator_tag>
+{
+  template<class Derived,class Base>
+  struct apply
+  {
+    typedef bidirectional_iter_adaptor_base<Derived,Base> type;
+  };
+};
+
+template<class Derived,class Base>
+class random_access_iter_adaptor_base:
+  public random_access_iterator_helper<
+    Derived,
+    typename Base::value_type,
+    typename Base::difference_type,
+    typename Base::pointer,
+    typename Base::reference>
+{
+public:
+  typedef typename Base::reference       reference;
+  typedef typename Base::difference_type difference_type;
+
+  reference operator*()const
+  {
+    return iter_adaptor_access::dereference(final());
+  }
+
+  friend bool operator==(const Derived& x,const Derived& y)
+  {
+    return iter_adaptor_access::equal(x,y);
+  }
+
+  friend bool operator<(const Derived& x,const Derived& y)
+  {
+    return iter_adaptor_access::distance_to(x,y)>0;
+  }
+
+  Derived& operator++()
+  {
+    iter_adaptor_access::increment(final());
+    return final();
+  }
+
+  Derived& operator--()
+  {
+    iter_adaptor_access::decrement(final());
+    return final();
+  }
+
+  Derived& operator+=(difference_type n)
+  {
+    iter_adaptor_access::advance(final(),n);
+    return final();
+  }
+
+  Derived& operator-=(difference_type n)
+  {
+    iter_adaptor_access::advance(final(),-n);
+    return final();
+  }
+
+  friend difference_type operator-(const Derived& x,const Derived& y)
+  {
+    return iter_adaptor_access::distance_to(y,x);
+  }
+
+private:
+  Derived& final(){return *static_cast<Derived*>(this);}
+  const Derived& final()const{return *static_cast<const Derived*>(this);}
+};
+
+template<class Derived,class Base>
+bool operator==(
+  const random_access_iter_adaptor_base<Derived,Base>& x,
+  const random_access_iter_adaptor_base<Derived,Base>& y)
+{
+  return iter_adaptor_access::equal(
+    static_cast<const Derived&>(x),static_cast<const Derived&>(y));
+}
+
+template<class Derived,class Base>
+bool operator<(
+  const random_access_iter_adaptor_base<Derived,Base>& x,
+  const random_access_iter_adaptor_base<Derived,Base>& y)
+{
+  return iter_adaptor_access::distance_to(
+    static_cast<const Derived&>(x),static_cast<const Derived&>(y))>0;
+}
+
+template<class Derived,class Base>
+typename random_access_iter_adaptor_base<Derived,Base>::difference_type
+operator-(
+  const random_access_iter_adaptor_base<Derived,Base>& x,
+  const random_access_iter_adaptor_base<Derived,Base>& y)
+{
+  return iter_adaptor_access::distance_to(
+    static_cast<const Derived&>(y),static_cast<const Derived&>(x));
+}
+
+template<>
+struct iter_adaptor_selector<std::random_access_iterator_tag>
+{
+  template<class Derived,class Base>
+  struct apply
+  {
+    typedef random_access_iter_adaptor_base<Derived,Base> type;
+  };
+};
+
+template<class Derived,class Base>
+struct iter_adaptor_base
+{
+  typedef iter_adaptor_selector<
+    typename Base::iterator_category> selector;
+  typedef typename mpl::apply2<
+    selector,Derived,Base>::type      type;
+};
+
+template<class Derived,class Base>
+class iter_adaptor:public iter_adaptor_base<Derived,Base>::type
+{
+protected:
+  iter_adaptor(){}
+  explicit iter_adaptor(const Base& b_):b(b_){}
+
+  const Base& base_reference()const{return b;}
+  Base&       base_reference(){return b;}
+
+private:
+  Base b;
+};
+
+} /* namespace multi_index::detail */
+
+} /* namespace multi_index */
+
+} /* namespace boost */
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/modify_key_adaptor.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/modify_key_adaptor.hpp
new file mode 100644
index 00000000000..6df89b18386
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/modify_key_adaptor.hpp
@@ -0,0 +1,49 @@
+/* Copyright 2003-2013 Joaquin M Lopez Munoz.
+ * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
+ */
+
+#ifndef BOOST_MULTI_INDEX_DETAIL_MODIFY_KEY_ADAPTOR_HPP
+#define BOOST_MULTI_INDEX_DETAIL_MODIFY_KEY_ADAPTOR_HPP
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+namespace boost{
+
+namespace multi_index{
+
+namespace detail{
+
+/* Functional adaptor to resolve modify_key as a call to modify.
+ * Preferred over compose_f_gx and stuff cause it eliminates problems
+ * with references to references, dealing with function pointers, etc.
+ */
+
+template<typename Fun,typename Value,typename KeyFromValue>
+struct modify_key_adaptor
+{
+
+  modify_key_adaptor(Fun f_,KeyFromValue kfv_):f(f_),kfv(kfv_){}
+
+  void operator()(Value& x)
+  {
+    f(kfv(x));
+  }
+
+private:
+  Fun          f;
+  KeyFromValue kfv;
+};
+
+} /* namespace multi_index::detail */
+
+} /* namespace multi_index */
+
+} /* namespace boost */
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/no_duplicate_tags.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/no_duplicate_tags.hpp
new file mode 100644
index 00000000000..ba216ed82cf
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/no_duplicate_tags.hpp
@@ -0,0 +1,97 @@
+/* Copyright 2003-2013 Joaquin M Lopez Munoz.
+ * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
+ */
+
+#ifndef BOOST_MULTI_INDEX_DETAIL_NO_DUPLICATE_TAGS_HPP
+#define BOOST_MULTI_INDEX_DETAIL_NO_DUPLICATE_TAGS_HPP
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
+#include <boost/mpl/fold.hpp>
+#include <boost/mpl/set/set0.hpp>
+
+namespace boost{
+
+namespace multi_index{
+
+namespace detail{
+
+/* no_duplicate_tags check at compile-time that a tag list
+ * has no duplicate tags.
+ * The algorithm deserves some explanation: tags
+ * are sequentially inserted into a mpl::set if they were
+ * not already present. Due to the magic of mpl::set
+ * (mpl::has_key is contant time), this operation takes linear
+ * time, and even MSVC++ 6.5 handles it gracefully (other obvious
+ * solutions are quadratic.)
+ */
+
+struct duplicate_tag_mark{};
+
+struct duplicate_tag_marker
+{
+  template <typename MplSet,typename Tag>
+  struct apply
+  {
+    typedef mpl::s_item<
+      typename mpl::if_<mpl::has_key<MplSet,Tag>,duplicate_tag_mark,Tag>::type,
+      MplSet
+    > type;
+  };
+};
+
+template<typename TagList>
+struct no_duplicate_tags
+{
+  typedef typename mpl::fold<
+    TagList,
+    mpl::set0<>,
+    duplicate_tag_marker
+  >::type aux;
+ 
+  BOOST_STATIC_CONSTANT(
+    bool,value=!(mpl::has_key<aux,duplicate_tag_mark>::value));
+};
+
+/* Variant for an index list: duplication is checked
+ * across all the indices.
+ */
+
+struct duplicate_tag_list_marker
+{
+  template <typename MplSet,typename Index>
+  struct apply:mpl::fold<
+    BOOST_DEDUCED_TYPENAME Index::tag_list,
+    MplSet,
+    duplicate_tag_marker>
+  {
+  };
+};
+
+template<typename IndexList>
+struct no_duplicate_tags_in_index_list
+{
+  typedef typename mpl::fold<
+    IndexList,
+    mpl::set0<>,
+    duplicate_tag_list_marker
+  >::type aux;
+ 
+  BOOST_STATIC_CONSTANT(
+    bool,value=!(mpl::has_key<aux,duplicate_tag_mark>::value));
+};
+
+} /* namespace multi_index::detail */
+
+} /* namespace multi_index */
+
+} /* namespace boost */
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/node_type.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/node_type.hpp
new file mode 100644
index 00000000000..7fe85cf968b
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/node_type.hpp
@@ -0,0 +1,66 @@
+/* Copyright 2003-2013 Joaquin M Lopez Munoz.
+ * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
+ */
+
+#ifndef BOOST_MULTI_INDEX_DETAIL_NODE_TYPE_HPP
+#define BOOST_MULTI_INDEX_DETAIL_NODE_TYPE_HPP
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
+#include <boost/detail/workaround.hpp>
+#include <boost/mpl/bind.hpp>
+#include <boost/mpl/reverse_iter_fold.hpp>
+#include <boost/mpl/deref.hpp>
+#include <boost/multi_index_container_fwd.hpp>
+#include <boost/multi_index/detail/header_holder.hpp>
+#include <boost/multi_index/detail/index_node_base.hpp>
+#include <boost/multi_index/detail/is_index_list.hpp>
+#include <boost/static_assert.hpp>
+
+namespace boost{
+
+namespace multi_index{
+
+namespace detail{
+
+/* MPL machinery to construct the internal node type associated to an
+ * index list.
+ */
+
+struct index_node_applier
+{
+  template<typename IndexSpecifierIterator,typename Super>
+  struct apply
+  {
+    typedef typename mpl::deref<IndexSpecifierIterator>::type index_specifier;
+    typedef typename index_specifier::
+      BOOST_NESTED_TEMPLATE node_class<Super>::type type;
+  }; 
+};
+
+template<typename Value,typename IndexSpecifierList,typename Allocator>
+struct multi_index_node_type
+{
+  BOOST_STATIC_ASSERT(detail::is_index_list<IndexSpecifierList>::value);
+
+  typedef typename mpl::reverse_iter_fold<
+    IndexSpecifierList,
+    index_node_base<Value,Allocator>,
+    mpl::bind2<index_node_applier,mpl::_2,mpl::_1>
+  >::type type;
+};
+
+} /* namespace multi_index::detail */
+
+} /* namespace multi_index */
+
+} /* namespace boost */
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/ord_index_args.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/ord_index_args.hpp
new file mode 100644
index 00000000000..3e2641f2f4d
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/ord_index_args.hpp
@@ -0,0 +1,83 @@
+/* Copyright 2003-2013 Joaquin M Lopez Munoz.
+ * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
+ */
+
+#ifndef BOOST_MULTI_INDEX_DETAIL_ORD_INDEX_ARGS_HPP
+#define BOOST_MULTI_INDEX_DETAIL_ORD_INDEX_ARGS_HPP
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
+#include <boost/mpl/aux_/na.hpp>
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/identity.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/multi_index/tag.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <functional>
+
+namespace boost{
+
+namespace multi_index{
+
+namespace detail{
+
+/* Oredered index specifiers can be instantiated in two forms:
+ *
+ *   (ordered_unique|ordered_non_unique)<
+ *     KeyFromValue,Compare=std::less<KeyFromValue::result_type> >
+ *   (ordered_unique|ordered_non_unique)<
+ *     TagList,KeyFromValue,Compare=std::less<KeyFromValue::result_type> >
+ *
+ * index_args implements the machinery to accept this argument-dependent
+ * polymorphism.
+ */
+
+template<typename KeyFromValue>
+struct index_args_default_compare
+{
+  typedef std::less<typename KeyFromValue::result_type> type;
+};
+
+template<typename Arg1,typename Arg2,typename Arg3>
+struct ordered_index_args
+{
+  typedef is_tag<Arg1> full_form;
+
+  typedef typename mpl::if_<
+    full_form,
+    Arg1,
+    tag< > >::type                                   tag_list_type;
+  typedef typename mpl::if_<
+    full_form,
+    Arg2,
+    Arg1>::type                                      key_from_value_type;
+  typedef typename mpl::if_<
+    full_form,
+    Arg3,
+    Arg2>::type                                      supplied_compare_type;
+  typedef typename mpl::eval_if<
+    mpl::is_na<supplied_compare_type>,
+    index_args_default_compare<key_from_value_type>,
+    mpl::identity<supplied_compare_type>
+  >::type                                            compare_type;
+
+  BOOST_STATIC_ASSERT(is_tag<tag_list_type>::value);
+  BOOST_STATIC_ASSERT(!mpl::is_na<key_from_value_type>::value);
+  BOOST_STATIC_ASSERT(!mpl::is_na<compare_type>::value);
+};
+
+} /* namespace multi_index::detail */
+
+} /* namespace multi_index */
+
+} /* namespace boost */
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/ord_index_impl.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/ord_index_impl.hpp
new file mode 100644
index 00000000000..040cb989630
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/ord_index_impl.hpp
@@ -0,0 +1,1567 @@
+/* Copyright 2003-2015 Joaquin M Lopez Munoz.
+ * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
+ *
+ * The internal implementation of red-black trees is based on that of SGI STL
+ * stl_tree.h file: 
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ */
+
+#ifndef BOOST_MULTI_INDEX_DETAIL_ORD_INDEX_IMPL_HPP
+#define BOOST_MULTI_INDEX_DETAIL_ORD_INDEX_IMPL_HPP
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
+#include <algorithm>
+#include <boost/call_traits.hpp>
+#include <boost/detail/no_exceptions_support.hpp>
+#include <boost/detail/workaround.hpp>
+#include <boost/foreach_fwd.hpp>
+#include <boost/iterator/reverse_iterator.hpp>
+#include <boost/move/core.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/mpl/push_front.hpp>
+#include <boost/multi_index/detail/access_specifier.hpp>
+#include <boost/multi_index/detail/bidir_node_iterator.hpp>
+#include <boost/multi_index/detail/do_not_copy_elements_tag.hpp>
+#include <boost/multi_index/detail/index_node_base.hpp>
+#include <boost/multi_index/detail/modify_key_adaptor.hpp>
+#include <boost/multi_index/detail/ord_index_node.hpp>
+#include <boost/multi_index/detail/ord_index_ops.hpp>
+#include <boost/multi_index/detail/safe_mode.hpp>
+#include <boost/multi_index/detail/scope_guard.hpp>
+#include <boost/multi_index/detail/unbounded.hpp>
+#include <boost/multi_index/detail/value_compare.hpp>
+#include <boost/multi_index/detail/vartempl_support.hpp>
+#include <boost/multi_index/detail/ord_index_impl_fwd.hpp>
+#include <boost/ref.hpp>
+#include <boost/tuple/tuple.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <utility>
+
+#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
+#include <initializer_list>
+#endif
+
+#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
+#include <boost/archive/archive_exception.hpp>
+#include <boost/bind.hpp>
+#include <boost/multi_index/detail/duplicates_iterator.hpp>
+#include <boost/throw_exception.hpp> 
+#endif
+
+#if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING)
+#define BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT_OF(x)                    \
+  detail::scope_guard BOOST_JOIN(check_invariant_,__LINE__)=                 \
+    detail::make_obj_guard(x,&ordered_index_impl::check_invariant_);         \
+  BOOST_JOIN(check_invariant_,__LINE__).touch();
+#define BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT                          \
+  BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT_OF(*this)
+#else
+#define BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT_OF(x)
+#define BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT
+#endif
+
+namespace boost{
+
+namespace multi_index{
+
+namespace detail{
+
+/* ordered_index adds a layer of ordered indexing to a given Super and accepts
+ * an augmenting policy for optional addition of order statistics.
+ */
+
+/* Most of the implementation of unique and non-unique indices is
+ * shared. We tell from one another on instantiation time by using
+ * these tags.
+ */
+
+struct ordered_unique_tag{};
+struct ordered_non_unique_tag{};
+
+template<
+  typename KeyFromValue,typename Compare,
+  typename SuperMeta,typename TagList,typename Category,typename AugmentPolicy
+>
+class ordered_index;
+
+template<
+  typename KeyFromValue,typename Compare,
+  typename SuperMeta,typename TagList,typename Category,typename AugmentPolicy
+>
+class ordered_index_impl:
+  BOOST_MULTI_INDEX_PROTECTED_IF_MEMBER_TEMPLATE_FRIENDS SuperMeta::type
+
+#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
+  ,public safe_mode::safe_container<
+    ordered_index_impl<
+      KeyFromValue,Compare,SuperMeta,TagList,Category,AugmentPolicy> >
+#endif
+
+{ 
+#if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING)&&\
+    BOOST_WORKAROUND(__MWERKS__,<=0x3003)
+/* The "ISO C++ Template Parser" option in CW8.3 has a problem with the
+ * lifetime of const references bound to temporaries --precisely what
+ * scopeguards are.
+ */
+
+#pragma parse_mfunc_templ off
+#endif
+
+  typedef typename SuperMeta::type                   super;
+
+protected:
+  typedef ordered_index_node<
+    AugmentPolicy,typename super::node_type>         node_type;
+
+protected: /* for the benefit of AugmentPolicy::augmented_interface */
+  typedef typename node_type::impl_type              node_impl_type;
+  typedef typename node_impl_type::pointer           node_impl_pointer;
+
+public:
+  /* types */
+
+  typedef typename KeyFromValue::result_type         key_type;
+  typedef typename node_type::value_type             value_type;
+  typedef KeyFromValue                               key_from_value;
+  typedef Compare                                    key_compare;
+  typedef value_comparison<
+    value_type,KeyFromValue,Compare>                 value_compare;
+  typedef tuple<key_from_value,key_compare>          ctor_args;
+  typedef typename super::final_allocator_type       allocator_type;
+  typedef typename allocator_type::reference         reference;
+  typedef typename allocator_type::const_reference   const_reference;
+
+#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
+  typedef safe_mode::safe_iterator<
+    bidir_node_iterator<node_type>,
+    ordered_index_impl>                              iterator;
+#else
+  typedef bidir_node_iterator<node_type>             iterator;
+#endif
+
+  typedef iterator                                   const_iterator;
+
+  typedef std::size_t                                size_type;      
+  typedef std::ptrdiff_t                             difference_type;
+  typedef typename allocator_type::pointer           pointer;
+  typedef typename allocator_type::const_pointer     const_pointer;
+  typedef typename
+    boost::reverse_iterator<iterator>                reverse_iterator;
+  typedef typename
+    boost::reverse_iterator<const_iterator>          const_reverse_iterator;
+  typedef TagList                                    tag_list;
+
+protected:
+  typedef typename super::final_node_type            final_node_type;
+  typedef tuples::cons<
+    ctor_args, 
+    typename super::ctor_args_list>                  ctor_args_list;
+  typedef typename mpl::push_front<
+    typename super::index_type_list,
+    ordered_index<
+      KeyFromValue,Compare,
+      SuperMeta,TagList,Category,AugmentPolicy
+    > >::type                                        index_type_list;
+  typedef typename mpl::push_front<
+    typename super::iterator_type_list,
+    iterator>::type    iterator_type_list;
+  typedef typename mpl::push_front<
+    typename super::const_iterator_type_list,
+    const_iterator>::type                            const_iterator_type_list;
+  typedef typename super::copy_map_type              copy_map_type;
+
+#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
+  typedef typename super::index_saver_type           index_saver_type;
+  typedef typename super::index_loader_type          index_loader_type;
+#endif
+
+protected:
+#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
+  typedef safe_mode::safe_container<
+    ordered_index_impl>                              safe_super;
+#endif
+
+  typedef typename call_traits<
+    value_type>::param_type                          value_param_type;
+  typedef typename call_traits<
+    key_type>::param_type                            key_param_type;
+
+  /* Needed to avoid commas in BOOST_MULTI_INDEX_OVERLOADS_TO_VARTEMPL
+   * expansion.
+   */
+
+  typedef std::pair<iterator,bool>                   emplace_return_type;
+
+public:
+
+  /* construct/copy/destroy
+   * Default and copy ctors are in the protected section as indices are
+   * not supposed to be created on their own. No range ctor either.
+   * Assignment operators defined at ordered_index rather than here.
+   */
+
+  allocator_type get_allocator()const BOOST_NOEXCEPT
+  {
+    return this->final().get_allocator();
+  }
+
+  /* iterators */
+
+  iterator
+    begin()BOOST_NOEXCEPT{return make_iterator(leftmost());}
+  const_iterator
+    begin()const BOOST_NOEXCEPT{return make_iterator(leftmost());}
+  iterator
+    end()BOOST_NOEXCEPT{return make_iterator(header());}
+  const_iterator
+    end()const BOOST_NOEXCEPT{return make_iterator(header());}
+  reverse_iterator
+    rbegin()BOOST_NOEXCEPT{return boost::make_reverse_iterator(end());}
+  const_reverse_iterator
+    rbegin()const BOOST_NOEXCEPT{return boost::make_reverse_iterator(end());}
+  reverse_iterator
+    rend()BOOST_NOEXCEPT{return boost::make_reverse_iterator(begin());}
+  const_reverse_iterator
+    rend()const BOOST_NOEXCEPT{return boost::make_reverse_iterator(begin());}
+  const_iterator
+    cbegin()const BOOST_NOEXCEPT{return begin();}
+  const_iterator
+    cend()const BOOST_NOEXCEPT{return end();}
+  const_reverse_iterator
+    crbegin()const BOOST_NOEXCEPT{return rbegin();}
+  const_reverse_iterator
+    crend()const BOOST_NOEXCEPT{return rend();}
+ 
+  iterator iterator_to(const value_type& x)
+  {
+    return make_iterator(node_from_value<node_type>(&x));
+  }
+
+  const_iterator iterator_to(const value_type& x)const
+  {
+    return make_iterator(node_from_value<node_type>(&x));
+  }
+
+  /* capacity */
+
+  bool      empty()const BOOST_NOEXCEPT{return this->final_empty_();}
+  size_type size()const BOOST_NOEXCEPT{return this->final_size_();}
+  size_type max_size()const BOOST_NOEXCEPT{return this->final_max_size_();}
+
+  /* modifiers */
+
+  BOOST_MULTI_INDEX_OVERLOADS_TO_VARTEMPL(
+    emplace_return_type,emplace,emplace_impl)
+
+  BOOST_MULTI_INDEX_OVERLOADS_TO_VARTEMPL_EXTRA_ARG(
+    iterator,emplace_hint,emplace_hint_impl,iterator,position)
+
+  std::pair<iterator,bool> insert(const value_type& x)
+  {
+    BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT;
+    std::pair<final_node_type*,bool> p=this->final_insert_(x);
+    return std::pair<iterator,bool>(make_iterator(p.first),p.second);
+  }
+
+  std::pair<iterator,bool> insert(BOOST_RV_REF(value_type) x)
+  {
+    BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT;
+    std::pair<final_node_type*,bool> p=this->final_insert_rv_(x);
+    return std::pair<iterator,bool>(make_iterator(p.first),p.second);
+  }
+
+  iterator insert(iterator position,const value_type& x)
+  {
+    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
+    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
+    BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT;
+    std::pair<final_node_type*,bool> p=this->final_insert_(
+      x,static_cast<final_node_type*>(position.get_node()));
+    return make_iterator(p.first);
+  }
+    
+  iterator insert(iterator position,BOOST_RV_REF(value_type) x)
+  {
+    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
+    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
+    BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT;
+    std::pair<final_node_type*,bool> p=this->final_insert_rv_(
+      x,static_cast<final_node_type*>(position.get_node()));
+    return make_iterator(p.first);
+  }
+
+  template<typename InputIterator>
+  void insert(InputIterator first,InputIterator last)
+  {
+    BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT;
+    node_type* hint=header(); /* end() */
+    for(;first!=last;++first){
+      hint=this->final_insert_ref_(
+        *first,static_cast<final_node_type*>(hint)).first;
+      node_type::increment(hint);
+    }
+  }
+
+#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
+  void insert(std::initializer_list<value_type> list)
+  {
+    insert(list.begin(),list.end());
+  }
+#endif
+
+  iterator erase(iterator position)
+  {
+    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
+    BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(position);
+    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
+    BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT;
+    this->final_erase_(static_cast<final_node_type*>(position++.get_node()));
+    return position;
+  }
+  
+  size_type erase(key_param_type x)
+  {
+    BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT;
+    std::pair<iterator,iterator> p=equal_range(x);
+    size_type s=0;
+    while(p.first!=p.second){
+      p.first=erase(p.first);
+      ++s;
+    }
+    return s;
+  }
+
+  iterator erase(iterator first,iterator last)
+  {
+    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(first);
+    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(last);
+    BOOST_MULTI_INDEX_CHECK_IS_OWNER(first,*this);
+    BOOST_MULTI_INDEX_CHECK_IS_OWNER(last,*this);
+    BOOST_MULTI_INDEX_CHECK_VALID_RANGE(first,last);
+    BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT;
+    while(first!=last){
+      first=erase(first);
+    }
+    return first;
+  }
+
+  bool replace(iterator position,const value_type& x)
+  {
+    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
+    BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(position);
+    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
+    BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT;
+    return this->final_replace_(
+      x,static_cast<final_node_type*>(position.get_node()));
+  }
+
+  bool replace(iterator position,BOOST_RV_REF(value_type) x)
+  {
+    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
+    BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(position);
+    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
+    BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT;
+    return this->final_replace_rv_(
+      x,static_cast<final_node_type*>(position.get_node()));
+  }
+
+  template<typename Modifier>
+  bool modify(iterator position,Modifier mod)
+  {
+    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
+    BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(position);
+    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
+    BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT;
+
+#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
+    /* MSVC++ 6.0 optimizer on safe mode code chokes if this
+     * this is not added. Left it for all compilers as it does no
+     * harm.
+     */
+
+    position.detach();
+#endif
+
+    return this->final_modify_(
+      mod,static_cast<final_node_type*>(position.get_node()));
+  }
+
+  template<typename Modifier,typename Rollback>
+  bool modify(iterator position,Modifier mod,Rollback back_)
+  {
+    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
+    BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(position);
+    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
+    BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT;
+
+#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
+    /* MSVC++ 6.0 optimizer on safe mode code chokes if this
+     * this is not added. Left it for all compilers as it does no
+     * harm.
+     */
+
+    position.detach();
+#endif
+
+    return this->final_modify_(
+      mod,back_,static_cast<final_node_type*>(position.get_node()));
+  }
+  
+  template<typename Modifier>
+  bool modify_key(iterator position,Modifier mod)
+  {
+    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
+    BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(position);
+    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
+    BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT;
+    return modify(
+      position,modify_key_adaptor<Modifier,value_type,KeyFromValue>(mod,key));
+  }
+
+  template<typename Modifier,typename Rollback>
+  bool modify_key(iterator position,Modifier mod,Rollback back_)
+  {
+    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
+    BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(position);
+    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
+    BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT;
+    return modify(
+      position,
+      modify_key_adaptor<Modifier,value_type,KeyFromValue>(mod,key),
+      modify_key_adaptor<Rollback,value_type,KeyFromValue>(back_,key));
+  }
+
+  void swap(
+    ordered_index<
+      KeyFromValue,Compare,SuperMeta,TagList,Category,AugmentPolicy>& x)
+  {
+    BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT;
+    BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT_OF(x);
+    this->final_swap_(x.final());
+  }
+
+  void clear()BOOST_NOEXCEPT
+  {
+    BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT;
+    this->final_clear_();
+  }
+
+  /* observers */
+
+  key_from_value key_extractor()const{return key;}
+  key_compare    key_comp()const{return comp_;}
+  value_compare  value_comp()const{return value_compare(key,comp_);}
+
+  /* set operations */
+
+  /* Internally, these ops rely on const_iterator being the same
+   * type as iterator.
+   */
+
+  template<typename CompatibleKey>
+  iterator find(const CompatibleKey& x)const
+  {
+    return make_iterator(ordered_index_find(root(),header(),key,x,comp_));
+  }
+
+  template<typename CompatibleKey,typename CompatibleCompare>
+  iterator find(
+    const CompatibleKey& x,const CompatibleCompare& comp)const
+  {
+    return make_iterator(ordered_index_find(root(),header(),key,x,comp));
+  }
+
+  template<typename CompatibleKey>
+  size_type count(const CompatibleKey& x)const
+  {
+    return count(x,comp_);
+  }
+
+  template<typename CompatibleKey,typename CompatibleCompare>
+  size_type count(const CompatibleKey& x,const CompatibleCompare& comp)const
+  {
+    std::pair<iterator,iterator> p=equal_range(x,comp);
+    size_type n=std::distance(p.first,p.second);
+    return n;
+  }
+
+  template<typename CompatibleKey>
+  iterator lower_bound(const CompatibleKey& x)const
+  {
+    return make_iterator(
+      ordered_index_lower_bound(root(),header(),key,x,comp_));
+  }
+
+  template<typename CompatibleKey,typename CompatibleCompare>
+  iterator lower_bound(
+    const CompatibleKey& x,const CompatibleCompare& comp)const
+  {
+    return make_iterator(
+      ordered_index_lower_bound(root(),header(),key,x,comp));
+  }
+
+  template<typename CompatibleKey>
+  iterator upper_bound(const CompatibleKey& x)const
+  {
+    return make_iterator(
+      ordered_index_upper_bound(root(),header(),key,x,comp_));
+  }
+
+  template<typename CompatibleKey,typename CompatibleCompare>
+  iterator upper_bound(
+    const CompatibleKey& x,const CompatibleCompare& comp)const
+  {
+    return make_iterator(
+      ordered_index_upper_bound(root(),header(),key,x,comp));
+  }
+
+  template<typename CompatibleKey>
+  std::pair<iterator,iterator> equal_range(
+    const CompatibleKey& x)const
+  {
+    std::pair<node_type*,node_type*> p=
+      ordered_index_equal_range(root(),header(),key,x,comp_);
+    return std::pair<iterator,iterator>(
+      make_iterator(p.first),make_iterator(p.second));
+  }
+
+  template<typename CompatibleKey,typename CompatibleCompare>
+  std::pair<iterator,iterator> equal_range(
+    const CompatibleKey& x,const CompatibleCompare& comp)const
+  {
+    std::pair<node_type*,node_type*> p=
+      ordered_index_equal_range(root(),header(),key,x,comp);
+    return std::pair<iterator,iterator>(
+      make_iterator(p.first),make_iterator(p.second));
+  }
+
+  /* range */
+
+  template<typename LowerBounder,typename UpperBounder>
+  std::pair<iterator,iterator>
+  range(LowerBounder lower,UpperBounder upper)const
+  {
+    typedef typename mpl::if_<
+      is_same<LowerBounder,unbounded_type>,
+      BOOST_DEDUCED_TYPENAME mpl::if_<
+        is_same<UpperBounder,unbounded_type>,
+        both_unbounded_tag,
+        lower_unbounded_tag
+      >::type,
+      BOOST_DEDUCED_TYPENAME mpl::if_<
+        is_same<UpperBounder,unbounded_type>,
+        upper_unbounded_tag,
+        none_unbounded_tag
+      >::type
+    >::type dispatch;
+
+    return range(lower,upper,dispatch());
+  }
+
+BOOST_MULTI_INDEX_PROTECTED_IF_MEMBER_TEMPLATE_FRIENDS:
+  ordered_index_impl(const ctor_args_list& args_list,const allocator_type& al):
+    super(args_list.get_tail(),al),
+    key(tuples::get<0>(args_list.get_head())),
+    comp_(tuples::get<1>(args_list.get_head()))
+  {
+    empty_initialize();
+  }
+
+  ordered_index_impl(
+    const ordered_index_impl<
+      KeyFromValue,Compare,SuperMeta,TagList,Category,AugmentPolicy>& x):
+    super(x),
+
+#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
+    safe_super(),
+#endif
+
+    key(x.key),
+    comp_(x.comp_)
+  {
+    /* Copy ctor just takes the key and compare objects from x. The rest is
+     * done in a subsequent call to copy_().
+     */
+  }
+
+  ordered_index_impl(
+     const ordered_index_impl<
+       KeyFromValue,Compare,SuperMeta,TagList,Category,AugmentPolicy>& x,
+     do_not_copy_elements_tag):
+    super(x,do_not_copy_elements_tag()),
+
+#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
+    safe_super(),
+#endif
+
+    key(x.key),
+    comp_(x.comp_)
+  {
+    empty_initialize();
+  }
+
+  ~ordered_index_impl()
+  {
+    /* the container is guaranteed to be empty by now */
+  }
+
+#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
+  iterator       make_iterator(node_type* node){return iterator(node,this);}
+  const_iterator make_iterator(node_type* node)const
+    {return const_iterator(node,const_cast<ordered_index_impl*>(this));}
+#else
+  iterator       make_iterator(node_type* node){return iterator(node);}
+  const_iterator make_iterator(node_type* node)const
+                   {return const_iterator(node);}
+#endif
+
+  void copy_(
+    const ordered_index_impl<
+      KeyFromValue,Compare,SuperMeta,TagList,Category,AugmentPolicy>& x,
+    const copy_map_type& map)
+  {
+    if(!x.root()){
+      empty_initialize();
+    }
+    else{
+      header()->color()=x.header()->color();
+      AugmentPolicy::copy(x.header()->impl(),header()->impl());
+
+      node_type* root_cpy=map.find(static_cast<final_node_type*>(x.root()));
+      header()->parent()=root_cpy->impl();
+
+      node_type* leftmost_cpy=map.find(
+        static_cast<final_node_type*>(x.leftmost()));
+      header()->left()=leftmost_cpy->impl();
+
+      node_type* rightmost_cpy=map.find(
+        static_cast<final_node_type*>(x.rightmost()));
+      header()->right()=rightmost_cpy->impl();
+
+      typedef typename copy_map_type::const_iterator copy_map_iterator;
+      for(copy_map_iterator it=map.begin(),it_end=map.end();it!=it_end;++it){
+        node_type* org=it->first;
+        node_type* cpy=it->second;
+
+        cpy->color()=org->color();
+        AugmentPolicy::copy(org->impl(),cpy->impl());
+
+        node_impl_pointer parent_org=org->parent();
+        if(parent_org==node_impl_pointer(0))cpy->parent()=node_impl_pointer(0);
+        else{
+          node_type* parent_cpy=map.find(
+            static_cast<final_node_type*>(node_type::from_impl(parent_org)));
+          cpy->parent()=parent_cpy->impl();
+          if(parent_org->left()==org->impl()){
+            parent_cpy->left()=cpy->impl();
+          }
+          else if(parent_org->right()==org->impl()){
+            /* header() does not satisfy this nor the previous check */
+            parent_cpy->right()=cpy->impl();
+          }
+        }
+
+        if(org->left()==node_impl_pointer(0))
+          cpy->left()=node_impl_pointer(0);
+        if(org->right()==node_impl_pointer(0))
+          cpy->right()=node_impl_pointer(0);
+      }
+    }
+    
+    super::copy_(x,map);
+  }
+
+  template<typename Variant>
+  final_node_type* insert_(
+    value_param_type v,final_node_type*& x,Variant variant)
+  {
+    link_info inf;
+    if(!link_point(key(v),inf,Category())){
+      return static_cast<final_node_type*>(node_type::from_impl(inf.pos));
+    }
+
+    final_node_type* res=super::insert_(v,x,variant);
+    if(res==x){
+      node_impl_type::link(
+        static_cast<node_type*>(x)->impl(),inf.side,inf.pos,header()->impl());
+    }
+    return res;
+  }
+
+  template<typename Variant>
+  final_node_type* insert_(
+    value_param_type v,node_type* position,final_node_type*& x,Variant variant)
+  {
+    link_info inf;
+    if(!hinted_link_point(key(v),position,inf,Category())){
+      return static_cast<final_node_type*>(node_type::from_impl(inf.pos));
+    }
+
+    final_node_type* res=super::insert_(v,position,x,variant);
+    if(res==x){
+      node_impl_type::link(
+        static_cast<node_type*>(x)->impl(),inf.side,inf.pos,header()->impl());
+    }
+    return res;
+  }
+
+  void erase_(node_type* x)
+  {
+    node_impl_type::rebalance_for_erase(
+      x->impl(),header()->parent(),header()->left(),header()->right());
+    super::erase_(x);
+
+#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
+    detach_iterators(x);
+#endif
+  }
+
+  void delete_all_nodes_()
+  {
+    delete_all_nodes(root());
+  }
+
+  void clear_()
+  {
+    super::clear_();
+    empty_initialize();
+
+#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
+    safe_super::detach_dereferenceable_iterators();
+#endif
+  }
+
+  void swap_(
+    ordered_index_impl<
+      KeyFromValue,Compare,SuperMeta,TagList,Category,AugmentPolicy>& x)
+  {
+    std::swap(key,x.key);
+    std::swap(comp_,x.comp_);
+
+#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
+    safe_super::swap(x);
+#endif
+
+    super::swap_(x);
+  }
+
+  void swap_elements_(
+    ordered_index_impl<
+      KeyFromValue,Compare,SuperMeta,TagList,Category,AugmentPolicy>& x)
+  {
+#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
+    safe_super::swap(x);
+#endif
+
+    super::swap_elements_(x);
+  }
+
+  template<typename Variant>
+  bool replace_(value_param_type v,node_type* x,Variant variant)
+  {
+    if(in_place(v,x,Category())){
+      return super::replace_(v,x,variant);
+    }
+
+    node_type* next=x;
+    node_type::increment(next);
+
+    node_impl_type::rebalance_for_erase(
+      x->impl(),header()->parent(),header()->left(),header()->right());
+
+    BOOST_TRY{
+      link_info inf;
+      if(link_point(key(v),inf,Category())&&super::replace_(v,x,variant)){
+        node_impl_type::link(x->impl(),inf.side,inf.pos,header()->impl());
+        return true;
+      }
+      node_impl_type::restore(x->impl(),next->impl(),header()->impl());
+      return false;
+    }
+    BOOST_CATCH(...){
+      node_impl_type::restore(x->impl(),next->impl(),header()->impl());
+      BOOST_RETHROW;
+    }
+    BOOST_CATCH_END
+  }
+
+  bool modify_(node_type* x)
+  {
+    bool b;
+    BOOST_TRY{
+      b=in_place(x->value(),x,Category());
+    }
+    BOOST_CATCH(...){
+      erase_(x);
+      BOOST_RETHROW;
+    }
+    BOOST_CATCH_END
+    if(!b){
+      node_impl_type::rebalance_for_erase(
+        x->impl(),header()->parent(),header()->left(),header()->right());
+      BOOST_TRY{
+        link_info inf;
+        if(!link_point(key(x->value()),inf,Category())){
+          super::erase_(x);
+
+#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
+          detach_iterators(x);
+#endif
+          return false;
+        }
+        node_impl_type::link(x->impl(),inf.side,inf.pos,header()->impl());
+      }
+      BOOST_CATCH(...){
+        super::erase_(x);
+
+#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
+        detach_iterators(x);
+#endif
+
+        BOOST_RETHROW;
+      }
+      BOOST_CATCH_END
+    }
+
+    BOOST_TRY{
+      if(!super::modify_(x)){
+        node_impl_type::rebalance_for_erase(
+          x->impl(),header()->parent(),header()->left(),header()->right());
+
+#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
+        detach_iterators(x);
+#endif
+
+        return false;
+      }
+      else return true;
+    }
+    BOOST_CATCH(...){
+      node_impl_type::rebalance_for_erase(
+        x->impl(),header()->parent(),header()->left(),header()->right());
+
+#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
+      detach_iterators(x);
+#endif
+
+      BOOST_RETHROW;
+    }
+    BOOST_CATCH_END
+  }
+
+  bool modify_rollback_(node_type* x)
+  {
+    if(in_place(x->value(),x,Category())){
+      return super::modify_rollback_(x);
+    }
+
+    node_type* next=x;
+    node_type::increment(next);
+
+    node_impl_type::rebalance_for_erase(
+      x->impl(),header()->parent(),header()->left(),header()->right());
+
+    BOOST_TRY{
+      link_info inf;
+      if(link_point(key(x->value()),inf,Category())&&
+         super::modify_rollback_(x)){
+        node_impl_type::link(x->impl(),inf.side,inf.pos,header()->impl());
+        return true;
+      }
+      node_impl_type::restore(x->impl(),next->impl(),header()->impl());
+      return false;
+    }
+    BOOST_CATCH(...){
+      node_impl_type::restore(x->impl(),next->impl(),header()->impl());
+      BOOST_RETHROW;
+    }
+    BOOST_CATCH_END
+  }
+
+#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
+  /* serialization */
+
+  template<typename Archive>
+  void save_(
+    Archive& ar,const unsigned int version,const index_saver_type& sm)const
+  {
+    save_(ar,version,sm,Category());
+  }
+
+  template<typename Archive>
+  void load_(Archive& ar,const unsigned int version,const index_loader_type& lm)
+  {
+    load_(ar,version,lm,Category());
+  }
+#endif
+
+#if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING)
+  /* invariant stuff */
+
+  bool invariant_()const
+  {
+    if(size()==0||begin()==end()){
+      if(size()!=0||begin()!=end()||
+         header()->left()!=header()->impl()||
+         header()->right()!=header()->impl())return false;
+    }
+    else{
+      if((size_type)std::distance(begin(),end())!=size())return false;
+
+      std::size_t len=node_impl_type::black_count(
+        leftmost()->impl(),root()->impl());
+      for(const_iterator it=begin(),it_end=end();it!=it_end;++it){
+        node_type* x=it.get_node();
+        node_type* left_x=node_type::from_impl(x->left());
+        node_type* right_x=node_type::from_impl(x->right());
+
+        if(x->color()==red){
+          if((left_x&&left_x->color()==red)||
+             (right_x&&right_x->color()==red))return false;
+        }
+        if(left_x&&comp_(key(x->value()),key(left_x->value())))return false;
+        if(right_x&&comp_(key(right_x->value()),key(x->value())))return false;
+        if(!left_x&&!right_x&&
+           node_impl_type::black_count(x->impl(),root()->impl())!=len)
+          return false;
+        if(!AugmentPolicy::invariant(x->impl()))return false;
+      }
+    
+      if(leftmost()->impl()!=node_impl_type::minimum(root()->impl()))
+        return false;
+      if(rightmost()->impl()!=node_impl_type::maximum(root()->impl()))
+        return false;
+    }
+
+    return super::invariant_();
+  }
+
+  
+  /* This forwarding function eases things for the boost::mem_fn construct
+   * in BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT. Actually,
+   * final_check_invariant is already an inherited member function of
+   * ordered_index_impl.
+   */
+  void check_invariant_()const{this->final_check_invariant_();}
+#endif
+
+protected: /* for the benefit of AugmentPolicy::augmented_interface */
+  node_type* header()const{return this->final_header();}
+  node_type* root()const{return node_type::from_impl(header()->parent());}
+  node_type* leftmost()const{return node_type::from_impl(header()->left());}
+  node_type* rightmost()const{return node_type::from_impl(header()->right());}
+
+private:
+  void empty_initialize()
+  {
+    header()->color()=red;
+    /* used to distinguish header() from root, in iterator.operator++ */
+    
+    header()->parent()=node_impl_pointer(0);
+    header()->left()=header()->impl();
+    header()->right()=header()->impl();
+  }
+
+  struct link_info
+  {
+    /* coverity[uninit_ctor]: suppress warning */
+    link_info():side(to_left){}
+
+    ordered_index_side side;
+    node_impl_pointer  pos;
+  };
+
+  bool link_point(key_param_type k,link_info& inf,ordered_unique_tag)
+  {
+    node_type* y=header();
+    node_type* x=root();
+    bool c=true;
+    while(x){
+      y=x;
+      c=comp_(k,key(x->value()));
+      x=node_type::from_impl(c?x->left():x->right());
+    }
+    node_type* yy=y;
+    if(c){
+      if(yy==leftmost()){
+        inf.side=to_left;
+        inf.pos=y->impl();
+        return true;
+      }
+      else node_type::decrement(yy);
+    }
+
+    if(comp_(key(yy->value()),k)){
+      inf.side=c?to_left:to_right;
+      inf.pos=y->impl();
+      return true;
+    }
+    else{
+      inf.pos=yy->impl();
+      return false;
+    }
+  }
+
+  bool link_point(key_param_type k,link_info& inf,ordered_non_unique_tag)
+  {
+    node_type* y=header();
+    node_type* x=root();
+    bool c=true;
+    while (x){
+     y=x;
+     c=comp_(k,key(x->value()));
+     x=node_type::from_impl(c?x->left():x->right());
+    }
+    inf.side=c?to_left:to_right;
+    inf.pos=y->impl();
+    return true;
+  }
+
+  bool lower_link_point(key_param_type k,link_info& inf,ordered_non_unique_tag)
+  {
+    node_type* y=header();
+    node_type* x=root();
+    bool c=false;
+    while (x){
+     y=x;
+     c=comp_(key(x->value()),k);
+     x=node_type::from_impl(c?x->right():x->left());
+    }
+    inf.side=c?to_right:to_left;
+    inf.pos=y->impl();
+    return true;
+  }
+
+  bool hinted_link_point(
+    key_param_type k,node_type* position,link_info& inf,ordered_unique_tag)
+  {
+    if(position->impl()==header()->left()){ 
+      if(size()>0&&comp_(k,key(position->value()))){
+        inf.side=to_left;
+        inf.pos=position->impl();
+        return true;
+      }
+      else return link_point(k,inf,ordered_unique_tag());
+    } 
+    else if(position==header()){ 
+      if(comp_(key(rightmost()->value()),k)){
+        inf.side=to_right;
+        inf.pos=rightmost()->impl();
+        return true;
+      }
+      else return link_point(k,inf,ordered_unique_tag());
+    } 
+    else{
+      node_type* before=position;
+      node_type::decrement(before);
+      if(comp_(key(before->value()),k)&&comp_(k,key(position->value()))){
+        if(before->right()==node_impl_pointer(0)){
+          inf.side=to_right;
+          inf.pos=before->impl();
+          return true;
+        }
+        else{
+          inf.side=to_left;
+          inf.pos=position->impl();
+          return true;
+        }
+      } 
+      else return link_point(k,inf,ordered_unique_tag());
+    }
+  }
+
+  bool hinted_link_point(
+    key_param_type k,node_type* position,link_info& inf,ordered_non_unique_tag)
+  {
+    if(position->impl()==header()->left()){ 
+      if(size()>0&&!comp_(key(position->value()),k)){
+        inf.side=to_left;
+        inf.pos=position->impl();
+        return true;
+      }
+      else return lower_link_point(k,inf,ordered_non_unique_tag());
+    } 
+    else if(position==header()){
+      if(!comp_(k,key(rightmost()->value()))){
+        inf.side=to_right;
+        inf.pos=rightmost()->impl();
+        return true;
+      }
+      else return link_point(k,inf,ordered_non_unique_tag());
+    } 
+    else{
+      node_type* before=position;
+      node_type::decrement(before);
+      if(!comp_(k,key(before->value()))){
+        if(!comp_(key(position->value()),k)){
+          if(before->right()==node_impl_pointer(0)){
+            inf.side=to_right;
+            inf.pos=before->impl();
+            return true;
+          }
+          else{
+            inf.side=to_left;
+            inf.pos=position->impl();
+            return true;
+          }
+        }
+        else return lower_link_point(k,inf,ordered_non_unique_tag());
+      } 
+      else return link_point(k,inf,ordered_non_unique_tag());
+    }
+  }
+
+  void delete_all_nodes(node_type* x)
+  {
+    if(!x)return;
+
+    delete_all_nodes(node_type::from_impl(x->left()));
+    delete_all_nodes(node_type::from_impl(x->right()));
+    this->final_delete_node_(static_cast<final_node_type*>(x));
+  }
+
+  bool in_place(value_param_type v,node_type* x,ordered_unique_tag)
+  {
+    node_type* y;
+    if(x!=leftmost()){
+      y=x;
+      node_type::decrement(y);
+      if(!comp_(key(y->value()),key(v)))return false;
+    }
+
+    y=x;
+    node_type::increment(y);
+    return y==header()||comp_(key(v),key(y->value()));
+  }
+
+  bool in_place(value_param_type v,node_type* x,ordered_non_unique_tag)
+  {
+    node_type* y;
+    if(x!=leftmost()){
+      y=x;
+      node_type::decrement(y);
+      if(comp_(key(v),key(y->value())))return false;
+    }
+
+    y=x;
+    node_type::increment(y);
+    return y==header()||!comp_(key(y->value()),key(v));
+  }
+
+#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
+  void detach_iterators(node_type* x)
+  {
+    iterator it=make_iterator(x);
+    safe_mode::detach_equivalent_iterators(it);
+  }
+#endif
+
+  template<BOOST_MULTI_INDEX_TEMPLATE_PARAM_PACK>
+  std::pair<iterator,bool> emplace_impl(BOOST_MULTI_INDEX_FUNCTION_PARAM_PACK)
+  {
+    BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT;
+    std::pair<final_node_type*,bool>p=
+      this->final_emplace_(BOOST_MULTI_INDEX_FORWARD_PARAM_PACK);
+    return std::pair<iterator,bool>(make_iterator(p.first),p.second);
+  }
+
+  template<BOOST_MULTI_INDEX_TEMPLATE_PARAM_PACK>
+  iterator emplace_hint_impl(
+    iterator position,BOOST_MULTI_INDEX_FUNCTION_PARAM_PACK)
+  {
+    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
+    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
+    BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT;
+    std::pair<final_node_type*,bool>p=
+      this->final_emplace_hint_(
+        static_cast<final_node_type*>(position.get_node()),
+        BOOST_MULTI_INDEX_FORWARD_PARAM_PACK);
+    return make_iterator(p.first);
+  }
+
+  template<typename LowerBounder,typename UpperBounder>
+  std::pair<iterator,iterator>
+  range(LowerBounder lower,UpperBounder upper,none_unbounded_tag)const
+  {
+    node_type* y=header();
+    node_type* z=root();
+
+    while(z){
+      if(!lower(key(z->value()))){
+        z=node_type::from_impl(z->right());
+      }
+      else if(!upper(key(z->value()))){
+        y=z;
+        z=node_type::from_impl(z->left());
+      }
+      else{
+        return std::pair<iterator,iterator>(
+          make_iterator(
+            lower_range(node_type::from_impl(z->left()),z,lower)),
+          make_iterator(
+            upper_range(node_type::from_impl(z->right()),y,upper)));
+      }
+    }
+
+    return std::pair<iterator,iterator>(make_iterator(y),make_iterator(y));
+  }
+
+  template<typename LowerBounder,typename UpperBounder>
+  std::pair<iterator,iterator>
+  range(LowerBounder,UpperBounder upper,lower_unbounded_tag)const
+  {
+    return std::pair<iterator,iterator>(
+      begin(),
+      make_iterator(upper_range(root(),header(),upper)));
+  }
+
+  template<typename LowerBounder,typename UpperBounder>
+  std::pair<iterator,iterator>
+  range(LowerBounder lower,UpperBounder,upper_unbounded_tag)const
+  {
+    return std::pair<iterator,iterator>(
+      make_iterator(lower_range(root(),header(),lower)),
+      end());
+  }
+
+  template<typename LowerBounder,typename UpperBounder>
+  std::pair<iterator,iterator>
+  range(LowerBounder,UpperBounder,both_unbounded_tag)const
+  {
+    return std::pair<iterator,iterator>(begin(),end());
+  }
+
+  template<typename LowerBounder>
+  node_type * lower_range(node_type* top,node_type* y,LowerBounder lower)const
+  {
+    while(top){
+      if(lower(key(top->value()))){
+        y=top;
+        top=node_type::from_impl(top->left());
+      }
+      else top=node_type::from_impl(top->right());
+    }
+
+    return y;
+  }
+
+  template<typename UpperBounder>
+  node_type * upper_range(node_type* top,node_type* y,UpperBounder upper)const
+  {
+    while(top){
+      if(!upper(key(top->value()))){
+        y=top;
+        top=node_type::from_impl(top->left());
+      }
+      else top=node_type::from_impl(top->right());
+    }
+
+    return y;
+  }
+
+#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
+  template<typename Archive>
+  void save_(
+    Archive& ar,const unsigned int version,const index_saver_type& sm,
+    ordered_unique_tag)const
+  {
+    super::save_(ar,version,sm);
+  }
+
+  template<typename Archive>
+  void load_(
+    Archive& ar,const unsigned int version,const index_loader_type& lm,
+    ordered_unique_tag)
+  {
+    super::load_(ar,version,lm);
+  }
+
+  template<typename Archive>
+  void save_(
+    Archive& ar,const unsigned int version,const index_saver_type& sm,
+    ordered_non_unique_tag)const
+  {
+    typedef duplicates_iterator<node_type,value_compare> dup_iterator;
+
+    sm.save(
+      dup_iterator(begin().get_node(),end().get_node(),value_comp()),
+      dup_iterator(end().get_node(),value_comp()),
+      ar,version);
+    super::save_(ar,version,sm);
+  }
+
+  template<typename Archive>
+  void load_(
+    Archive& ar,const unsigned int version,const index_loader_type& lm,
+    ordered_non_unique_tag)
+  {
+    lm.load(
+      ::boost::bind(
+        &ordered_index_impl::rearranger,this,
+        ::boost::arg<1>(),::boost::arg<2>()),
+      ar,version);
+    super::load_(ar,version,lm);
+  }
+
+  void rearranger(node_type* position,node_type *x)
+  {
+    if(!position||comp_(key(position->value()),key(x->value()))){
+      position=lower_bound(key(x->value())).get_node();
+    }
+    else if(comp_(key(x->value()),key(position->value()))){
+      /* inconsistent rearrangement */
+      throw_exception(
+        archive::archive_exception(
+          archive::archive_exception::other_exception));
+    }
+    else node_type::increment(position);
+
+    if(position!=x){
+      node_impl_type::rebalance_for_erase(
+        x->impl(),header()->parent(),header()->left(),header()->right());
+      node_impl_type::restore(
+        x->impl(),position->impl(),header()->impl());
+    }
+  }
+#endif /* serialization */
+
+protected: /* for the benefit of AugmentPolicy::augmented_interface */
+  key_from_value key;
+  key_compare    comp_;
+
+#if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING)&&\
+    BOOST_WORKAROUND(__MWERKS__,<=0x3003)
+#pragma parse_mfunc_templ reset
+#endif
+};
+
+template<
+  typename KeyFromValue,typename Compare,
+  typename SuperMeta,typename TagList,typename Category,typename AugmentPolicy
+>
+class ordered_index:
+  public AugmentPolicy::template augmented_interface<
+    ordered_index_impl<
+      KeyFromValue,Compare,SuperMeta,TagList,Category,AugmentPolicy
+    >
+  >::type
+{
+  typedef typename AugmentPolicy::template
+    augmented_interface<
+      ordered_index_impl<
+        KeyFromValue,Compare,
+        SuperMeta,TagList,Category,AugmentPolicy
+      >
+    >::type                                       super;
+public:
+  typedef typename super::ctor_args_list          ctor_args_list;
+  typedef typename super::allocator_type          allocator_type;
+  typedef typename super::iterator                iterator;
+
+  /* construct/copy/destroy
+   * Default and copy ctors are in the protected section as indices are
+   * not supposed to be created on their own. No range ctor either.
+   */
+
+  ordered_index& operator=(const ordered_index& x)
+  {
+    this->final()=x.final();
+    return *this;
+  }
+
+#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
+  ordered_index& operator=(
+    std::initializer_list<BOOST_DEDUCED_TYPENAME super::value_type> list)
+  {
+    this->final()=list;
+    return *this;
+  }
+#endif
+
+protected:
+  ordered_index(
+    const ctor_args_list& args_list,const allocator_type& al):
+    super(args_list,al){}
+
+  ordered_index(const ordered_index& x):super(x){};
+
+  ordered_index(const ordered_index& x,do_not_copy_elements_tag):
+    super(x,do_not_copy_elements_tag()){};
+};
+
+/* comparison */
+
+template<
+  typename KeyFromValue1,typename Compare1,
+  typename SuperMeta1,typename TagList1,typename Category1,
+  typename AugmentPolicy1,
+  typename KeyFromValue2,typename Compare2,
+  typename SuperMeta2,typename TagList2,typename Category2,
+  typename AugmentPolicy2
+>
+bool operator==(
+  const ordered_index<
+    KeyFromValue1,Compare1,SuperMeta1,TagList1,Category1,AugmentPolicy1>& x,
+  const ordered_index<
+    KeyFromValue2,Compare2,SuperMeta2,TagList2,Category2,AugmentPolicy2>& y)
+{
+  return x.size()==y.size()&&std::equal(x.begin(),x.end(),y.begin());
+}
+
+template<
+  typename KeyFromValue1,typename Compare1,
+  typename SuperMeta1,typename TagList1,typename Category1,
+  typename AugmentPolicy1,
+  typename KeyFromValue2,typename Compare2,
+  typename SuperMeta2,typename TagList2,typename Category2,
+  typename AugmentPolicy2
+>
+bool operator<(
+  const ordered_index<
+    KeyFromValue1,Compare1,SuperMeta1,TagList1,Category1,AugmentPolicy1>& x,
+  const ordered_index<
+    KeyFromValue2,Compare2,SuperMeta2,TagList2,Category2,AugmentPolicy2>& y)
+{
+  return std::lexicographical_compare(x.begin(),x.end(),y.begin(),y.end());
+}
+
+template<
+  typename KeyFromValue1,typename Compare1,
+  typename SuperMeta1,typename TagList1,typename Category1,
+  typename AugmentPolicy1,
+  typename KeyFromValue2,typename Compare2,
+  typename SuperMeta2,typename TagList2,typename Category2,
+  typename AugmentPolicy2
+>
+bool operator!=(
+  const ordered_index<
+    KeyFromValue1,Compare1,SuperMeta1,TagList1,Category1,AugmentPolicy1>& x,
+  const ordered_index<
+    KeyFromValue2,Compare2,SuperMeta2,TagList2,Category2,AugmentPolicy2>& y)
+{
+  return !(x==y);
+}
+
+template<
+  typename KeyFromValue1,typename Compare1,
+  typename SuperMeta1,typename TagList1,typename Category1,
+  typename AugmentPolicy1,
+  typename KeyFromValue2,typename Compare2,
+  typename SuperMeta2,typename TagList2,typename Category2,
+  typename AugmentPolicy2
+>
+bool operator>(
+  const ordered_index<
+    KeyFromValue1,Compare1,SuperMeta1,TagList1,Category1,AugmentPolicy1>& x,
+  const ordered_index<
+    KeyFromValue2,Compare2,SuperMeta2,TagList2,Category2,AugmentPolicy2>& y)
+{
+  return y<x;
+}
+
+template<
+  typename KeyFromValue1,typename Compare1,
+  typename SuperMeta1,typename TagList1,typename Category1,
+  typename AugmentPolicy1,
+  typename KeyFromValue2,typename Compare2,
+  typename SuperMeta2,typename TagList2,typename Category2,
+  typename AugmentPolicy2
+>
+bool operator>=(
+  const ordered_index<
+    KeyFromValue1,Compare1,SuperMeta1,TagList1,Category1,AugmentPolicy1>& x,
+  const ordered_index<
+    KeyFromValue2,Compare2,SuperMeta2,TagList2,Category2,AugmentPolicy2>& y)
+{
+  return !(x<y);
+}
+
+template<
+  typename KeyFromValue1,typename Compare1,
+  typename SuperMeta1,typename TagList1,typename Category1,
+  typename AugmentPolicy1,
+  typename KeyFromValue2,typename Compare2,
+  typename SuperMeta2,typename TagList2,typename Category2,
+  typename AugmentPolicy2
+>
+bool operator<=(
+  const ordered_index<
+    KeyFromValue1,Compare1,SuperMeta1,TagList1,Category1,AugmentPolicy1>& x,
+  const ordered_index<
+    KeyFromValue2,Compare2,SuperMeta2,TagList2,Category2,AugmentPolicy2>& y)
+{
+  return !(x>y);
+}
+
+/*  specialized algorithms */
+
+template<
+  typename KeyFromValue,typename Compare,
+  typename SuperMeta,typename TagList,typename Category,typename AugmentPolicy
+>
+void swap(
+  ordered_index<
+    KeyFromValue,Compare,SuperMeta,TagList,Category,AugmentPolicy>& x,
+  ordered_index<
+    KeyFromValue,Compare,SuperMeta,TagList,Category,AugmentPolicy>& y)
+{
+  x.swap(y);
+}
+
+} /* namespace multi_index::detail */
+
+} /* namespace multi_index */
+
+} /* namespace boost */
+
+/* Boost.Foreach compatibility */
+
+template<
+  typename KeyFromValue,typename Compare,
+  typename SuperMeta,typename TagList,typename Category,typename AugmentPolicy
+>
+inline boost::mpl::true_* boost_foreach_is_noncopyable(
+  boost::multi_index::detail::ordered_index<
+    KeyFromValue,Compare,SuperMeta,TagList,Category,AugmentPolicy>*&,
+  boost_foreach_argument_dependent_lookup_hack)
+{
+  return 0;
+}
+
+#undef BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT
+#undef BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT_OF
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/ord_index_impl_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/ord_index_impl_fwd.hpp
new file mode 100644
index 00000000000..6590ef05fdd
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/ord_index_impl_fwd.hpp
@@ -0,0 +1,128 @@
+/* Copyright 2003-2015 Joaquin M Lopez Munoz.
+ * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
+ */
+
+#ifndef BOOST_MULTI_INDEX_DETAIL_ORD_INDEX_IMPL_FWD_HPP
+#define BOOST_MULTI_INDEX_DETAIL_ORD_INDEX_IMPL_FWD_HPP
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+namespace boost{
+
+namespace multi_index{
+
+namespace detail{
+
+template<
+  typename KeyFromValue,typename Compare,
+  typename SuperMeta,typename TagList,typename Category,typename AugmentPolicy
+>
+class ordered_index;
+
+template<
+  typename KeyFromValue1,typename Compare1,
+  typename SuperMeta1,typename TagList1,typename Category1,
+  typename AugmentPolicy1,
+  typename KeyFromValue2,typename Compare2,
+  typename SuperMeta2,typename TagList2,typename Category2,
+  typename AugmentPolicy2
+>
+bool operator==(
+  const ordered_index<
+    KeyFromValue1,Compare1,SuperMeta1,TagList1,Category1,AugmentPolicy1>& x,
+  const ordered_index<
+    KeyFromValue2,Compare2,SuperMeta2,TagList2,Category2,AugmentPolicy2>& y);
+
+template<
+  typename KeyFromValue1,typename Compare1,
+  typename SuperMeta1,typename TagList1,typename Category1,
+  typename AugmentPolicy1,
+  typename KeyFromValue2,typename Compare2,
+  typename SuperMeta2,typename TagList2,typename Category2,
+  typename AugmentPolicy2
+>
+bool operator<(
+  const ordered_index<
+    KeyFromValue1,Compare1,SuperMeta1,TagList1,Category1,AugmentPolicy1>& x,
+  const ordered_index<
+    KeyFromValue2,Compare2,SuperMeta2,TagList2,Category2,AugmentPolicy2>& y);
+
+template<
+  typename KeyFromValue1,typename Compare1,
+  typename SuperMeta1,typename TagList1,typename Category1,
+  typename AugmentPolicy1,
+  typename KeyFromValue2,typename Compare2,
+  typename SuperMeta2,typename TagList2,typename Category2,
+  typename AugmentPolicy2
+>
+bool operator!=(
+  const ordered_index<
+    KeyFromValue1,Compare1,SuperMeta1,TagList1,Category1,AugmentPolicy1>& x,
+  const ordered_index<
+    KeyFromValue2,Compare2,SuperMeta2,TagList2,Category2,AugmentPolicy2>& y);
+
+template<
+  typename KeyFromValue1,typename Compare1,
+  typename SuperMeta1,typename TagList1,typename Category1,
+  typename AugmentPolicy1,
+  typename KeyFromValue2,typename Compare2,
+  typename SuperMeta2,typename TagList2,typename Category2,
+  typename AugmentPolicy2
+>
+bool operator>(
+  const ordered_index<
+    KeyFromValue1,Compare1,SuperMeta1,TagList1,Category1,AugmentPolicy1>& x,
+  const ordered_index<
+    KeyFromValue2,Compare2,SuperMeta2,TagList2,Category2,AugmentPolicy2>& y);
+
+template<
+  typename KeyFromValue1,typename Compare1,
+  typename SuperMeta1,typename TagList1,typename Category1,
+  typename AugmentPolicy1,
+  typename KeyFromValue2,typename Compare2,
+  typename SuperMeta2,typename TagList2,typename Category2,
+  typename AugmentPolicy2
+>
+bool operator>=(
+  const ordered_index<
+    KeyFromValue1,Compare1,SuperMeta1,TagList1,Category1,AugmentPolicy1>& x,
+  const ordered_index<
+    KeyFromValue2,Compare2,SuperMeta2,TagList2,Category2,AugmentPolicy2>& y);
+
+template<
+  typename KeyFromValue1,typename Compare1,
+  typename SuperMeta1,typename TagList1,typename Category1,
+  typename AugmentPolicy1,
+  typename KeyFromValue2,typename Compare2,
+  typename SuperMeta2,typename TagList2,typename Category2,
+  typename AugmentPolicy2
+>
+bool operator<=(
+  const ordered_index<
+    KeyFromValue1,Compare1,SuperMeta1,TagList1,Category1,AugmentPolicy1>& x,
+  const ordered_index<
+    KeyFromValue2,Compare2,SuperMeta2,TagList2,Category2,AugmentPolicy2>& y);
+
+template<
+  typename KeyFromValue,typename Compare,
+  typename SuperMeta,typename TagList,typename Category,typename AugmentPolicy
+>
+void swap(
+  ordered_index<
+    KeyFromValue,Compare,SuperMeta,TagList,Category,AugmentPolicy>& x,
+  ordered_index<
+    KeyFromValue,Compare,SuperMeta,TagList,Category,AugmentPolicy>& y);
+
+} /* namespace multi_index::detail */
+
+} /* namespace multi_index */
+
+} /* namespace boost */
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/ord_index_node.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/ord_index_node.hpp
new file mode 100644
index 00000000000..e7af0377fb9
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/ord_index_node.hpp
@@ -0,0 +1,658 @@
+/* Copyright 2003-2015 Joaquin M Lopez Munoz.
+ * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
+ *
+ * The internal implementation of red-black trees is based on that of SGI STL
+ * stl_tree.h file: 
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ */
+
+#ifndef BOOST_MULTI_INDEX_DETAIL_ORD_INDEX_NODE_HPP
+#define BOOST_MULTI_INDEX_DETAIL_ORD_INDEX_NODE_HPP
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
+#include <cstddef>
+#include <boost/detail/allocator_utilities.hpp>
+#include <boost/multi_index/detail/raw_ptr.hpp>
+
+#if !defined(BOOST_MULTI_INDEX_DISABLE_COMPRESSED_ORDERED_INDEX_NODES)
+#include <boost/mpl/and.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/multi_index/detail/uintptr_type.hpp>
+#include <boost/type_traits/alignment_of.hpp>
+#include <boost/type_traits/is_same.hpp>
+#endif
+
+namespace boost{
+
+namespace multi_index{
+
+namespace detail{
+
+/* definition of red-black nodes for ordered_index */
+
+enum ordered_index_color{red=false,black=true};
+enum ordered_index_side{to_left=false,to_right=true};
+
+template<typename AugmentPolicy,typename Allocator>
+struct ordered_index_node_impl; /* fwd decl. */
+
+template<typename AugmentPolicy,typename Allocator>
+struct ordered_index_node_std_base
+{
+  typedef typename
+  boost::detail::allocator::rebind_to<
+    Allocator,
+    ordered_index_node_impl<AugmentPolicy,Allocator>
+  >::type::pointer                                   pointer;
+  typedef typename
+  boost::detail::allocator::rebind_to<
+    Allocator,
+    ordered_index_node_impl<AugmentPolicy,Allocator>
+  >::type::const_pointer                             const_pointer;
+  typedef ordered_index_color&                       color_ref;
+  typedef pointer&                                   parent_ref;
+
+  ordered_index_color& color(){return color_;}
+  ordered_index_color  color()const{return color_;}
+  pointer&             parent(){return parent_;}
+  pointer              parent()const{return parent_;}
+  pointer&             left(){return left_;}
+  pointer              left()const{return left_;}
+  pointer&             right(){return right_;}
+  pointer              right()const{return right_;}
+
+private:
+  ordered_index_color color_; 
+  pointer             parent_;
+  pointer             left_;
+  pointer             right_;
+};
+
+#if !defined(BOOST_MULTI_INDEX_DISABLE_COMPRESSED_ORDERED_INDEX_NODES)
+/* If ordered_index_node_impl has even alignment, we can use the least
+ * significant bit of one of the ordered_index_node_impl pointers to
+ * store color information. This typically reduces the size of
+ * ordered_index_node_impl by 25%.
+ */
+
+#if defined(BOOST_MSVC)
+/* This code casts pointers to an integer type that has been computed
+ * to be large enough to hold the pointer, however the metaprogramming
+ * logic is not always spotted by the VC++ code analyser that issues a
+ * long list of warnings.
+ */
+
+#pragma warning(push)
+#pragma warning(disable:4312 4311)
+#endif
+
+template<typename AugmentPolicy,typename Allocator>
+struct ordered_index_node_compressed_base
+{
+  typedef ordered_index_node_impl<
+    AugmentPolicy,Allocator>*            pointer;
+  typedef const ordered_index_node_impl<
+    AugmentPolicy,Allocator>*            const_pointer;
+
+  struct color_ref
+  {
+    color_ref(uintptr_type* r_):r(r_){}
+    
+    operator ordered_index_color()const
+    {
+      return ordered_index_color(*r&uintptr_type(1));
+    }
+    
+    color_ref& operator=(ordered_index_color c)
+    {
+      *r&=~uintptr_type(1);
+      *r|=uintptr_type(c);
+      return *this;
+    }
+    
+    color_ref& operator=(const color_ref& x)
+    {
+      return operator=(x.operator ordered_index_color());
+    }
+    
+  private:
+    uintptr_type* r;
+  };
+  
+  struct parent_ref
+  {
+    parent_ref(uintptr_type* r_):r(r_){}
+    
+    operator pointer()const
+    {
+      return (pointer)(void*)(*r&~uintptr_type(1));
+    }
+    
+    parent_ref& operator=(pointer p)
+    {
+      *r=((uintptr_type)(void*)p)|(*r&uintptr_type(1));
+      return *this;
+    }
+    
+    parent_ref& operator=(const parent_ref& x)
+    {
+      return operator=(x.operator pointer());
+    }
+
+    pointer operator->()const
+    {
+      return operator pointer();
+    }
+
+  private:
+    uintptr_type* r;
+  };
+  
+  color_ref           color(){return color_ref(&parentcolor_);}
+  ordered_index_color color()const
+  {
+    return ordered_index_color(parentcolor_&uintptr_type(1));
+  }
+
+  parent_ref parent(){return parent_ref(&parentcolor_);}
+  pointer    parent()const
+  {
+    return (pointer)(void*)(parentcolor_&~uintptr_type(1));
+  }
+
+  pointer& left(){return left_;}
+  pointer  left()const{return left_;}
+  pointer& right(){return right_;}
+  pointer  right()const{return right_;}
+
+private:
+  uintptr_type parentcolor_;
+  pointer      left_;
+  pointer      right_;
+};
+#if defined(BOOST_MSVC)
+#pragma warning(pop)
+#endif
+#endif
+
+template<typename AugmentPolicy,typename Allocator>
+struct ordered_index_node_impl_base:
+
+#if !defined(BOOST_MULTI_INDEX_DISABLE_COMPRESSED_ORDERED_INDEX_NODES)
+  AugmentPolicy::template augmented_node<
+    typename mpl::if_c<
+      !(has_uintptr_type::value)||
+      (alignment_of<
+        ordered_index_node_compressed_base<AugmentPolicy,Allocator>
+       >::value%2)||
+      !(is_same<
+        typename boost::detail::allocator::rebind_to<
+          Allocator,
+          ordered_index_node_impl<AugmentPolicy,Allocator>
+        >::type::pointer,
+        ordered_index_node_impl<AugmentPolicy,Allocator>*>::value),
+      ordered_index_node_std_base<AugmentPolicy,Allocator>,
+      ordered_index_node_compressed_base<AugmentPolicy,Allocator>
+    >::type
+  >::type
+#else
+  AugmentPolicy::template augmented_node<
+    ordered_index_node_std_base<AugmentPolicy,Allocator>
+  >::type
+#endif
+
+{};
+
+template<typename AugmentPolicy,typename Allocator>
+struct ordered_index_node_impl:
+  ordered_index_node_impl_base<AugmentPolicy,Allocator>
+{
+private:
+  typedef ordered_index_node_impl_base<AugmentPolicy,Allocator> super;
+
+public:
+  typedef typename super::color_ref                             color_ref;
+  typedef typename super::parent_ref                            parent_ref;
+  typedef typename super::pointer                               pointer;
+  typedef typename super::const_pointer                         const_pointer;
+
+  /* interoperability with bidir_node_iterator */
+
+  static void increment(pointer& x)
+  {
+    if(x->right()!=pointer(0)){
+      x=x->right();
+      while(x->left()!=pointer(0))x=x->left();
+    }
+    else{
+      pointer y=x->parent();
+      while(x==y->right()){
+        x=y;
+        y=y->parent();
+      }
+      if(x->right()!=y)x=y;
+    }
+  }
+
+  static void decrement(pointer& x)
+  {
+    if(x->color()==red&&x->parent()->parent()==x){
+      x=x->right();
+    }
+    else if(x->left()!=pointer(0)){
+      pointer y=x->left();
+      while(y->right()!=pointer(0))y=y->right();
+      x=y;
+    }else{
+      pointer y=x->parent();
+      while(x==y->left()){
+        x=y;
+        y=y->parent();
+      }
+      x=y;
+    }
+  }
+
+  /* algorithmic stuff */
+
+  static void rotate_left(pointer x,parent_ref root)
+  {
+    pointer y=x->right();
+    x->right()=y->left();
+    if(y->left()!=pointer(0))y->left()->parent()=x;
+    y->parent()=x->parent();
+    
+    if(x==root)                    root=y;
+    else if(x==x->parent()->left())x->parent()->left()=y;
+    else                           x->parent()->right()=y;
+    y->left()=x;
+    x->parent()=y;
+    AugmentPolicy::rotate_left(x,y);
+  }
+
+  static pointer minimum(pointer x)
+  {
+    while(x->left()!=pointer(0))x=x->left();
+    return x;
+  }
+
+  static pointer maximum(pointer x)
+  {
+    while(x->right()!=pointer(0))x=x->right();
+    return x;
+  }
+
+  static void rotate_right(pointer x,parent_ref root)
+  {
+    pointer y=x->left();
+    x->left()=y->right();
+    if(y->right()!=pointer(0))y->right()->parent()=x;
+    y->parent()=x->parent();
+
+    if(x==root)                     root=y;
+    else if(x==x->parent()->right())x->parent()->right()=y;
+    else                            x->parent()->left()=y;
+    y->right()=x;
+    x->parent()=y;
+    AugmentPolicy::rotate_right(x,y);
+  }
+
+  static void rebalance(pointer x,parent_ref root)
+  {
+    x->color()=red;
+    while(x!=root&&x->parent()->color()==red){
+      if(x->parent()==x->parent()->parent()->left()){
+        pointer y=x->parent()->parent()->right();
+        if(y!=pointer(0)&&y->color()==red){
+          x->parent()->color()=black;
+          y->color()=black;
+          x->parent()->parent()->color()=red;
+          x=x->parent()->parent();
+        }
+        else{
+          if(x==x->parent()->right()){
+            x=x->parent();
+            rotate_left(x,root);
+          }
+          x->parent()->color()=black;
+          x->parent()->parent()->color()=red;
+          rotate_right(x->parent()->parent(),root);
+        }
+      }
+      else{
+        pointer y=x->parent()->parent()->left();
+        if(y!=pointer(0)&&y->color()==red){
+          x->parent()->color()=black;
+          y->color()=black;
+          x->parent()->parent()->color()=red;
+          x=x->parent()->parent();
+        }
+        else{
+          if(x==x->parent()->left()){
+            x=x->parent();
+            rotate_right(x,root);
+          }
+          x->parent()->color()=black;
+          x->parent()->parent()->color()=red;
+          rotate_left(x->parent()->parent(),root);
+        }
+      }
+    }
+    root->color()=black;
+  }
+
+  static void link(
+    pointer x,ordered_index_side side,pointer position,pointer header)
+  {
+    if(side==to_left){
+      position->left()=x;  /* also makes leftmost=x when parent==header */
+      if(position==header){
+        header->parent()=x;
+        header->right()=x;
+      }
+      else if(position==header->left()){
+        header->left()=x;  /* maintain leftmost pointing to min node */
+      }
+    }
+    else{
+      position->right()=x;
+      if(position==header->right()){
+        header->right()=x; /* maintain rightmost pointing to max node */
+      }
+    }
+    x->parent()=position;
+    x->left()=pointer(0);
+    x->right()=pointer(0);
+    AugmentPolicy::add(x,pointer(header->parent()));
+    ordered_index_node_impl::rebalance(x,header->parent());
+  }
+
+  static pointer rebalance_for_erase(
+    pointer z,parent_ref root,pointer& leftmost,pointer& rightmost)
+  {
+    pointer y=z;
+    pointer x=pointer(0);
+    pointer x_parent=pointer(0);
+    if(y->left()==pointer(0)){    /* z has at most one non-null child. y==z. */
+      x=y->right();               /* x might be null */
+    }
+    else{
+      if(y->right()==pointer(0)){ /* z has exactly one non-null child. y==z. */
+        x=y->left();              /* x is not null */
+      }
+      else{                       /* z has two non-null children.  Set y to */
+        y=y->right();             /* z's successor. x might be null.        */
+        while(y->left()!=pointer(0))y=y->left();
+        x=y->right();
+      }
+    }
+    AugmentPolicy::remove(y,pointer(root));
+    if(y!=z){
+      AugmentPolicy::copy(z,y);
+      z->left()->parent()=y;   /* relink y in place of z. y is z's successor */
+      y->left()=z->left();
+      if(y!=z->right()){
+        x_parent=y->parent();
+        if(x!=pointer(0))x->parent()=y->parent();
+        y->parent()->left()=x; /* y must be a child of left */
+        y->right()=z->right();
+        z->right()->parent()=y;
+      }
+      else{
+        x_parent=y;
+      }
+
+      if(root==z)                    root=y;
+      else if(z->parent()->left()==z)z->parent()->left()=y;
+      else                           z->parent()->right()=y;
+      y->parent()=z->parent();
+      ordered_index_color c=y->color();
+      y->color()=z->color();
+      z->color()=c;
+      y=z;                    /* y now points to node to be actually deleted */
+    }
+    else{                     /* y==z */
+      x_parent=y->parent();
+      if(x!=pointer(0))x->parent()=y->parent();   
+      if(root==z){
+        root=x;
+      }
+      else{
+        if(z->parent()->left()==z)z->parent()->left()=x;
+        else                      z->parent()->right()=x;
+      }
+      if(leftmost==z){
+        if(z->right()==pointer(0)){ /* z->left() must be null also */
+          leftmost=z->parent();
+        }
+        else{              
+          leftmost=minimum(x);      /* makes leftmost==header if z==root */
+        }
+      }
+      if(rightmost==z){
+        if(z->left()==pointer(0)){  /* z->right() must be null also */
+          rightmost=z->parent();
+        }
+        else{                   /* x==z->left() */
+          rightmost=maximum(x); /* makes rightmost==header if z==root */
+        }
+      }
+    }
+    if(y->color()!=red){
+      while(x!=root&&(x==pointer(0)|| x->color()==black)){
+        if(x==x_parent->left()){
+          pointer w=x_parent->right();
+          if(w->color()==red){
+            w->color()=black;
+            x_parent->color()=red;
+            rotate_left(x_parent,root);
+            w=x_parent->right();
+          }
+          if((w->left()==pointer(0)||w->left()->color()==black) &&
+             (w->right()==pointer(0)||w->right()->color()==black)){
+            w->color()=red;
+            x=x_parent;
+            x_parent=x_parent->parent();
+          } 
+          else{
+            if(w->right()==pointer(0 )
+                || w->right()->color()==black){
+              if(w->left()!=pointer(0)) w->left()->color()=black;
+              w->color()=red;
+              rotate_right(w,root);
+              w=x_parent->right();
+            }
+            w->color()=x_parent->color();
+            x_parent->color()=black;
+            if(w->right()!=pointer(0))w->right()->color()=black;
+            rotate_left(x_parent,root);
+            break;
+          }
+        } 
+        else{                   /* same as above,with right <-> left */
+          pointer w=x_parent->left();
+          if(w->color()==red){
+            w->color()=black;
+            x_parent->color()=red;
+            rotate_right(x_parent,root);
+            w=x_parent->left();
+          }
+          if((w->right()==pointer(0)||w->right()->color()==black) &&
+             (w->left()==pointer(0)||w->left()->color()==black)){
+            w->color()=red;
+            x=x_parent;
+            x_parent=x_parent->parent();
+          }
+          else{
+            if(w->left()==pointer(0)||w->left()->color()==black){
+              if(w->right()!=pointer(0))w->right()->color()=black;
+              w->color()=red;
+              rotate_left(w,root);
+              w=x_parent->left();
+            }
+            w->color()=x_parent->color();
+            x_parent->color()=black;
+            if(w->left()!=pointer(0))w->left()->color()=black;
+            rotate_right(x_parent,root);
+            break;
+          }
+        }
+      }
+      if(x!=pointer(0))x->color()=black;
+    }
+    return y;
+  }
+
+  static void restore(pointer x,pointer position,pointer header)
+  {
+    if(position->left()==pointer(0)||position->left()==header){
+      link(x,to_left,position,header);
+    }
+    else{
+      decrement(position);
+      link(x,to_right,position,header);
+    }
+  }
+
+#if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING)
+  /* invariant stuff */
+
+  static std::size_t black_count(pointer node,pointer root)
+  {
+    if(node==pointer(0))return 0;
+    std::size_t sum=0;
+    for(;;){
+      if(node->color()==black)++sum;
+      if(node==root)break;
+      node=node->parent();
+    } 
+    return sum;
+  }
+#endif
+};
+
+template<typename AugmentPolicy,typename Super>
+struct ordered_index_node_trampoline:
+  ordered_index_node_impl<
+    AugmentPolicy,
+    typename boost::detail::allocator::rebind_to<
+      typename Super::allocator_type,
+      char
+    >::type
+  >
+{
+  typedef ordered_index_node_impl<
+    AugmentPolicy,
+    typename boost::detail::allocator::rebind_to<
+      typename Super::allocator_type,
+      char
+    >::type
+  > impl_type;
+};
+
+template<typename AugmentPolicy,typename Super>
+struct ordered_index_node:
+  Super,ordered_index_node_trampoline<AugmentPolicy,Super>
+{
+private:
+  typedef ordered_index_node_trampoline<AugmentPolicy,Super> trampoline;
+
+public:
+  typedef typename trampoline::impl_type     impl_type;
+  typedef typename trampoline::color_ref     impl_color_ref;
+  typedef typename trampoline::parent_ref    impl_parent_ref;
+  typedef typename trampoline::pointer       impl_pointer;
+  typedef typename trampoline::const_pointer const_impl_pointer;
+
+  impl_color_ref      color(){return trampoline::color();}
+  ordered_index_color color()const{return trampoline::color();}
+  impl_parent_ref     parent(){return trampoline::parent();}
+  impl_pointer        parent()const{return trampoline::parent();}
+  impl_pointer&       left(){return trampoline::left();}
+  impl_pointer        left()const{return trampoline::left();}
+  impl_pointer&       right(){return trampoline::right();}
+  impl_pointer        right()const{return trampoline::right();}
+
+  impl_pointer impl()
+  {
+    return static_cast<impl_pointer>(
+      static_cast<impl_type*>(static_cast<trampoline*>(this)));
+  }
+
+  const_impl_pointer impl()const
+  {
+    return static_cast<const_impl_pointer>(
+      static_cast<const impl_type*>(static_cast<const trampoline*>(this)));
+  }
+
+  static ordered_index_node* from_impl(impl_pointer x)
+  {
+    return
+      static_cast<ordered_index_node*>(
+        static_cast<trampoline*>(
+          raw_ptr<impl_type*>(x)));
+  }
+
+  static const ordered_index_node* from_impl(const_impl_pointer x)
+  {
+    return
+      static_cast<const ordered_index_node*>(
+        static_cast<const trampoline*>(
+          raw_ptr<const impl_type*>(x)));
+  }
+
+  /* interoperability with bidir_node_iterator */
+
+  static void increment(ordered_index_node*& x)
+  {
+    impl_pointer xi=x->impl();
+    trampoline::increment(xi);
+    x=from_impl(xi);
+  }
+
+  static void decrement(ordered_index_node*& x)
+  {
+    impl_pointer xi=x->impl();
+    trampoline::decrement(xi);
+    x=from_impl(xi);
+  }
+};
+
+} /* namespace multi_index::detail */
+
+} /* namespace multi_index */
+
+} /* namespace boost */
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/ord_index_ops.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/ord_index_ops.hpp
new file mode 100644
index 00000000000..84d5cacae19
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/ord_index_ops.hpp
@@ -0,0 +1,266 @@
+/* Copyright 2003-2014 Joaquin M Lopez Munoz.
+ * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
+ *
+ * The internal implementation of red-black trees is based on that of SGI STL
+ * stl_tree.h file: 
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ */
+
+#ifndef BOOST_MULTI_INDEX_DETAIL_ORD_INDEX_OPS_HPP
+#define BOOST_MULTI_INDEX_DETAIL_ORD_INDEX_OPS_HPP
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
+#include <boost/mpl/and.hpp>
+#include <boost/multi_index/detail/promotes_arg.hpp>
+#include <utility>
+
+namespace boost{
+
+namespace multi_index{
+
+namespace detail{
+
+/* Common code for index memfuns having templatized and
+ * non-templatized versions.
+ * Implementation note: When CompatibleKey is consistently promoted to
+ * KeyFromValue::result_type for comparison, the promotion is made once in
+ * advance to increase efficiency.
+ */
+
+template<
+  typename Node,typename KeyFromValue,
+  typename CompatibleKey,typename CompatibleCompare
+>
+inline Node* ordered_index_find(
+  Node* top,Node* y,const KeyFromValue& key,const CompatibleKey& x,
+  const CompatibleCompare& comp)
+{
+  typedef typename KeyFromValue::result_type key_type;
+
+  return ordered_index_find(
+    top,y,key,x,comp,
+    mpl::and_<
+      promotes_1st_arg<CompatibleCompare,CompatibleKey,key_type>,
+      promotes_2nd_arg<CompatibleCompare,key_type,CompatibleKey> >());
+}
+
+template<
+  typename Node,typename KeyFromValue,
+  typename CompatibleCompare
+>
+inline Node* ordered_index_find(
+  Node* top,Node* y,const KeyFromValue& key,
+  const BOOST_DEDUCED_TYPENAME KeyFromValue::result_type& x,
+  const CompatibleCompare& comp,mpl::true_)
+{
+  return ordered_index_find(top,y,key,x,comp,mpl::false_());
+}
+
+template<
+  typename Node,typename KeyFromValue,
+  typename CompatibleKey,typename CompatibleCompare
+>
+inline Node* ordered_index_find(
+  Node* top,Node* y,const KeyFromValue& key,const CompatibleKey& x,
+  const CompatibleCompare& comp,mpl::false_)
+{
+  Node* y0=y;
+
+  while (top){
+    if(!comp(key(top->value()),x)){
+      y=top;
+      top=Node::from_impl(top->left());
+    }
+    else top=Node::from_impl(top->right());
+  }
+    
+  return (y==y0||comp(x,key(y->value())))?y0:y;
+}
+
+template<
+  typename Node,typename KeyFromValue,
+  typename CompatibleKey,typename CompatibleCompare
+>
+inline Node* ordered_index_lower_bound(
+  Node* top,Node* y,const KeyFromValue& key,const CompatibleKey& x,
+  const CompatibleCompare& comp)
+{
+  typedef typename KeyFromValue::result_type key_type;
+
+  return ordered_index_lower_bound(
+    top,y,key,x,comp,
+    promotes_2nd_arg<CompatibleCompare,key_type,CompatibleKey>());
+}
+
+template<
+  typename Node,typename KeyFromValue,
+  typename CompatibleCompare
+>
+inline Node* ordered_index_lower_bound(
+  Node* top,Node* y,const KeyFromValue& key,
+  const BOOST_DEDUCED_TYPENAME KeyFromValue::result_type& x,
+  const CompatibleCompare& comp,mpl::true_)
+{
+  return ordered_index_lower_bound(top,y,key,x,comp,mpl::false_());
+}
+
+template<
+  typename Node,typename KeyFromValue,
+  typename CompatibleKey,typename CompatibleCompare
+>
+inline Node* ordered_index_lower_bound(
+  Node* top,Node* y,const KeyFromValue& key,const CompatibleKey& x,
+  const CompatibleCompare& comp,mpl::false_)
+{
+  while(top){
+    if(!comp(key(top->value()),x)){
+      y=top;
+      top=Node::from_impl(top->left());
+    }
+    else top=Node::from_impl(top->right());
+  }
+
+  return y;
+}
+
+template<
+  typename Node,typename KeyFromValue,
+  typename CompatibleKey,typename CompatibleCompare
+>
+inline Node* ordered_index_upper_bound(
+  Node* top,Node* y,const KeyFromValue& key,const CompatibleKey& x,
+  const CompatibleCompare& comp)
+{
+  typedef typename KeyFromValue::result_type key_type;
+
+  return ordered_index_upper_bound(
+    top,y,key,x,comp,
+    promotes_1st_arg<CompatibleCompare,CompatibleKey,key_type>());
+}
+
+template<
+  typename Node,typename KeyFromValue,
+  typename CompatibleCompare
+>
+inline Node* ordered_index_upper_bound(
+  Node* top,Node* y,const KeyFromValue& key,
+  const BOOST_DEDUCED_TYPENAME KeyFromValue::result_type& x,
+  const CompatibleCompare& comp,mpl::true_)
+{
+  return ordered_index_upper_bound(top,y,key,x,comp,mpl::false_());
+}
+
+template<
+  typename Node,typename KeyFromValue,
+  typename CompatibleKey,typename CompatibleCompare
+>
+inline Node* ordered_index_upper_bound(
+  Node* top,Node* y,const KeyFromValue& key,const CompatibleKey& x,
+  const CompatibleCompare& comp,mpl::false_)
+{
+  while(top){
+    if(comp(x,key(top->value()))){
+      y=top;
+      top=Node::from_impl(top->left());
+    }
+    else top=Node::from_impl(top->right());
+  }
+
+  return y;
+}
+
+template<
+  typename Node,typename KeyFromValue,
+  typename CompatibleKey,typename CompatibleCompare
+>
+inline std::pair<Node*,Node*> ordered_index_equal_range(
+  Node* top,Node* y,const KeyFromValue& key,const CompatibleKey& x,
+  const CompatibleCompare& comp)
+{
+  typedef typename KeyFromValue::result_type key_type;
+
+  return ordered_index_equal_range(
+    top,y,key,x,comp,
+    mpl::and_<
+      promotes_1st_arg<CompatibleCompare,CompatibleKey,key_type>,
+      promotes_2nd_arg<CompatibleCompare,key_type,CompatibleKey> >());
+}
+
+template<
+  typename Node,typename KeyFromValue,
+  typename CompatibleCompare
+>
+inline std::pair<Node*,Node*> ordered_index_equal_range(
+  Node* top,Node* y,const KeyFromValue& key,
+  const BOOST_DEDUCED_TYPENAME KeyFromValue::result_type& x,
+  const CompatibleCompare& comp,mpl::true_)
+{
+  return ordered_index_equal_range(top,y,key,x,comp,mpl::false_());
+}
+
+template<
+  typename Node,typename KeyFromValue,
+  typename CompatibleKey,typename CompatibleCompare
+>
+inline std::pair<Node*,Node*> ordered_index_equal_range(
+  Node* top,Node* y,const KeyFromValue& key,const CompatibleKey& x,
+  const CompatibleCompare& comp,mpl::false_)
+{
+  while(top){
+    if(comp(key(top->value()),x)){
+      top=Node::from_impl(top->right());
+    }
+    else if(comp(x,key(top->value()))){
+      y=top;
+      top=Node::from_impl(top->left());
+    }
+    else{
+      return std::pair<Node*,Node*>(
+        ordered_index_lower_bound(
+          Node::from_impl(top->left()),top,key,x,comp,mpl::false_()),
+        ordered_index_upper_bound(
+          Node::from_impl(top->right()),y,key,x,comp,mpl::false_()));
+    }
+  }
+
+  return std::pair<Node*,Node*>(y,y);
+}
+
+} /* namespace multi_index::detail */
+
+} /* namespace multi_index */
+
+} /* namespace boost */
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/promotes_arg.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/promotes_arg.hpp
new file mode 100644
index 00000000000..7a11b6e9fbe
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/promotes_arg.hpp
@@ -0,0 +1,83 @@
+/* Copyright 2003-2017 Joaquin M Lopez Munoz.
+ * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
+ */
+
+#ifndef BOOST_MULTI_INDEX_DETAIL_PROMOTES_ARG_HPP
+#define BOOST_MULTI_INDEX_DETAIL_PROMOTES_ARG_HPP
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
+#include <boost/detail/workaround.hpp>
+
+/* Metafunctions to check if f(arg1,arg2) promotes either arg1 to the type of
+ * arg2 or viceversa. By default, (i.e. if it cannot be determined), no
+ * promotion is assumed.
+ */
+
+#if BOOST_WORKAROUND(BOOST_MSVC,<1400)
+
+namespace boost{
+
+namespace multi_index{
+
+namespace detail{
+
+template<typename F,typename Arg1,typename Arg2>
+struct promotes_1st_arg:mpl::false_{};
+
+template<typename F,typename Arg1,typename Arg2>
+struct promotes_2nd_arg:mpl::false_{};
+
+} /* namespace multi_index::detail */
+
+} /* namespace multi_index */
+
+} /* namespace boost */
+
+#else
+
+#include <boost/mpl/and.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/mpl/not.hpp>
+#include <boost/multi_index/detail/is_transparent.hpp>
+#include <boost/type_traits/is_convertible.hpp>
+
+namespace boost{
+
+namespace multi_index{
+
+namespace detail{
+  
+template<typename F,typename Arg1,typename Arg2>
+struct promotes_1st_arg:
+  mpl::and_<
+    mpl::not_<is_transparent<F,Arg1,Arg2> >,
+    is_convertible<const Arg1,Arg2>,
+    is_transparent<F,Arg2,Arg2>
+  >
+{};
+
+template<typename F,typename Arg1,typename Arg2>
+struct promotes_2nd_arg:
+  mpl::and_<
+    mpl::not_<is_transparent<F,Arg1,Arg2> >,
+    is_convertible<const Arg2,Arg1>,
+    is_transparent<F,Arg1,Arg1>
+  >
+{};
+
+} /* namespace multi_index::detail */
+
+} /* namespace multi_index */
+
+} /* namespace boost */
+
+#endif
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/raw_ptr.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/raw_ptr.hpp
new file mode 100644
index 00000000000..c32007435c0
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/raw_ptr.hpp
@@ -0,0 +1,52 @@
+/* Copyright 2003-2015 Joaquin M Lopez Munoz.
+ * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
+ */
+
+#ifndef BOOST_MULTI_INDEX_DETAIL_RAW_PTR_HPP
+#define BOOST_MULTI_INDEX_DETAIL_RAW_PTR_HPP
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
+#include <boost/mpl/bool.hpp>
+#include <boost/type_traits/is_same.hpp>
+
+namespace boost{
+
+namespace multi_index{
+
+namespace detail{
+
+/* gets the underlying pointer of a pointer-like value */
+
+template<typename RawPointer>
+inline RawPointer raw_ptr(RawPointer const& p,mpl::true_)
+{
+  return p;
+}
+
+template<typename RawPointer,typename Pointer>
+inline RawPointer raw_ptr(Pointer const& p,mpl::false_)
+{
+  return p==Pointer(0)?0:&*p;
+}
+
+template<typename RawPointer,typename Pointer>
+inline RawPointer raw_ptr(Pointer const& p)
+{
+  return raw_ptr<RawPointer>(p,is_same<RawPointer,Pointer>());
+}
+
+} /* namespace multi_index::detail */
+
+} /* namespace multi_index */
+
+} /* namespace boost */
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/restore_wstrict_aliasing.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/restore_wstrict_aliasing.hpp
new file mode 100644
index 00000000000..ee2c799d5a8
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/restore_wstrict_aliasing.hpp
@@ -0,0 +1,11 @@
+/* Copyright 2003-2016 Joaquin M Lopez Munoz.
+ * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
+ */
+
+#define BOOST_MULTI_INDEX_DETAIL_RESTORE_WSTRICT_ALIASING
+#include <boost/multi_index/detail/ignore_wstrict_aliasing.hpp>
+#undef BOOST_MULTI_INDEX_DETAIL_RESTORE_WSTRICT_ALIASING
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/rnd_index_loader.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/rnd_index_loader.hpp
new file mode 100644
index 00000000000..4b00345a6d9
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/rnd_index_loader.hpp
@@ -0,0 +1,173 @@
+/* Copyright 2003-2013 Joaquin M Lopez Munoz.
+ * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
+ */
+
+#ifndef BOOST_MULTI_INDEX_DETAIL_RND_INDEX_LOADER_HPP
+#define BOOST_MULTI_INDEX_DETAIL_RND_INDEX_LOADER_HPP
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
+#include <algorithm>
+#include <boost/detail/allocator_utilities.hpp>
+#include <boost/multi_index/detail/auto_space.hpp>
+#include <boost/multi_index/detail/rnd_index_ptr_array.hpp>
+#include <boost/noncopyable.hpp>
+#include <cstddef>
+
+namespace boost{
+
+namespace multi_index{
+
+namespace detail{
+
+/* This class implements a serialization rearranger for random access
+ * indices. In order to achieve O(n) performance, the following strategy
+ * is followed: the nodes of the index are handled as if in a bidirectional
+ * list, where the next pointers are stored in the original
+ * random_access_index_ptr_array and the prev pointers are stored in
+ * an auxiliary array. Rearranging of nodes in such a bidirectional list
+ * is constant time. Once all the arrangements are performed (on destruction
+ * time) the list is traversed in reverse order and
+ * pointers are swapped and set accordingly so that they recover its
+ * original semantics ( *(node->up())==node ) while retaining the
+ * new order.
+ */
+
+template<typename Allocator>
+class random_access_index_loader_base:private noncopyable
+{
+protected:
+  typedef random_access_index_node_impl<
+    typename boost::detail::allocator::rebind_to<
+      Allocator,
+      char
+    >::type
+  >                                                 node_impl_type;
+  typedef typename node_impl_type::pointer          node_impl_pointer;
+  typedef random_access_index_ptr_array<Allocator>  ptr_array;
+
+  random_access_index_loader_base(const Allocator& al_,ptr_array& ptrs_):
+    al(al_),
+    ptrs(ptrs_),
+    header(*ptrs.end()),
+    prev_spc(al,0),
+    preprocessed(false)
+  {}
+
+  ~random_access_index_loader_base()
+  {
+    if(preprocessed)
+    {
+      node_impl_pointer n=header;
+      next(n)=n;
+
+      for(std::size_t i=ptrs.size();i--;){
+        n=prev(n);
+        std::size_t d=position(n);
+        if(d!=i){
+          node_impl_pointer m=prev(next_at(i));
+          std::swap(m->up(),n->up());
+          next_at(d)=next_at(i);
+          std::swap(prev_at(d),prev_at(i));
+        }
+        next(n)=n;
+      }
+    }
+  }
+
+  void rearrange(node_impl_pointer position_,node_impl_pointer x)
+  {
+    preprocess(); /* only incur this penalty if rearrange() is ever called */
+    if(position_==node_impl_pointer(0))position_=header;
+    next(prev(x))=next(x);
+    prev(next(x))=prev(x);
+    prev(x)=position_;
+    next(x)=next(position_);
+    next(prev(x))=prev(next(x))=x;
+  }
+
+private:
+  void preprocess()
+  {
+    if(!preprocessed){
+      /* get space for the auxiliary prev array */
+      auto_space<node_impl_pointer,Allocator> tmp(al,ptrs.size()+1);
+      prev_spc.swap(tmp);
+
+      /* prev_spc elements point to the prev nodes */
+      std::rotate_copy(
+        &*ptrs.begin(),&*ptrs.end(),&*ptrs.end()+1,&*prev_spc.data());
+
+      /* ptrs elements point to the next nodes */
+      std::rotate(&*ptrs.begin(),&*ptrs.begin()+1,&*ptrs.end()+1);
+
+      preprocessed=true;
+    }
+  }
+
+  std::size_t position(node_impl_pointer x)const
+  {
+    return (std::size_t)(x->up()-ptrs.begin());
+  }
+
+  node_impl_pointer& next_at(std::size_t n)const
+  {
+    return *ptrs.at(n);
+  }
+
+  node_impl_pointer& prev_at(std::size_t n)const
+  {
+    return *(prev_spc.data()+n);
+  }
+
+  node_impl_pointer& next(node_impl_pointer x)const
+  {
+    return *(x->up());
+  }
+
+  node_impl_pointer& prev(node_impl_pointer x)const
+  {
+    return prev_at(position(x));
+  }
+
+  Allocator                               al;
+  ptr_array&                              ptrs;
+  node_impl_pointer                       header;
+  auto_space<node_impl_pointer,Allocator> prev_spc;
+  bool                                    preprocessed;
+};
+
+template<typename Node,typename Allocator>
+class random_access_index_loader:
+  private random_access_index_loader_base<Allocator>
+{
+  typedef random_access_index_loader_base<Allocator> super;
+  typedef typename super::node_impl_pointer          node_impl_pointer;
+  typedef typename super::ptr_array                  ptr_array;
+
+public:
+  random_access_index_loader(const Allocator& al_,ptr_array& ptrs_):
+    super(al_,ptrs_)
+  {}
+
+  void rearrange(Node* position_,Node *x)
+  {
+    super::rearrange(
+      position_?position_->impl():node_impl_pointer(0),x->impl());
+  }
+};
+
+} /* namespace multi_index::detail */
+
+} /* namespace multi_index */
+
+} /* namespace boost */
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/rnd_index_node.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/rnd_index_node.hpp
new file mode 100644
index 00000000000..ad61ea25dda
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/rnd_index_node.hpp
@@ -0,0 +1,273 @@
+/* Copyright 2003-2015 Joaquin M Lopez Munoz.
+ * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
+ */
+
+#ifndef BOOST_MULTI_INDEX_DETAIL_RND_INDEX_NODE_HPP
+#define BOOST_MULTI_INDEX_DETAIL_RND_INDEX_NODE_HPP
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
+#include <algorithm>
+#include <boost/detail/allocator_utilities.hpp>
+#include <boost/integer/common_factor_rt.hpp>
+#include <boost/multi_index/detail/raw_ptr.hpp>
+#include <cstddef>
+#include <functional>
+
+namespace boost{
+
+namespace multi_index{
+
+namespace detail{
+
+template<typename Allocator>
+struct random_access_index_node_impl
+{
+  typedef typename
+  boost::detail::allocator::rebind_to<
+    Allocator,random_access_index_node_impl
+  >::type::pointer                          pointer;
+  typedef typename
+  boost::detail::allocator::rebind_to<
+    Allocator,random_access_index_node_impl
+  >::type::const_pointer                    const_pointer;
+  typedef typename
+  boost::detail::allocator::rebind_to<
+    Allocator,pointer
+  >::type::pointer                          ptr_pointer;
+
+  ptr_pointer& up(){return up_;}
+  ptr_pointer  up()const{return up_;}
+
+  /* interoperability with rnd_node_iterator */
+
+  static void increment(pointer& x)
+  {
+    x=*(x->up()+1);
+  }
+
+  static void decrement(pointer& x)
+  {
+    x=*(x->up()-1);
+  }
+
+  static void advance(pointer& x,std::ptrdiff_t n)
+  {
+    x=*(x->up()+n);
+  }
+
+  static std::ptrdiff_t distance(pointer x,pointer y)
+  {
+    return y->up()-x->up();
+  }
+
+  /* algorithmic stuff */
+
+  static void relocate(ptr_pointer pos,ptr_pointer x)
+  {
+    pointer n=*x;
+    if(x<pos){
+      extract(x,pos);
+      *(pos-1)=n;
+      n->up()=pos-1;
+    }
+    else{
+      while(x!=pos){
+        *x=*(x-1);
+        (*x)->up()=x;
+        --x;
+      }
+      *pos=n;
+      n->up()=pos;
+    }
+  };
+
+  static void relocate(ptr_pointer pos,ptr_pointer first,ptr_pointer last)
+  {
+    ptr_pointer begin,middle,end;
+    if(pos<first){
+      begin=pos;
+      middle=first;
+      end=last;
+    }
+    else{
+      begin=first;
+      middle=last;
+      end=pos;
+    }
+
+    std::ptrdiff_t n=end-begin;
+    std::ptrdiff_t m=middle-begin;
+    std::ptrdiff_t n_m=n-m;
+    std::ptrdiff_t p=integer::gcd(n,m);
+
+    for(std::ptrdiff_t i=0;i<p;++i){
+      pointer tmp=begin[i];
+      for(std::ptrdiff_t j=i,k;;){
+        if(j<n_m)k=j+m;
+        else     k=j-n_m;
+        if(k==i){
+          *(begin+j)=tmp;
+          (*(begin+j))->up()=begin+j;
+          break;
+        }
+        else{
+          *(begin+j)=*(begin+k);
+          (*(begin+j))->up()=begin+j;
+        }
+
+        if(k<n_m)j=k+m;
+        else     j=k-n_m;
+        if(j==i){
+          *(begin+k)=tmp;
+          (*(begin+k))->up()=begin+k;
+          break;
+        }
+        else{
+          *(begin+k)=*(begin+j);
+          (*(begin+k))->up()=begin+k;
+        }
+      }
+    }
+  };
+
+  static void extract(ptr_pointer x,ptr_pointer pend)
+  {
+    --pend;
+    while(x!=pend){
+      *x=*(x+1);
+      (*x)->up()=x;
+      ++x;
+    }
+  }
+
+  static void transfer(
+    ptr_pointer pbegin0,ptr_pointer pend0,ptr_pointer pbegin1)
+  {
+    while(pbegin0!=pend0){
+      *pbegin1=*pbegin0++;
+      (*pbegin1)->up()=pbegin1;
+      ++pbegin1;
+    }
+  }
+
+  static void reverse(ptr_pointer pbegin,ptr_pointer pend)
+  {
+    std::ptrdiff_t d=(pend-pbegin)/2;
+    for(std::ptrdiff_t i=0;i<d;++i){
+      std::swap(*pbegin,*--pend);
+      (*pbegin)->up()=pbegin;
+      (*pend)->up()=pend;
+      ++pbegin;
+    }
+  }
+
+private:
+  ptr_pointer up_;
+};
+
+template<typename Super>
+struct random_access_index_node_trampoline:
+  random_access_index_node_impl<
+    typename boost::detail::allocator::rebind_to<
+      typename Super::allocator_type,
+      char
+    >::type
+  >
+{
+  typedef random_access_index_node_impl<
+    typename boost::detail::allocator::rebind_to<
+      typename Super::allocator_type,
+      char
+    >::type
+  > impl_type;
+};
+
+template<typename Super>
+struct random_access_index_node:
+  Super,random_access_index_node_trampoline<Super>
+{
+private:
+  typedef random_access_index_node_trampoline<Super> trampoline;
+
+public:
+  typedef typename trampoline::impl_type     impl_type;
+  typedef typename trampoline::pointer       impl_pointer;
+  typedef typename trampoline::const_pointer const_impl_pointer;
+  typedef typename trampoline::ptr_pointer   impl_ptr_pointer;
+
+  impl_ptr_pointer& up(){return trampoline::up();}
+  impl_ptr_pointer  up()const{return trampoline::up();}
+
+  impl_pointer impl()
+  {
+    return static_cast<impl_pointer>(
+      static_cast<impl_type*>(static_cast<trampoline*>(this)));
+  }
+
+  const_impl_pointer impl()const
+  {
+    return static_cast<const_impl_pointer>(
+      static_cast<const impl_type*>(static_cast<const trampoline*>(this)));
+  }
+
+  static random_access_index_node* from_impl(impl_pointer x)
+  {
+    return
+      static_cast<random_access_index_node*>(
+        static_cast<trampoline*>(
+          raw_ptr<impl_type*>(x)));
+  }
+
+  static const random_access_index_node* from_impl(const_impl_pointer x)
+  {
+    return
+      static_cast<const random_access_index_node*>(
+        static_cast<const trampoline*>(
+          raw_ptr<const impl_type*>(x)));
+  }
+
+  /* interoperability with rnd_node_iterator */
+
+  static void increment(random_access_index_node*& x)
+  {
+    impl_pointer xi=x->impl();
+    trampoline::increment(xi);
+    x=from_impl(xi);
+  }
+
+  static void decrement(random_access_index_node*& x)
+  {
+    impl_pointer xi=x->impl();
+    trampoline::decrement(xi);
+    x=from_impl(xi);
+  }
+
+  static void advance(random_access_index_node*& x,std::ptrdiff_t n)
+  {
+    impl_pointer xi=x->impl();
+    trampoline::advance(xi,n);
+    x=from_impl(xi);
+  }
+
+  static std::ptrdiff_t distance(
+    random_access_index_node* x,random_access_index_node* y)
+  {
+    return trampoline::distance(x->impl(),y->impl());
+  }
+};
+
+} /* namespace multi_index::detail */
+
+} /* namespace multi_index */
+
+} /* namespace boost */
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/rnd_index_ops.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/rnd_index_ops.hpp
new file mode 100644
index 00000000000..f5e76e4441f
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/rnd_index_ops.hpp
@@ -0,0 +1,203 @@
+/* Copyright 2003-2015 Joaquin M Lopez Munoz.
+ * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
+ */
+
+#ifndef BOOST_MULTI_INDEX_DETAIL_RND_INDEX_OPS_HPP
+#define BOOST_MULTI_INDEX_DETAIL_RND_INDEX_OPS_HPP
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
+#include <algorithm>
+#include <boost/multi_index/detail/rnd_index_ptr_array.hpp>
+
+namespace boost{
+
+namespace multi_index{
+
+namespace detail{
+
+/* Common code for random_access_index memfuns having templatized and
+ * non-templatized versions.
+ */
+
+template<typename Node,typename Allocator,typename Predicate>
+Node* random_access_index_remove(
+  random_access_index_ptr_array<Allocator>& ptrs,Predicate pred)
+{
+  typedef typename Node::value_type value_type;
+  typedef typename Node::impl_ptr_pointer impl_ptr_pointer;
+
+  impl_ptr_pointer first=ptrs.begin(),
+                   res=first,
+                   last=ptrs.end();
+  for(;first!=last;++first){
+    if(!pred(
+        const_cast<const value_type&>(Node::from_impl(*first)->value()))){
+      if(first!=res){
+        std::swap(*first,*res);
+        (*first)->up()=first;
+        (*res)->up()=res;
+      }
+      ++res;
+    }
+  }
+  return Node::from_impl(*res);
+}
+
+template<typename Node,typename Allocator,class BinaryPredicate>
+Node* random_access_index_unique(
+  random_access_index_ptr_array<Allocator>& ptrs,BinaryPredicate binary_pred)
+{
+  typedef typename Node::value_type       value_type;
+  typedef typename Node::impl_ptr_pointer impl_ptr_pointer;
+
+  impl_ptr_pointer first=ptrs.begin(),
+                   res=first,
+                   last=ptrs.end();
+  if(first!=last){
+    for(;++first!=last;){
+      if(!binary_pred(
+           const_cast<const value_type&>(Node::from_impl(*res)->value()),
+           const_cast<const value_type&>(Node::from_impl(*first)->value()))){
+        ++res;
+        if(first!=res){
+          std::swap(*first,*res);
+          (*first)->up()=first;
+          (*res)->up()=res;
+        }
+      }
+    }
+    ++res;
+  }
+  return Node::from_impl(*res);
+}
+
+template<typename Node,typename Allocator,typename Compare>
+void random_access_index_inplace_merge(
+  const Allocator& al,
+  random_access_index_ptr_array<Allocator>& ptrs,
+  BOOST_DEDUCED_TYPENAME Node::impl_ptr_pointer first1,Compare comp)
+{
+  typedef typename Node::value_type       value_type;
+  typedef typename Node::impl_pointer     impl_pointer;
+  typedef typename Node::impl_ptr_pointer impl_ptr_pointer;
+
+  auto_space<impl_pointer,Allocator> spc(al,ptrs.size());
+
+  impl_ptr_pointer first0=ptrs.begin(),
+                   last0=first1,
+                   last1=ptrs.end(),
+                   out=spc.data();
+  while(first0!=last0&&first1!=last1){
+    if(comp(
+        const_cast<const value_type&>(Node::from_impl(*first1)->value()),
+        const_cast<const value_type&>(Node::from_impl(*first0)->value()))){
+      *out++=*first1++;
+    }
+    else{
+      *out++=*first0++;
+    }
+  }
+  std::copy(&*first0,&*last0,&*out);
+  std::copy(&*first1,&*last1,&*out);
+
+  first1=ptrs.begin();
+  out=spc.data();
+  while(first1!=last1){
+    *first1=*out++;
+    (*first1)->up()=first1;
+    ++first1;
+  }
+}
+
+/* sorting */
+
+/* auxiliary stuff */
+
+template<typename Node,typename Compare>
+struct random_access_index_sort_compare
+{
+  typedef typename Node::impl_pointer first_argument_type;
+  typedef typename Node::impl_pointer second_argument_type;
+  typedef bool                        result_type;
+
+  random_access_index_sort_compare(Compare comp_=Compare()):comp(comp_){}
+
+  bool operator()(
+    typename Node::impl_pointer x,typename Node::impl_pointer y)const
+  {
+    typedef typename Node::value_type value_type;
+
+    return comp(
+      const_cast<const value_type&>(Node::from_impl(x)->value()),
+      const_cast<const value_type&>(Node::from_impl(y)->value()));
+  }
+
+private:
+  Compare comp;
+};
+
+template<typename Node,typename Allocator,class Compare>
+void random_access_index_sort(
+  const Allocator& al,
+  random_access_index_ptr_array<Allocator>& ptrs,
+  Compare comp)
+{
+  /* The implementation is extremely simple: an auxiliary
+   * array of pointers is sorted using stdlib facilities and
+   * then used to rearrange the index. This is suboptimal
+   * in space and time, but has some advantages over other
+   * possible approaches:
+   *   - Use std::stable_sort() directly on ptrs using some
+   *     special iterator in charge of maintaining pointers
+   *     and up() pointers in sync: we cannot guarantee
+   *     preservation of the container invariants in the face of
+   *     exceptions, if, for instance, std::stable_sort throws
+   *     when ptrs transitorily contains duplicate elements.
+   *   - Rewrite the internal algorithms of std::stable_sort
+   *     adapted for this case: besides being a fair amount of
+   *     work, making a stable sort compatible with Boost.MultiIndex
+   *     invariants (basically, no duplicates or missing elements
+   *     even if an exception is thrown) is complicated, error-prone
+   *     and possibly won't perform much better than the
+   *     solution adopted.
+   */
+
+  if(ptrs.size()<=1)return;
+
+  typedef typename Node::impl_pointer       impl_pointer;
+  typedef typename Node::impl_ptr_pointer   impl_ptr_pointer;
+  typedef random_access_index_sort_compare<
+    Node,Compare>                           ptr_compare;
+  
+  impl_ptr_pointer   first=ptrs.begin();
+  impl_ptr_pointer   last=ptrs.end();
+  auto_space<
+    impl_pointer,
+    Allocator>       spc(al,ptrs.size());
+  impl_ptr_pointer   buf=spc.data();
+
+  std::copy(&*first,&*last,&*buf);
+  std::stable_sort(&*buf,&*buf+ptrs.size(),ptr_compare(comp));
+
+  while(first!=last){
+    *first=*buf++;
+    (*first)->up()=first;
+    ++first;
+  }
+}
+
+} /* namespace multi_index::detail */
+
+} /* namespace multi_index */
+
+} /* namespace boost */
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/rnd_index_ptr_array.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/rnd_index_ptr_array.hpp
new file mode 100644
index 00000000000..bae1c851b8e
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/rnd_index_ptr_array.hpp
@@ -0,0 +1,144 @@
+/* Copyright 2003-2013 Joaquin M Lopez Munoz.
+ * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
+ */
+
+#ifndef BOOST_MULTI_INDEX_DETAIL_RND_INDEX_PTR_ARRAY_HPP
+#define BOOST_MULTI_INDEX_DETAIL_RND_INDEX_PTR_ARRAY_HPP
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
+#include <algorithm>
+#include <boost/detail/allocator_utilities.hpp>
+#include <boost/multi_index/detail/auto_space.hpp>
+#include <boost/multi_index/detail/rnd_index_node.hpp>
+#include <boost/noncopyable.hpp>
+#include <cstddef>
+
+namespace boost{
+
+namespace multi_index{
+
+namespace detail{
+
+/* pointer structure for use by random access indices */
+
+template<typename Allocator>
+class random_access_index_ptr_array:private noncopyable
+{
+  typedef random_access_index_node_impl<
+    typename boost::detail::allocator::rebind_to<
+      Allocator,
+      char
+    >::type
+  >                                                     node_impl_type;
+
+public:
+  typedef typename node_impl_type::pointer              value_type;
+  typedef typename boost::detail::allocator::rebind_to<
+    Allocator,value_type
+  >::type::pointer                                      pointer;
+
+  random_access_index_ptr_array(
+    const Allocator& al,value_type end_,std::size_t sz):
+    size_(sz),
+    capacity_(sz),
+    spc(al,capacity_+1)
+  {
+    *end()=end_;
+    end_->up()=end();
+  }
+
+  std::size_t size()const{return size_;}
+  std::size_t capacity()const{return capacity_;}
+
+  void room_for_one()
+  {
+    if(size_==capacity_){
+      reserve(capacity_<=10?15:capacity_+capacity_/2);
+    }
+  }
+
+  void reserve(std::size_t c)
+  {
+    if(c>capacity_)set_capacity(c);
+  }
+
+  void shrink_to_fit()
+  {
+    if(capacity_>size_)set_capacity(size_);
+  }
+
+  pointer begin()const{return ptrs();}
+  pointer end()const{return ptrs()+size_;}
+  pointer at(std::size_t n)const{return ptrs()+n;}
+
+  void push_back(value_type x)
+  {
+    *(end()+1)=*end();
+    (*(end()+1))->up()=end()+1;
+    *end()=x;
+    (*end())->up()=end();
+    ++size_;
+  }
+
+  void erase(value_type x)
+  {
+    node_impl_type::extract(x->up(),end()+1);
+    --size_;
+  }
+
+  void clear()
+  {
+    *begin()=*end();
+    (*begin())->up()=begin();
+    size_=0;
+  }
+
+  void swap(random_access_index_ptr_array& x)
+  {
+    std::swap(size_,x.size_);
+    std::swap(capacity_,x.capacity_);
+    spc.swap(x.spc);
+  }
+
+private:
+  std::size_t                      size_;
+  std::size_t                      capacity_;
+  auto_space<value_type,Allocator> spc;
+
+  pointer ptrs()const
+  {
+    return spc.data();
+  }
+
+  void set_capacity(std::size_t c)
+  {
+    auto_space<value_type,Allocator> spc1(spc.get_allocator(),c+1);
+    node_impl_type::transfer(begin(),end()+1,spc1.data());
+    spc.swap(spc1);
+    capacity_=c;
+  }
+};
+
+template<typename Allocator>
+void swap(
+  random_access_index_ptr_array<Allocator>& x,
+  random_access_index_ptr_array<Allocator>& y)
+{
+  x.swap(y);
+}
+
+} /* namespace multi_index::detail */
+
+} /* namespace multi_index */
+
+} /* namespace boost */
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/rnd_node_iterator.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/rnd_node_iterator.hpp
new file mode 100644
index 00000000000..48026132fb7
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/rnd_node_iterator.hpp
@@ -0,0 +1,140 @@
+/* Copyright 2003-2014 Joaquin M Lopez Munoz.
+ * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
+ */
+
+#ifndef BOOST_MULTI_INDEX_DETAIL_RND_NODE_ITERATOR_HPP
+#define BOOST_MULTI_INDEX_DETAIL_RND_NODE_ITERATOR_HPP
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
+#include <boost/operators.hpp>
+
+#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
+#include <boost/serialization/nvp.hpp>
+#include <boost/serialization/split_member.hpp>
+#endif
+
+namespace boost{
+
+namespace multi_index{
+
+namespace detail{
+
+/* Iterator class for node-based indices with random access iterators. */
+
+template<typename Node>
+class rnd_node_iterator:
+  public random_access_iterator_helper<
+    rnd_node_iterator<Node>,
+    typename Node::value_type,
+    std::ptrdiff_t,
+    const typename Node::value_type*,
+    const typename Node::value_type&>
+{
+public:
+  /* coverity[uninit_ctor]: suppress warning */
+  rnd_node_iterator(){}
+  explicit rnd_node_iterator(Node* node_):node(node_){}
+
+  const typename Node::value_type& operator*()const
+  {
+    return node->value();
+  }
+
+  rnd_node_iterator& operator++()
+  {
+    Node::increment(node);
+    return *this;
+  }
+
+  rnd_node_iterator& operator--()
+  {
+    Node::decrement(node);
+    return *this;
+  }
+
+  rnd_node_iterator& operator+=(std::ptrdiff_t n)
+  {
+    Node::advance(node,n);
+    return *this;
+  }
+
+  rnd_node_iterator& operator-=(std::ptrdiff_t n)
+  {
+    Node::advance(node,-n);
+    return *this;
+  }
+
+#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
+  /* Serialization. As for why the following is public,
+   * see explanation in safe_mode_iterator notes in safe_mode.hpp.
+   */
+
+  BOOST_SERIALIZATION_SPLIT_MEMBER()
+
+  typedef typename Node::base_type node_base_type;
+
+  template<class Archive>
+  void save(Archive& ar,const unsigned int)const
+  {
+    node_base_type* bnode=node;
+    ar<<serialization::make_nvp("pointer",bnode);
+  }
+
+  template<class Archive>
+  void load(Archive& ar,const unsigned int)
+  {
+    node_base_type* bnode;
+    ar>>serialization::make_nvp("pointer",bnode);
+    node=static_cast<Node*>(bnode);
+  }
+#endif
+
+  /* get_node is not to be used by the user */
+
+  typedef Node node_type;
+
+  Node* get_node()const{return node;}
+
+private:
+  Node* node;
+};
+
+template<typename Node>
+bool operator==(
+  const rnd_node_iterator<Node>& x,
+  const rnd_node_iterator<Node>& y)
+{
+  return x.get_node()==y.get_node();
+}
+
+template<typename Node>
+bool operator<(
+  const rnd_node_iterator<Node>& x,
+  const rnd_node_iterator<Node>& y)
+{
+  return Node::distance(x.get_node(),y.get_node())>0;
+}
+
+template<typename Node>
+std::ptrdiff_t operator-(
+  const rnd_node_iterator<Node>& x,
+  const rnd_node_iterator<Node>& y)
+{
+  return Node::distance(y.get_node(),x.get_node());
+}
+
+} /* namespace multi_index::detail */
+
+} /* namespace multi_index */
+
+} /* namespace boost */
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/rnk_index_ops.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/rnk_index_ops.hpp
new file mode 100644
index 00000000000..fb233cf4973
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/rnk_index_ops.hpp
@@ -0,0 +1,300 @@
+/* Copyright 2003-2017 Joaquin M Lopez Munoz.
+ * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
+ */
+
+#ifndef BOOST_MULTI_INDEX_DETAIL_RNK_INDEX_OPS_HPP
+#define BOOST_MULTI_INDEX_DETAIL_RNK_INDEX_OPS_HPP
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
+#include <boost/mpl/and.hpp>
+#include <boost/multi_index/detail/promotes_arg.hpp>
+#include <cstddef>
+#include <utility>
+
+namespace boost{
+
+namespace multi_index{
+
+namespace detail{
+
+/* Common code for ranked_index memfuns having templatized and
+ * non-templatized versions.
+ */
+
+template<typename Pointer>
+inline std::size_t ranked_node_size(Pointer x)
+{
+  return x!=Pointer(0)?x->size:0;
+}
+
+template<typename Pointer>
+inline Pointer ranked_index_nth(std::size_t n,Pointer end_)
+{
+  Pointer top=end_->parent();
+  if(top==Pointer(0)||n>=top->size)return end_;
+
+  for(;;){
+    std::size_t s=ranked_node_size(top->left());
+    if(n==s)return top;
+    if(n<s)top=top->left();
+    else{
+      top=top->right();
+      n-=s+1;
+    }
+  }
+}
+
+template<typename Pointer>
+inline std::size_t ranked_index_rank(Pointer x,Pointer end_)
+{
+  Pointer top=end_->parent();
+  if(top==Pointer(0))return 0;
+  if(x==end_)return top->size;
+
+  std::size_t s=ranked_node_size(x->left());
+  while(x!=top){
+    Pointer z=x->parent();
+    if(x==z->right()){
+      s+=ranked_node_size(z->left())+1;
+    }
+    x=z;
+  }
+  return s;
+}
+
+template<
+  typename Node,typename KeyFromValue,
+  typename CompatibleKey,typename CompatibleCompare
+>
+inline std::size_t ranked_index_find_rank(
+  Node* top,Node* y,const KeyFromValue& key,const CompatibleKey& x,
+  const CompatibleCompare& comp)
+{
+  typedef typename KeyFromValue::result_type key_type;
+
+  return ranked_index_find_rank(
+    top,y,key,x,comp,
+    mpl::and_<
+      promotes_1st_arg<CompatibleCompare,CompatibleKey,key_type>,
+      promotes_2nd_arg<CompatibleCompare,key_type,CompatibleKey> >());
+}
+
+template<
+  typename Node,typename KeyFromValue,
+  typename CompatibleCompare
+>
+inline std::size_t ranked_index_find_rank(
+  Node* top,Node* y,const KeyFromValue& key,
+  const BOOST_DEDUCED_TYPENAME KeyFromValue::result_type& x,
+  const CompatibleCompare& comp,mpl::true_)
+{
+  return ranked_index_find_rank(top,y,key,x,comp,mpl::false_());
+}
+
+template<
+  typename Node,typename KeyFromValue,
+  typename CompatibleKey,typename CompatibleCompare
+>
+inline std::size_t ranked_index_find_rank(
+  Node* top,Node* y,const KeyFromValue& key,const CompatibleKey& x,
+  const CompatibleCompare& comp,mpl::false_)
+{
+  if(!top)return 0;
+
+  std::size_t s=top->impl()->size,
+              s0=s;
+  Node*       y0=y;
+
+  do{
+    if(!comp(key(top->value()),x)){
+      y=top;
+      s-=ranked_node_size(y->right())+1;
+      top=Node::from_impl(top->left());
+    }
+    else top=Node::from_impl(top->right());
+  }while(top);
+    
+  return (y==y0||comp(x,key(y->value())))?s0:s;
+}
+
+template<
+  typename Node,typename KeyFromValue,
+  typename CompatibleKey,typename CompatibleCompare
+>
+inline std::size_t ranked_index_lower_bound_rank(
+  Node* top,Node* y,const KeyFromValue& key,const CompatibleKey& x,
+  const CompatibleCompare& comp)
+{
+  typedef typename KeyFromValue::result_type key_type;
+
+  return ranked_index_lower_bound_rank(
+    top,y,key,x,comp,
+    promotes_2nd_arg<CompatibleCompare,key_type,CompatibleKey>());
+}
+
+template<
+  typename Node,typename KeyFromValue,
+  typename CompatibleCompare
+>
+inline std::size_t ranked_index_lower_bound_rank(
+  Node* top,Node* y,const KeyFromValue& key,
+  const BOOST_DEDUCED_TYPENAME KeyFromValue::result_type& x,
+  const CompatibleCompare& comp,mpl::true_)
+{
+  return ranked_index_lower_bound_rank(top,y,key,x,comp,mpl::false_());
+}
+
+template<
+  typename Node,typename KeyFromValue,
+  typename CompatibleKey,typename CompatibleCompare
+>
+inline std::size_t ranked_index_lower_bound_rank(
+  Node* top,Node* y,const KeyFromValue& key,const CompatibleKey& x,
+  const CompatibleCompare& comp,mpl::false_)
+{
+  if(!top)return 0;
+
+  std::size_t s=top->impl()->size;
+
+  do{
+    if(!comp(key(top->value()),x)){
+      y=top;
+      s-=ranked_node_size(y->right())+1;
+      top=Node::from_impl(top->left());
+    }
+    else top=Node::from_impl(top->right());
+  }while(top);
+
+  return s;
+}
+
+template<
+  typename Node,typename KeyFromValue,
+  typename CompatibleKey,typename CompatibleCompare
+>
+inline std::size_t ranked_index_upper_bound_rank(
+  Node* top,Node* y,const KeyFromValue& key,const CompatibleKey& x,
+  const CompatibleCompare& comp)
+{
+  typedef typename KeyFromValue::result_type key_type;
+
+  return ranked_index_upper_bound_rank(
+    top,y,key,x,comp,
+    promotes_1st_arg<CompatibleCompare,CompatibleKey,key_type>());
+}
+
+template<
+  typename Node,typename KeyFromValue,
+  typename CompatibleCompare
+>
+inline std::size_t ranked_index_upper_bound_rank(
+  Node* top,Node* y,const KeyFromValue& key,
+  const BOOST_DEDUCED_TYPENAME KeyFromValue::result_type& x,
+  const CompatibleCompare& comp,mpl::true_)
+{
+  return ranked_index_upper_bound_rank(top,y,key,x,comp,mpl::false_());
+}
+
+template<
+  typename Node,typename KeyFromValue,
+  typename CompatibleKey,typename CompatibleCompare
+>
+inline std::size_t ranked_index_upper_bound_rank(
+  Node* top,Node* y,const KeyFromValue& key,const CompatibleKey& x,
+  const CompatibleCompare& comp,mpl::false_)
+{
+  if(!top)return 0;
+
+  std::size_t s=top->impl()->size;
+
+  do{
+    if(comp(x,key(top->value()))){
+      y=top;
+      s-=ranked_node_size(y->right())+1;
+      top=Node::from_impl(top->left());
+    }
+    else top=Node::from_impl(top->right());
+  }while(top);
+
+  return s;
+}
+
+template<
+  typename Node,typename KeyFromValue,
+  typename CompatibleKey,typename CompatibleCompare
+>
+inline std::pair<std::size_t,std::size_t> ranked_index_equal_range_rank(
+  Node* top,Node* y,const KeyFromValue& key,const CompatibleKey& x,
+  const CompatibleCompare& comp)
+{
+  typedef typename KeyFromValue::result_type key_type;
+
+  return ranked_index_equal_range_rank(
+    top,y,key,x,comp,
+    mpl::and_<
+      promotes_1st_arg<CompatibleCompare,CompatibleKey,key_type>,
+      promotes_2nd_arg<CompatibleCompare,key_type,CompatibleKey> >());
+}
+
+template<
+  typename Node,typename KeyFromValue,
+  typename CompatibleCompare
+>
+inline std::pair<std::size_t,std::size_t> ranked_index_equal_range_rank(
+  Node* top,Node* y,const KeyFromValue& key,
+  const BOOST_DEDUCED_TYPENAME KeyFromValue::result_type& x,
+  const CompatibleCompare& comp,mpl::true_)
+{
+  return ranked_index_equal_range_rank(top,y,key,x,comp,mpl::false_());
+}
+
+template<
+  typename Node,typename KeyFromValue,
+  typename CompatibleKey,typename CompatibleCompare
+>
+inline std::pair<std::size_t,std::size_t> ranked_index_equal_range_rank(
+  Node* top,Node* y,const KeyFromValue& key,const CompatibleKey& x,
+  const CompatibleCompare& comp,mpl::false_)
+{
+  if(!top)return std::pair<std::size_t,std::size_t>(0,0);
+
+  std::size_t s=top->impl()->size;
+
+  do{
+    if(comp(key(top->value()),x)){
+      top=Node::from_impl(top->right());
+    }
+    else if(comp(x,key(top->value()))){
+      y=top;
+      s-=ranked_node_size(y->right())+1;
+      top=Node::from_impl(top->left());
+    }
+    else{
+      return std::pair<std::size_t,std::size_t>(
+        s-top->impl()->size+
+          ranked_index_lower_bound_rank(
+           Node::from_impl(top->left()),top,key,x,comp,mpl::false_()),
+        s-ranked_node_size(top->right())+
+          ranked_index_upper_bound_rank(
+            Node::from_impl(top->right()),y,key,x,comp,mpl::false_()));
+    }
+  }while(top);
+
+  return std::pair<std::size_t,std::size_t>(s,s);
+}
+
+} /* namespace multi_index::detail */
+
+} /* namespace multi_index */
+
+} /* namespace boost */
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/safe_mode.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/safe_mode.hpp
new file mode 100644
index 00000000000..905270e9fb3
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/safe_mode.hpp
@@ -0,0 +1,588 @@
+/* Copyright 2003-2013 Joaquin M Lopez Munoz.
+ * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
+ */
+
+#ifndef BOOST_MULTI_INDEX_DETAIL_SAFE_MODE_HPP
+#define BOOST_MULTI_INDEX_DETAIL_SAFE_MODE_HPP
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+/* Safe mode machinery, in the spirit of Cay Hortmann's "Safe STL"
+ * (http://www.horstmann.com/safestl.html).
+ * In this mode, containers of type Container are derived from
+ * safe_container<Container>, and their corresponding iterators
+ * are wrapped with safe_iterator. These classes provide
+ * an internal record of which iterators are at a given moment associated
+ * to a given container, and properly mark the iterators as invalid
+ * when the container gets destroyed.
+ * Iterators are chained in a single attached list, whose header is
+ * kept by the container. More elaborate data structures would yield better
+ * performance, but I decided to keep complexity to a minimum since
+ * speed is not an issue here.
+ * Safe mode iterators automatically check that only proper operations
+ * are performed on them: for instance, an invalid iterator cannot be
+ * dereferenced. Additionally, a set of utilty macros and functions are
+ * provided that serve to implement preconditions and cooperate with
+ * the framework within the container.
+ * Iterators can also be unchecked, i.e. they do not have info about
+ * which container they belong in. This situation arises when the iterator
+ * is restored from a serialization archive: only information on the node
+ * is available, and it is not possible to determine to which container
+ * the iterator is associated to. The only sensible policy is to assume
+ * unchecked iterators are valid, though this can certainly generate false
+ * positive safe mode checks.
+ * This is not a full-fledged safe mode framework, and is only intended
+ * for use within the limits of Boost.MultiIndex.
+ */
+
+/* Assertion macros. These resolve to no-ops if
+ * !defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE).
+ */
+
+#if !defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
+#undef BOOST_MULTI_INDEX_SAFE_MODE_ASSERT
+#define BOOST_MULTI_INDEX_SAFE_MODE_ASSERT(expr,error_code) ((void)0)
+#else
+#if !defined(BOOST_MULTI_INDEX_SAFE_MODE_ASSERT)
+#include <boost/assert.hpp>
+#define BOOST_MULTI_INDEX_SAFE_MODE_ASSERT(expr,error_code) BOOST_ASSERT(expr)
+#endif
+#endif
+
+#define BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(it)                           \
+  BOOST_MULTI_INDEX_SAFE_MODE_ASSERT(                                        \
+    safe_mode::check_valid_iterator(it),                                     \
+    safe_mode::invalid_iterator);
+
+#define BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(it)                 \
+  BOOST_MULTI_INDEX_SAFE_MODE_ASSERT(                                        \
+    safe_mode::check_dereferenceable_iterator(it),                           \
+    safe_mode::not_dereferenceable_iterator);
+
+#define BOOST_MULTI_INDEX_CHECK_INCREMENTABLE_ITERATOR(it)                   \
+  BOOST_MULTI_INDEX_SAFE_MODE_ASSERT(                                        \
+    safe_mode::check_incrementable_iterator(it),                             \
+    safe_mode::not_incrementable_iterator);
+
+#define BOOST_MULTI_INDEX_CHECK_DECREMENTABLE_ITERATOR(it)                   \
+  BOOST_MULTI_INDEX_SAFE_MODE_ASSERT(                                        \
+    safe_mode::check_decrementable_iterator(it),                             \
+    safe_mode::not_decrementable_iterator);
+
+#define BOOST_MULTI_INDEX_CHECK_IS_OWNER(it,cont)                            \
+  BOOST_MULTI_INDEX_SAFE_MODE_ASSERT(                                        \
+    safe_mode::check_is_owner(it,cont),                                      \
+    safe_mode::not_owner);
+
+#define BOOST_MULTI_INDEX_CHECK_SAME_OWNER(it0,it1)                          \
+  BOOST_MULTI_INDEX_SAFE_MODE_ASSERT(                                        \
+    safe_mode::check_same_owner(it0,it1),                                    \
+    safe_mode::not_same_owner);
+
+#define BOOST_MULTI_INDEX_CHECK_VALID_RANGE(it0,it1)                         \
+  BOOST_MULTI_INDEX_SAFE_MODE_ASSERT(                                        \
+    safe_mode::check_valid_range(it0,it1),                                   \
+    safe_mode::invalid_range);
+
+#define BOOST_MULTI_INDEX_CHECK_OUTSIDE_RANGE(it,it0,it1)                    \
+  BOOST_MULTI_INDEX_SAFE_MODE_ASSERT(                                        \
+    safe_mode::check_outside_range(it,it0,it1),                              \
+    safe_mode::inside_range);
+
+#define BOOST_MULTI_INDEX_CHECK_IN_BOUNDS(it,n)                              \
+  BOOST_MULTI_INDEX_SAFE_MODE_ASSERT(                                        \
+    safe_mode::check_in_bounds(it,n),                                        \
+    safe_mode::out_of_bounds);
+
+#define BOOST_MULTI_INDEX_CHECK_DIFFERENT_CONTAINER(cont0,cont1)             \
+  BOOST_MULTI_INDEX_SAFE_MODE_ASSERT(                                        \
+    safe_mode::check_different_container(cont0,cont1),                       \
+    safe_mode::same_container);
+
+#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
+#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
+#include <algorithm>
+#include <boost/detail/iterator.hpp>
+#include <boost/multi_index/detail/access_specifier.hpp>
+#include <boost/multi_index/detail/iter_adaptor.hpp>
+#include <boost/multi_index/safe_mode_errors.hpp>
+#include <boost/noncopyable.hpp>
+
+#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
+#include <boost/serialization/split_member.hpp>
+#include <boost/serialization/version.hpp>
+#endif
+
+#if defined(BOOST_HAS_THREADS)
+#include <boost/detail/lightweight_mutex.hpp>
+#endif
+
+namespace boost{
+
+namespace multi_index{
+
+namespace safe_mode{
+
+/* Checking routines. Assume the best for unchecked iterators
+ * (i.e. they pass the checking when there is not enough info
+ * to know.)
+ */
+
+template<typename Iterator>
+inline bool check_valid_iterator(const Iterator& it)
+{
+  return it.valid()||it.unchecked();
+}
+
+template<typename Iterator>
+inline bool check_dereferenceable_iterator(const Iterator& it)
+{
+  return (it.valid()&&it!=it.owner()->end())||it.unchecked();
+}
+
+template<typename Iterator>
+inline bool check_incrementable_iterator(const Iterator& it)
+{
+  return (it.valid()&&it!=it.owner()->end())||it.unchecked();
+}
+
+template<typename Iterator>
+inline bool check_decrementable_iterator(const Iterator& it)
+{
+  return (it.valid()&&it!=it.owner()->begin())||it.unchecked();
+}
+
+template<typename Iterator>
+inline bool check_is_owner(
+  const Iterator& it,const typename Iterator::container_type& cont)
+{
+  return (it.valid()&&it.owner()==&cont)||it.unchecked();
+}
+
+template<typename Iterator>
+inline bool check_same_owner(const Iterator& it0,const Iterator& it1)
+{
+  return (it0.valid()&&it1.valid()&&it0.owner()==it1.owner())||
+         it0.unchecked()||it1.unchecked();
+}
+
+template<typename Iterator>
+inline bool check_valid_range(const Iterator& it0,const Iterator& it1)
+{
+  if(!check_same_owner(it0,it1))return false;
+
+  if(it0.valid()){
+    Iterator last=it0.owner()->end();
+    if(it1==last)return true;
+
+    for(Iterator first=it0;first!=last;++first){
+      if(first==it1)return true;
+    }
+    return false;
+  }
+  return true;
+}
+
+template<typename Iterator>
+inline bool check_outside_range(
+  const Iterator& it,const Iterator& it0,const Iterator& it1)
+{
+  if(!check_same_owner(it0,it1))return false;
+
+  if(it0.valid()){
+    Iterator last=it0.owner()->end();
+    bool found=false;
+
+    Iterator first=it0;
+    for(;first!=last;++first){
+      if(first==it1)break;
+    
+      /* crucial that this check goes after previous break */
+    
+      if(first==it)found=true;
+    }
+    if(first!=it1)return false;
+    return !found;
+  }
+  return true;
+}
+
+template<typename Iterator,typename Difference>
+inline bool check_in_bounds(const Iterator& it,Difference n)
+{
+  if(it.unchecked())return true;
+  if(!it.valid())   return false;
+  if(n>0)           return it.owner()->end()-it>=n;
+  else              return it.owner()->begin()-it<=n;
+}
+
+template<typename Container>
+inline bool check_different_container(
+  const Container& cont0,const Container& cont1)
+{
+  return &cont0!=&cont1;
+}
+
+/* Invalidates all iterators equivalent to that given. Safe containers
+ * must call this when deleting elements: the safe mode framework cannot
+ * perform this operation automatically without outside help.
+ */
+
+template<typename Iterator>
+inline void detach_equivalent_iterators(Iterator& it)
+{
+  if(it.valid()){
+    {
+#if defined(BOOST_HAS_THREADS)
+      boost::detail::lightweight_mutex::scoped_lock lock(it.cont->mutex);
+#endif
+
+      Iterator *prev_,*next_;
+      for(
+        prev_=static_cast<Iterator*>(&it.cont->header);
+        (next_=static_cast<Iterator*>(prev_->next))!=0;){
+        if(next_!=&it&&*next_==it){
+          prev_->next=next_->next;
+          next_->cont=0;
+        }
+        else prev_=next_;
+      }
+    }
+    it.detach();
+  }
+}
+
+template<typename Container> class safe_container; /* fwd decl. */
+
+} /* namespace multi_index::safe_mode */
+
+namespace detail{
+
+class safe_container_base;                 /* fwd decl. */
+
+class safe_iterator_base
+{
+public:
+  bool valid()const{return cont!=0;}
+  bool unchecked()const{return unchecked_;}
+
+  inline void detach();
+
+  void uncheck()
+  {
+    detach();
+    unchecked_=true;
+  }
+
+protected:
+  safe_iterator_base():cont(0),next(0),unchecked_(false){}
+
+  explicit safe_iterator_base(safe_container_base* cont_):
+    unchecked_(false)
+  {
+    attach(cont_);
+  }
+
+  safe_iterator_base(const safe_iterator_base& it):
+    unchecked_(it.unchecked_)
+  {
+    attach(it.cont);
+  }
+
+  safe_iterator_base& operator=(const safe_iterator_base& it)
+  {
+    unchecked_=it.unchecked_;
+    safe_container_base* new_cont=it.cont;
+    if(cont!=new_cont){
+      detach();
+      attach(new_cont);
+    }
+    return *this;
+  }
+
+  ~safe_iterator_base()
+  {
+    detach();
+  }
+
+  const safe_container_base* owner()const{return cont;}
+
+BOOST_MULTI_INDEX_PRIVATE_IF_MEMBER_TEMPLATE_FRIENDS:
+  friend class safe_container_base;
+
+#if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
+  template<typename>          friend class safe_mode::safe_container;
+  template<typename Iterator> friend
+    void safe_mode::detach_equivalent_iterators(Iterator&);
+#endif
+
+  inline void attach(safe_container_base* cont_);
+
+  safe_container_base* cont;
+  safe_iterator_base*  next;
+  bool                 unchecked_;
+};
+
+class safe_container_base:private noncopyable
+{
+public:
+  safe_container_base(){}
+
+BOOST_MULTI_INDEX_PROTECTED_IF_MEMBER_TEMPLATE_FRIENDS:
+  friend class safe_iterator_base;
+
+#if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
+  template<typename Iterator> friend
+    void safe_mode::detach_equivalent_iterators(Iterator&);
+#endif
+
+  ~safe_container_base()
+  {
+    /* Detaches all remaining iterators, which by now will
+     * be those pointing to the end of the container.
+     */
+
+    for(safe_iterator_base* it=header.next;it;it=it->next)it->cont=0;
+    header.next=0;
+  }
+
+  void swap(safe_container_base& x)
+  {
+    for(safe_iterator_base* it0=header.next;it0;it0=it0->next)it0->cont=&x;
+    for(safe_iterator_base* it1=x.header.next;it1;it1=it1->next)it1->cont=this;
+    std::swap(header.cont,x.header.cont);
+    std::swap(header.next,x.header.next);
+  }
+
+  safe_iterator_base header;
+
+#if defined(BOOST_HAS_THREADS)
+  boost::detail::lightweight_mutex mutex;
+#endif
+};
+
+void safe_iterator_base::attach(safe_container_base* cont_)
+{
+  cont=cont_;
+  if(cont){
+#if defined(BOOST_HAS_THREADS)
+    boost::detail::lightweight_mutex::scoped_lock lock(cont->mutex);
+#endif
+
+    next=cont->header.next;
+    cont->header.next=this;
+  }
+}
+
+void safe_iterator_base::detach()
+{
+  if(cont){
+#if defined(BOOST_HAS_THREADS)
+    boost::detail::lightweight_mutex::scoped_lock lock(cont->mutex);
+#endif
+
+    safe_iterator_base *prev_,*next_;
+    for(prev_=&cont->header;(next_=prev_->next)!=this;prev_=next_){}
+    prev_->next=next;
+    cont=0;
+  }
+}
+
+} /* namespace multi_index::detail */
+
+namespace safe_mode{
+
+/* In order to enable safe mode on a container:
+ *   - The container must derive from safe_container<container_type>,
+ *   - iterators must be generated via safe_iterator, which adapts a
+ *     preexistent unsafe iterator class.
+ */
+ 
+template<typename Container>
+class safe_container;
+
+template<typename Iterator,typename Container>
+class safe_iterator:
+  public detail::iter_adaptor<safe_iterator<Iterator,Container>,Iterator>,
+  public detail::safe_iterator_base
+{
+  typedef detail::iter_adaptor<safe_iterator,Iterator> super;
+  typedef detail::safe_iterator_base                   safe_super;
+
+public:
+  typedef Container                                    container_type;
+  typedef typename Iterator::reference                 reference;
+  typedef typename Iterator::difference_type           difference_type;
+
+  safe_iterator(){}
+  explicit safe_iterator(safe_container<container_type>* cont_):
+    safe_super(cont_){}
+  template<typename T0>
+  safe_iterator(const T0& t0,safe_container<container_type>* cont_):
+    super(Iterator(t0)),safe_super(cont_){}
+  template<typename T0,typename T1>
+  safe_iterator(
+    const T0& t0,const T1& t1,safe_container<container_type>* cont_):
+    super(Iterator(t0,t1)),safe_super(cont_){}
+
+  safe_iterator& operator=(const safe_iterator& x)
+  {
+    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(x);
+    this->base_reference()=x.base_reference();
+    safe_super::operator=(x);
+    return *this;
+  }
+
+  const container_type* owner()const
+  {
+    return
+      static_cast<const container_type*>(
+        static_cast<const safe_container<container_type>*>(
+          this->safe_super::owner()));
+  }
+
+  /* get_node is not to be used by the user */
+
+  typedef typename Iterator::node_type node_type;
+
+  node_type* get_node()const{return this->base_reference().get_node();}
+
+private:
+  friend class boost::multi_index::detail::iter_adaptor_access;
+
+  reference dereference()const
+  {
+    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(*this);
+    BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(*this);
+    return *(this->base_reference());
+  }
+
+  bool equal(const safe_iterator& x)const
+  {
+    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(*this);
+    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(x);
+    BOOST_MULTI_INDEX_CHECK_SAME_OWNER(*this,x);
+    return this->base_reference()==x.base_reference();
+  }
+
+  void increment()
+  {
+    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(*this);
+    BOOST_MULTI_INDEX_CHECK_INCREMENTABLE_ITERATOR(*this);
+    ++(this->base_reference());
+  }
+
+  void decrement()
+  {
+    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(*this);
+    BOOST_MULTI_INDEX_CHECK_DECREMENTABLE_ITERATOR(*this);
+    --(this->base_reference());
+  }
+
+  void advance(difference_type n)
+  {
+    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(*this);
+    BOOST_MULTI_INDEX_CHECK_IN_BOUNDS(*this,n);
+    this->base_reference()+=n;
+  }
+
+  difference_type distance_to(const safe_iterator& x)const
+  {
+    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(*this);
+    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(x);
+    BOOST_MULTI_INDEX_CHECK_SAME_OWNER(*this,x);
+    return x.base_reference()-this->base_reference();
+  }
+
+#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
+  /* Serialization. Note that Iterator::save and Iterator:load
+   * are assumed to be defined and public: at first sight it seems
+   * like we could have resorted to the public serialization interface
+   * for doing the forwarding to the adapted iterator class:
+   *   ar<<base_reference();
+   *   ar>>base_reference();
+   * but this would cause incompatibilities if a saving
+   * program is in safe mode and the loading program is not, or
+   * viceversa --in safe mode, the archived iterator data is one layer
+   * deeper, this is especially relevant with XML archives.
+   * It'd be nice if Boost.Serialization provided some forwarding
+   * facility for use by adaptor classes.
+   */ 
+
+  friend class boost::serialization::access;
+
+  BOOST_SERIALIZATION_SPLIT_MEMBER()
+
+  template<class Archive>
+  void save(Archive& ar,const unsigned int version)const
+  {
+    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(*this);
+    this->base_reference().save(ar,version);
+  }
+
+  template<class Archive>
+  void load(Archive& ar,const unsigned int version)
+  {
+    this->base_reference().load(ar,version);
+    safe_super::uncheck();
+  }
+#endif
+};
+
+template<typename Container>
+class safe_container:public detail::safe_container_base
+{
+  typedef detail::safe_container_base super;
+
+public:
+  void detach_dereferenceable_iterators()
+  {
+    typedef typename Container::iterator iterator;
+
+    iterator end_=static_cast<Container*>(this)->end();
+    iterator *prev_,*next_;
+    for(
+      prev_=static_cast<iterator*>(&this->header);
+      (next_=static_cast<iterator*>(prev_->next))!=0;){
+      if(*next_!=end_){
+        prev_->next=next_->next;
+        next_->cont=0;
+      }
+      else prev_=next_;
+    }
+  }
+
+  void swap(safe_container<Container>& x)
+  {
+    super::swap(x);
+  }
+};
+
+} /* namespace multi_index::safe_mode */
+
+} /* namespace multi_index */
+
+#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
+namespace serialization{
+template<typename Iterator,typename Container>
+struct version<
+  boost::multi_index::safe_mode::safe_iterator<Iterator,Container>
+>
+{
+  BOOST_STATIC_CONSTANT(
+    int,value=boost::serialization::version<Iterator>::value);
+};
+} /* namespace serialization */
+#endif
+
+} /* namespace boost */
+
+#endif /* BOOST_MULTI_INDEX_ENABLE_SAFE_MODE */
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/scope_guard.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/scope_guard.hpp
new file mode 100644
index 00000000000..116f8f50415
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/scope_guard.hpp
@@ -0,0 +1,453 @@
+/* Copyright 2003-2013 Joaquin M Lopez Munoz.
+ * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
+ */
+
+#ifndef BOOST_MULTI_INDEX_DETAIL_SCOPE_GUARD_HPP
+#define BOOST_MULTI_INDEX_DETAIL_SCOPE_GUARD_HPP
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/detail/no_exceptions_support.hpp>
+#include <boost/mpl/if.hpp>
+
+namespace boost{
+
+namespace multi_index{
+
+namespace detail{
+
+/* Until some official version of the ScopeGuard idiom makes it into Boost,
+ * we locally define our own. This is a merely reformated version of
+ * ScopeGuard.h as defined in:
+ *   Alexandrescu, A., Marginean, P.:"Generic<Programming>: Change the Way You
+ *     Write Exception-Safe Code - Forever", C/C++ Users Jornal, Dec 2000,
+ *     http://www.drdobbs.com/184403758
+ * with the following modifications:
+ *   - General pretty formatting (pretty to my taste at least.)
+ *   - Naming style changed to standard C++ library requirements.
+ *   - Added scope_guard_impl4 and obj_scope_guard_impl3, (Boost.MultiIndex
+ *     needs them). A better design would provide guards for many more
+ *     arguments through the Boost Preprocessor Library.
+ *   - Added scope_guard_impl_base::touch (see below.)
+ *   - Removed RefHolder and ByRef, whose functionality is provided
+ *     already by Boost.Ref.
+ *   - Removed static make_guard's and make_obj_guard's, so that the code
+ *     will work even if BOOST_NO_MEMBER_TEMPLATES is defined. This forces
+ *     us to move some private ctors to public, though.
+ *
+ * NB: CodeWarrior Pro 8 seems to have problems looking up safe_execute
+ * without an explicit qualification.
+ * 
+ * We also define the following variants of the idiom:
+ * 
+ *   - make_guard_if_c<bool>( ... )
+ *   - make_guard_if<IntegralConstant>( ... )
+ *   - make_obj_guard_if_c<bool>( ... )
+ *   - make_obj_guard_if<IntegralConstant>( ... )
+ * which may be used with a compile-time constant to yield
+ * a "null_guard" if the boolean compile-time parameter is false,
+ * or conversely, the guard is only constructed if the constant is true.
+ * This is useful to avoid extra tagging, because the returned
+ * null_guard can be optimzed comlpetely away by the compiler.
+ */
+
+class scope_guard_impl_base
+{
+public:
+  scope_guard_impl_base():dismissed_(false){}
+  void dismiss()const{dismissed_=true;}
+
+  /* This helps prevent some "unused variable" warnings under, for instance,
+   * GCC 3.2.
+   */
+  void touch()const{}
+
+protected:
+  ~scope_guard_impl_base(){}
+
+  scope_guard_impl_base(const scope_guard_impl_base& other):
+    dismissed_(other.dismissed_)
+  {
+    other.dismiss();
+  }
+
+  template<typename J>
+  static void safe_execute(J& j){
+    BOOST_TRY{
+      if(!j.dismissed_)j.execute();
+    }
+    BOOST_CATCH(...){}
+    BOOST_CATCH_END
+  }
+  
+  mutable bool dismissed_;
+
+private:
+  scope_guard_impl_base& operator=(const scope_guard_impl_base&);
+};
+
+typedef const scope_guard_impl_base& scope_guard;
+
+struct null_guard : public scope_guard_impl_base
+{
+    template< class T1 >
+    null_guard( const T1& )
+    { }
+
+    template< class T1, class T2 >
+    null_guard( const T1&, const T2& )
+    { }
+
+    template< class T1, class T2, class T3 >
+    null_guard( const T1&, const T2&, const T3& )
+    { }
+
+    template< class T1, class T2, class T3, class T4 >
+    null_guard( const T1&, const T2&, const T3&, const T4& )
+    { }
+
+    template< class T1, class T2, class T3, class T4, class T5 >
+    null_guard( const T1&, const T2&, const T3&, const T4&, const T5& )
+    { }
+};
+
+template< bool cond, class T >
+struct null_guard_return
+{
+    typedef typename boost::mpl::if_c<cond,T,null_guard>::type type;
+};
+
+template<typename F>
+class scope_guard_impl0:public scope_guard_impl_base
+{
+public:
+  scope_guard_impl0(F fun):fun_(fun){}
+  ~scope_guard_impl0(){scope_guard_impl_base::safe_execute(*this);}
+  void execute(){fun_();}
+
+protected:
+
+  F fun_;
+};
+
+template<typename F> 
+inline scope_guard_impl0<F> make_guard(F fun)
+{
+  return scope_guard_impl0<F>(fun);
+}
+
+template<bool cond, typename F> 
+inline typename null_guard_return<cond,scope_guard_impl0<F> >::type  
+make_guard_if_c(F fun)
+{
+  return typename null_guard_return<cond,scope_guard_impl0<F> >::type(fun);
+}
+
+template<typename C, typename F> 
+inline typename null_guard_return<C::value,scope_guard_impl0<F> >::type  
+make_guard_if(F fun)
+{
+  return make_guard_if<C::value>(fun);
+}
+
+template<typename F,typename P1>
+class scope_guard_impl1:public scope_guard_impl_base
+{
+public:
+  scope_guard_impl1(F fun,P1 p1):fun_(fun),p1_(p1){}
+  ~scope_guard_impl1(){scope_guard_impl_base::safe_execute(*this);}
+  void execute(){fun_(p1_);}
+
+protected:
+  F        fun_;
+  const P1 p1_;
+};
+
+template<typename F,typename P1> 
+inline scope_guard_impl1<F,P1> make_guard(F fun,P1 p1)
+{
+  return scope_guard_impl1<F,P1>(fun,p1);
+}
+
+template<bool cond, typename F,typename P1> 
+inline typename null_guard_return<cond,scope_guard_impl1<F,P1> >::type 
+make_guard_if_c(F fun,P1 p1)
+{
+  return typename null_guard_return<cond,scope_guard_impl1<F,P1> >::type(fun,p1);
+}
+
+template<typename C, typename F,typename P1> 
+inline typename null_guard_return<C::value,scope_guard_impl1<F,P1> >::type 
+make_guard_if(F fun,P1 p1)
+{
+  return make_guard_if_c<C::value>(fun,p1);
+}
+
+template<typename F,typename P1,typename P2>
+class scope_guard_impl2:public scope_guard_impl_base
+{
+public:
+  scope_guard_impl2(F fun,P1 p1,P2 p2):fun_(fun),p1_(p1),p2_(p2){}
+  ~scope_guard_impl2(){scope_guard_impl_base::safe_execute(*this);}
+  void execute(){fun_(p1_,p2_);}
+
+protected:
+  F        fun_;
+  const P1 p1_;
+  const P2 p2_;
+};
+
+template<typename F,typename P1,typename P2>
+inline scope_guard_impl2<F,P1,P2> make_guard(F fun,P1 p1,P2 p2)
+{
+  return scope_guard_impl2<F,P1,P2>(fun,p1,p2);
+}
+
+template<bool cond, typename F,typename P1,typename P2>
+inline typename null_guard_return<cond,scope_guard_impl2<F,P1,P2> >::type
+make_guard_if_c(F fun,P1 p1,P2 p2)
+{
+  return typename null_guard_return<cond,scope_guard_impl2<F,P1,P2> >::type(fun,p1,p2);
+}
+
+template<typename C, typename F,typename P1,typename P2>
+inline typename null_guard_return<C::value,scope_guard_impl2<F,P1,P2> >::type
+make_guard_if(F fun,P1 p1,P2 p2)
+{
+  return make_guard_if_c<C::value>(fun,p1,p2);
+}
+
+template<typename F,typename P1,typename P2,typename P3>
+class scope_guard_impl3:public scope_guard_impl_base
+{
+public:
+  scope_guard_impl3(F fun,P1 p1,P2 p2,P3 p3):fun_(fun),p1_(p1),p2_(p2),p3_(p3){}
+  ~scope_guard_impl3(){scope_guard_impl_base::safe_execute(*this);}
+  void execute(){fun_(p1_,p2_,p3_);}
+
+protected:
+  F        fun_;
+  const P1 p1_;
+  const P2 p2_;
+  const P3 p3_;
+};
+
+template<typename F,typename P1,typename P2,typename P3>
+inline scope_guard_impl3<F,P1,P2,P3> make_guard(F fun,P1 p1,P2 p2,P3 p3)
+{
+  return scope_guard_impl3<F,P1,P2,P3>(fun,p1,p2,p3);
+}
+
+template<bool cond,typename F,typename P1,typename P2,typename P3>
+inline typename null_guard_return<cond,scope_guard_impl3<F,P1,P2,P3> >::type 
+make_guard_if_c(F fun,P1 p1,P2 p2,P3 p3)
+{
+  return typename null_guard_return<cond,scope_guard_impl3<F,P1,P2,P3> >::type(fun,p1,p2,p3);
+}
+
+template<typename C,typename F,typename P1,typename P2,typename P3>
+inline typename null_guard_return< C::value,scope_guard_impl3<F,P1,P2,P3> >::type 
+make_guard_if(F fun,P1 p1,P2 p2,P3 p3)
+{
+  return make_guard_if_c<C::value>(fun,p1,p2,p3);
+}
+
+template<typename F,typename P1,typename P2,typename P3,typename P4>
+class scope_guard_impl4:public scope_guard_impl_base
+{
+public:
+  scope_guard_impl4(F fun,P1 p1,P2 p2,P3 p3,P4 p4):
+    fun_(fun),p1_(p1),p2_(p2),p3_(p3),p4_(p4){}
+  ~scope_guard_impl4(){scope_guard_impl_base::safe_execute(*this);}
+  void execute(){fun_(p1_,p2_,p3_,p4_);}
+
+protected:
+  F        fun_;
+  const P1 p1_;
+  const P2 p2_;
+  const P3 p3_;
+  const P4 p4_;
+};
+
+template<typename F,typename P1,typename P2,typename P3,typename P4>
+inline scope_guard_impl4<F,P1,P2,P3,P4> make_guard(
+  F fun,P1 p1,P2 p2,P3 p3,P4 p4)
+{
+  return scope_guard_impl4<F,P1,P2,P3,P4>(fun,p1,p2,p3,p4);
+}
+
+template<bool cond, typename F,typename P1,typename P2,typename P3,typename P4>
+inline typename null_guard_return<cond,scope_guard_impl4<F,P1,P2,P3,P4> >::type 
+make_guard_if_c(
+  F fun,P1 p1,P2 p2,P3 p3,P4 p4)
+{
+  return typename null_guard_return<cond,scope_guard_impl4<F,P1,P2,P3,P4> >::type(fun,p1,p2,p3,p4);
+}
+
+template<typename C, typename F,typename P1,typename P2,typename P3,typename P4>
+inline typename null_guard_return<C::value,scope_guard_impl4<F,P1,P2,P3,P4> >::type 
+make_guard_if(
+  F fun,P1 p1,P2 p2,P3 p3,P4 p4)
+{
+  return make_guard_if_c<C::value>(fun,p1,p2,p3,p4);
+}
+
+template<class Obj,typename MemFun>
+class obj_scope_guard_impl0:public scope_guard_impl_base
+{
+public:
+  obj_scope_guard_impl0(Obj& obj,MemFun mem_fun):obj_(obj),mem_fun_(mem_fun){}
+  ~obj_scope_guard_impl0(){scope_guard_impl_base::safe_execute(*this);}
+  void execute(){(obj_.*mem_fun_)();}
+
+protected:
+  Obj&   obj_;
+  MemFun mem_fun_;
+};
+
+template<class Obj,typename MemFun>
+inline obj_scope_guard_impl0<Obj,MemFun> make_obj_guard(Obj& obj,MemFun mem_fun)
+{
+  return obj_scope_guard_impl0<Obj,MemFun>(obj,mem_fun);
+}
+
+template<bool cond, class Obj,typename MemFun>
+inline typename null_guard_return<cond,obj_scope_guard_impl0<Obj,MemFun> >::type 
+make_obj_guard_if_c(Obj& obj,MemFun mem_fun)
+{
+  return typename null_guard_return<cond,obj_scope_guard_impl0<Obj,MemFun> >::type(obj,mem_fun);
+}
+
+template<typename C, class Obj,typename MemFun>
+inline typename null_guard_return<C::value,obj_scope_guard_impl0<Obj,MemFun> >::type 
+make_obj_guard_if(Obj& obj,MemFun mem_fun)
+{
+  return make_obj_guard_if_c<C::value>(obj,mem_fun);
+}
+
+template<class Obj,typename MemFun,typename P1>
+class obj_scope_guard_impl1:public scope_guard_impl_base
+{
+public:
+  obj_scope_guard_impl1(Obj& obj,MemFun mem_fun,P1 p1):
+    obj_(obj),mem_fun_(mem_fun),p1_(p1){}
+  ~obj_scope_guard_impl1(){scope_guard_impl_base::safe_execute(*this);}
+  void execute(){(obj_.*mem_fun_)(p1_);}
+
+protected:
+  Obj&     obj_;
+  MemFun   mem_fun_;
+  const P1 p1_;
+};
+
+template<class Obj,typename MemFun,typename P1>
+inline obj_scope_guard_impl1<Obj,MemFun,P1> make_obj_guard(
+  Obj& obj,MemFun mem_fun,P1 p1)
+{
+  return obj_scope_guard_impl1<Obj,MemFun,P1>(obj,mem_fun,p1);
+}
+
+template<bool cond, class Obj,typename MemFun,typename P1>
+inline typename null_guard_return<cond,obj_scope_guard_impl1<Obj,MemFun,P1> >::type 
+make_obj_guard_if_c(  Obj& obj,MemFun mem_fun,P1 p1)
+{
+  return typename null_guard_return<cond,obj_scope_guard_impl1<Obj,MemFun,P1> >::type(obj,mem_fun,p1);
+}
+
+template<typename C, class Obj,typename MemFun,typename P1>
+inline typename null_guard_return<C::value,obj_scope_guard_impl1<Obj,MemFun,P1> >::type 
+make_obj_guard_if( Obj& obj,MemFun mem_fun,P1 p1)
+{
+  return make_obj_guard_if_c<C::value>(obj,mem_fun,p1);
+}
+
+template<class Obj,typename MemFun,typename P1,typename P2>
+class obj_scope_guard_impl2:public scope_guard_impl_base
+{
+public:
+  obj_scope_guard_impl2(Obj& obj,MemFun mem_fun,P1 p1,P2 p2):
+    obj_(obj),mem_fun_(mem_fun),p1_(p1),p2_(p2)
+  {}
+  ~obj_scope_guard_impl2(){scope_guard_impl_base::safe_execute(*this);}
+  void execute(){(obj_.*mem_fun_)(p1_,p2_);}
+
+protected:
+  Obj&     obj_;
+  MemFun   mem_fun_;
+  const P1 p1_;
+  const P2 p2_;
+};
+
+template<class Obj,typename MemFun,typename P1,typename P2>
+inline obj_scope_guard_impl2<Obj,MemFun,P1,P2>
+make_obj_guard(Obj& obj,MemFun mem_fun,P1 p1,P2 p2)
+{
+  return obj_scope_guard_impl2<Obj,MemFun,P1,P2>(obj,mem_fun,p1,p2);
+}
+
+template<bool cond, class Obj,typename MemFun,typename P1,typename P2>
+inline typename null_guard_return<cond,obj_scope_guard_impl2<Obj,MemFun,P1,P2> >::type
+make_obj_guard_if_c(Obj& obj,MemFun mem_fun,P1 p1,P2 p2)
+{
+  return typename null_guard_return<cond,obj_scope_guard_impl2<Obj,MemFun,P1,P2> >::type(obj,mem_fun,p1,p2);
+}
+
+template<typename C, class Obj,typename MemFun,typename P1,typename P2>
+inline typename null_guard_return<C::value,obj_scope_guard_impl2<Obj,MemFun,P1,P2> >::type
+make_obj_guard_if(Obj& obj,MemFun mem_fun,P1 p1,P2 p2)
+{
+  return make_obj_guard_if_c<C::value>(obj,mem_fun,p1,p2);
+}
+
+template<class Obj,typename MemFun,typename P1,typename P2,typename P3>
+class obj_scope_guard_impl3:public scope_guard_impl_base
+{
+public:
+  obj_scope_guard_impl3(Obj& obj,MemFun mem_fun,P1 p1,P2 p2,P3 p3):
+    obj_(obj),mem_fun_(mem_fun),p1_(p1),p2_(p2),p3_(p3)
+  {}
+  ~obj_scope_guard_impl3(){scope_guard_impl_base::safe_execute(*this);}
+  void execute(){(obj_.*mem_fun_)(p1_,p2_,p3_);}
+
+protected:
+  Obj&     obj_;
+  MemFun   mem_fun_;
+  const P1 p1_;
+  const P2 p2_;
+  const P3 p3_;
+};
+
+template<class Obj,typename MemFun,typename P1,typename P2,typename P3>
+inline obj_scope_guard_impl3<Obj,MemFun,P1,P2,P3>
+make_obj_guard(Obj& obj,MemFun mem_fun,P1 p1,P2 p2,P3 p3)
+{
+  return obj_scope_guard_impl3<Obj,MemFun,P1,P2,P3>(obj,mem_fun,p1,p2,p3);
+}
+
+template<bool cond, class Obj,typename MemFun,typename P1,typename P2,typename P3>
+inline typename null_guard_return<cond,obj_scope_guard_impl3<Obj,MemFun,P1,P2,P3> >::type
+make_obj_guard_if_c(Obj& obj,MemFun mem_fun,P1 p1,P2 p2,P3 p3)
+{
+  return typename null_guard_return<cond,obj_scope_guard_impl3<Obj,MemFun,P1,P2,P3> >::type(obj,mem_fun,p1,p2,p3);
+}
+
+template<typename C, class Obj,typename MemFun,typename P1,typename P2,typename P3>
+inline typename null_guard_return<C::value,obj_scope_guard_impl3<Obj,MemFun,P1,P2,P3> >::type
+make_obj_guard_if(Obj& obj,MemFun mem_fun,P1 p1,P2 p2,P3 p3)
+{
+  return make_obj_guard_if_c<C::value>(obj,mem_fun,p1,p2,p3);
+}
+
+} /* namespace multi_index::detail */
+
+} /* namespace multi_index */
+
+} /* namespace boost */
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/seq_index_node.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/seq_index_node.hpp
new file mode 100644
index 00000000000..85b345af938
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/seq_index_node.hpp
@@ -0,0 +1,217 @@
+/* Copyright 2003-2015 Joaquin M Lopez Munoz.
+ * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
+ */
+
+#ifndef BOOST_MULTI_INDEX_DETAIL_SEQ_INDEX_NODE_HPP
+#define BOOST_MULTI_INDEX_DETAIL_SEQ_INDEX_NODE_HPP
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
+#include <algorithm>
+#include <boost/detail/allocator_utilities.hpp>
+#include <boost/multi_index/detail/raw_ptr.hpp>
+
+namespace boost{
+
+namespace multi_index{
+
+namespace detail{
+
+/* doubly-linked node for use by sequenced_index */
+
+template<typename Allocator>
+struct sequenced_index_node_impl
+{
+  typedef typename
+  boost::detail::allocator::rebind_to<
+    Allocator,sequenced_index_node_impl
+  >::type::pointer                      pointer;
+  typedef typename
+  boost::detail::allocator::rebind_to<
+    Allocator,sequenced_index_node_impl
+  >::type::const_pointer                const_pointer;
+
+  pointer& prior(){return prior_;}
+  pointer  prior()const{return prior_;}
+  pointer& next(){return next_;}
+  pointer  next()const{return next_;}
+
+  /* interoperability with bidir_node_iterator */
+
+  static void increment(pointer& x){x=x->next();}
+  static void decrement(pointer& x){x=x->prior();}
+
+  /* algorithmic stuff */
+
+  static void link(pointer x,pointer header)
+  {
+    x->prior()=header->prior();
+    x->next()=header;
+    x->prior()->next()=x->next()->prior()=x;
+  };
+
+  static void unlink(pointer x)
+  {
+    x->prior()->next()=x->next();
+    x->next()->prior()=x->prior();
+  }
+
+  static void relink(pointer position,pointer x)
+  {
+    unlink(x);
+    x->prior()=position->prior();
+    x->next()=position;
+    x->prior()->next()=x->next()->prior()=x;
+  }
+
+  static void relink(pointer position,pointer x,pointer y)
+  {
+    /* position is assumed not to be in [x,y) */
+
+    if(x!=y){
+      pointer z=y->prior();
+      x->prior()->next()=y;
+      y->prior()=x->prior();
+      x->prior()=position->prior();
+      z->next()=position;
+      x->prior()->next()=x;
+      z->next()->prior()=z;
+    }
+  }
+
+  static void reverse(pointer header)
+  {
+    pointer x=header;
+    do{
+      pointer y=x->next();
+      std::swap(x->prior(),x->next());
+      x=y;
+    }while(x!=header);
+  }
+
+  static void swap(pointer x,pointer y)
+  {
+    /* This swap function does not exchange the header nodes,
+     * but rather their pointers. This is *not* used for implementing
+     * sequenced_index::swap.
+     */
+
+    if(x->next()!=x){
+      if(y->next()!=y){
+        std::swap(x->next(),y->next());
+        std::swap(x->prior(),y->prior());
+        x->next()->prior()=x->prior()->next()=x;
+        y->next()->prior()=y->prior()->next()=y;
+      }
+      else{
+        y->next()=x->next();
+        y->prior()=x->prior();
+        x->next()=x->prior()=x;
+        y->next()->prior()=y->prior()->next()=y;
+      }
+    }
+    else if(y->next()!=y){
+      x->next()=y->next();
+      x->prior()=y->prior();
+      y->next()=y->prior()=y;
+      x->next()->prior()=x->prior()->next()=x;
+    }
+  }
+
+private:
+  pointer prior_;
+  pointer next_;
+};
+
+template<typename Super>
+struct sequenced_index_node_trampoline:
+  sequenced_index_node_impl<
+    typename boost::detail::allocator::rebind_to<
+      typename Super::allocator_type,
+      char
+    >::type
+  >
+{
+  typedef sequenced_index_node_impl<
+    typename boost::detail::allocator::rebind_to<
+      typename Super::allocator_type,
+      char
+    >::type
+  > impl_type;
+};
+
+template<typename Super>
+struct sequenced_index_node:Super,sequenced_index_node_trampoline<Super>
+{
+private:
+  typedef sequenced_index_node_trampoline<Super> trampoline;
+
+public:
+  typedef typename trampoline::impl_type         impl_type;
+  typedef typename trampoline::pointer           impl_pointer;
+  typedef typename trampoline::const_pointer     const_impl_pointer;
+
+  impl_pointer& prior(){return trampoline::prior();}
+  impl_pointer  prior()const{return trampoline::prior();}
+  impl_pointer& next(){return trampoline::next();}
+  impl_pointer  next()const{return trampoline::next();}
+
+  impl_pointer impl()
+  {
+    return static_cast<impl_pointer>(
+      static_cast<impl_type*>(static_cast<trampoline*>(this)));
+  }
+
+  const_impl_pointer impl()const
+  {
+    return static_cast<const_impl_pointer>(
+      static_cast<const impl_type*>(static_cast<const trampoline*>(this)));
+  }
+
+  static sequenced_index_node* from_impl(impl_pointer x)
+  {
+    return
+      static_cast<sequenced_index_node*>(
+        static_cast<trampoline*>(
+          raw_ptr<impl_type*>(x)));
+  }
+
+  static const sequenced_index_node* from_impl(const_impl_pointer x)
+  {
+    return
+      static_cast<const sequenced_index_node*>(
+        static_cast<const trampoline*>(
+          raw_ptr<const impl_type*>(x)));
+  }
+
+  /* interoperability with bidir_node_iterator */
+
+  static void increment(sequenced_index_node*& x)
+  {
+    impl_pointer xi=x->impl();
+    trampoline::increment(xi);
+    x=from_impl(xi);
+  }
+
+  static void decrement(sequenced_index_node*& x)
+  {
+    impl_pointer xi=x->impl();
+    trampoline::decrement(xi);
+    x=from_impl(xi);
+  }
+};
+
+} /* namespace multi_index::detail */
+
+} /* namespace multi_index */
+
+} /* namespace boost */
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/seq_index_ops.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/seq_index_ops.hpp
new file mode 100644
index 00000000000..142bdd9dd9a
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/seq_index_ops.hpp
@@ -0,0 +1,203 @@
+/* Copyright 2003-2016 Joaquin M Lopez Munoz.
+ * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
+ */
+
+#ifndef BOOST_MULTI_INDEX_DETAIL_SEQ_INDEX_OPS_HPP
+#define BOOST_MULTI_INDEX_DETAIL_SEQ_INDEX_OPS_HPP
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
+#include <boost/detail/no_exceptions_support.hpp>
+#include <boost/multi_index/detail/seq_index_node.hpp>
+#include <boost/limits.hpp>
+#include <boost/type_traits/aligned_storage.hpp>
+#include <boost/type_traits/alignment_of.hpp> 
+#include <cstddef>
+
+namespace boost{
+
+namespace multi_index{
+
+namespace detail{
+
+/* Common code for sequenced_index memfuns having templatized and
+ * non-templatized versions.
+ */
+
+template <typename SequencedIndex,typename Predicate>
+void sequenced_index_remove(SequencedIndex& x,Predicate pred)
+{
+  typedef typename SequencedIndex::iterator iterator;
+  iterator first=x.begin(),last=x.end();
+  while(first!=last){
+    if(pred(*first))x.erase(first++);
+    else ++first;
+  }
+}
+
+template <typename SequencedIndex,class BinaryPredicate>
+void sequenced_index_unique(SequencedIndex& x,BinaryPredicate binary_pred)
+{
+  typedef typename SequencedIndex::iterator iterator;
+  iterator first=x.begin();
+  iterator last=x.end();
+  if(first!=last){
+    for(iterator middle=first;++middle!=last;middle=first){
+      if(binary_pred(*middle,*first))x.erase(middle);
+      else first=middle;
+    }
+  }
+}
+
+template <typename SequencedIndex,typename Compare>
+void sequenced_index_merge(SequencedIndex& x,SequencedIndex& y,Compare comp)
+{
+  typedef typename SequencedIndex::iterator iterator;
+  if(&x!=&y){
+    iterator first0=x.begin(),last0=x.end();
+    iterator first1=y.begin(),last1=y.end();
+    while(first0!=last0&&first1!=last1){
+      if(comp(*first1,*first0))x.splice(first0,y,first1++);
+      else ++first0;
+    }
+    x.splice(last0,y,first1,last1);
+  }
+}
+
+/* sorting  */
+
+/* auxiliary stuff */
+
+template<typename Node,typename Compare>
+void sequenced_index_collate(
+  BOOST_DEDUCED_TYPENAME Node::impl_type* x,
+  BOOST_DEDUCED_TYPENAME Node::impl_type* y,
+  Compare comp)
+{
+  typedef typename Node::impl_type    impl_type;
+  typedef typename Node::impl_pointer impl_pointer;
+
+  impl_pointer first0=x->next();
+  impl_pointer last0=x;
+  impl_pointer first1=y->next();
+  impl_pointer last1=y;
+  while(first0!=last0&&first1!=last1){
+    if(comp(
+        Node::from_impl(first1)->value(),Node::from_impl(first0)->value())){
+      impl_pointer tmp=first1->next();
+      impl_type::relink(first0,first1);
+      first1=tmp;
+    }
+    else first0=first0->next();
+  }
+  impl_type::relink(last0,first1,last1);
+}
+
+/* Some versions of CGG require a bogus typename in counter_spc
+ * inside sequenced_index_sort if the following is defined
+ * also inside sequenced_index_sort.
+ */
+
+BOOST_STATIC_CONSTANT(
+  std::size_t,
+  sequenced_index_sort_max_fill=
+    (std::size_t)std::numeric_limits<std::size_t>::digits+1);
+
+#include <boost/multi_index/detail/ignore_wstrict_aliasing.hpp>
+
+template<typename Node,typename Compare>
+void sequenced_index_sort(Node* header,Compare comp)
+{
+  /* Musser's mergesort, see http://www.cs.rpi.edu/~musser/gp/List/lists1.html.
+   * The implementation is a little convoluted: in the original code
+   * counter elements and carry are std::lists: here we do not want
+   * to use multi_index instead, so we do things at a lower level, managing
+   * directly the internal node representation.
+   * Incidentally, the implementations I've seen of this algorithm (SGI,
+   * Dinkumware, STLPort) are not exception-safe: this is. Moreover, we do not
+   * use any dynamic storage.
+   */
+
+  if(header->next()==header->impl()||
+     header->next()->next()==header->impl())return;
+
+  typedef typename Node::impl_type      impl_type;
+  typedef typename Node::impl_pointer   impl_pointer;
+
+  typedef typename aligned_storage<
+    sizeof(impl_type),
+    alignment_of<impl_type>::value
+  >::type                               carry_spc_type;
+  carry_spc_type                        carry_spc;
+  impl_type&                            carry=
+    *reinterpret_cast<impl_type*>(&carry_spc);
+  typedef typename aligned_storage<
+    sizeof(
+      impl_type
+        [sequenced_index_sort_max_fill]),
+    alignment_of<
+      impl_type
+        [sequenced_index_sort_max_fill]
+    >::value
+  >::type                               counter_spc_type;
+  counter_spc_type                      counter_spc;
+  impl_type*                            counter=
+    reinterpret_cast<impl_type*>(&counter_spc);
+  std::size_t                           fill=0;
+
+  carry.prior()=carry.next()=static_cast<impl_pointer>(&carry);
+  counter[0].prior()=counter[0].next()=static_cast<impl_pointer>(&counter[0]);
+
+  BOOST_TRY{
+    while(header->next()!=header->impl()){
+      impl_type::relink(carry.next(),header->next());
+      std::size_t i=0;
+      while(i<fill&&counter[i].next()!=static_cast<impl_pointer>(&counter[i])){
+        sequenced_index_collate<Node>(&carry,&counter[i++],comp);
+      }
+      impl_type::swap(
+        static_cast<impl_pointer>(&carry),
+        static_cast<impl_pointer>(&counter[i]));
+      if(i==fill){
+        ++fill;
+        counter[fill].prior()=counter[fill].next()=
+          static_cast<impl_pointer>(&counter[fill]);
+      }
+    }
+
+    for(std::size_t i=1;i<fill;++i){
+      sequenced_index_collate<Node>(&counter[i],&counter[i-1],comp);
+    }
+    impl_type::swap(
+      header->impl(),static_cast<impl_pointer>(&counter[fill-1]));
+  }
+  BOOST_CATCH(...)
+  {
+    impl_type::relink(
+      header->impl(),carry.next(),static_cast<impl_pointer>(&carry));
+    for(std::size_t i=0;i<=fill;++i){
+      impl_type::relink(
+        header->impl(),counter[i].next(),
+        static_cast<impl_pointer>(&counter[i]));
+    }
+    BOOST_RETHROW;
+  }
+  BOOST_CATCH_END
+}
+
+#include <boost/multi_index/detail/restore_wstrict_aliasing.hpp>
+
+} /* namespace multi_index::detail */
+
+} /* namespace multi_index */
+
+} /* namespace boost */
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/serialization_version.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/serialization_version.hpp
new file mode 100644
index 00000000000..ccd8bb4f791
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/serialization_version.hpp
@@ -0,0 +1,73 @@
+/* Copyright 2003-2013 Joaquin M Lopez Munoz.
+ * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
+ */
+
+#ifndef BOOST_MULTI_INDEX_DETAIL_SERIALIZATION_VERSION_HPP
+#define BOOST_MULTI_INDEX_DETAIL_SERIALIZATION_VERSION_HPP
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
+#include <boost/serialization/split_member.hpp>
+#include <boost/serialization/version.hpp>
+
+namespace boost{
+
+namespace multi_index{
+
+namespace detail{
+
+/* Helper class for storing and retrieving a given type serialization class
+ * version while avoiding saving the number multiple times in the same
+ * archive.
+ * Behavior undefined if template partial specialization is not supported.
+ */
+
+template<typename T>
+struct serialization_version
+{
+  serialization_version():
+    value(boost::serialization::version<serialization_version>::value){}
+
+  serialization_version& operator=(unsigned int x){value=x;return *this;};
+
+  operator unsigned int()const{return value;}
+
+private:
+  friend class boost::serialization::access;
+
+  BOOST_SERIALIZATION_SPLIT_MEMBER()
+
+  template<class Archive>
+  void save(Archive&,const unsigned int)const{}
+
+  template<class Archive>
+  void load(Archive&,const unsigned int version)
+  {
+    this->value=version;
+  }
+
+  unsigned int value;
+};
+
+} /* namespace multi_index::detail */
+
+} /* namespace multi_index */
+
+namespace serialization {
+template<typename T>
+struct version<boost::multi_index::detail::serialization_version<T> >
+{
+  BOOST_STATIC_CONSTANT(int,value=version<T>::value);
+};
+} /* namespace serialization */
+
+} /* namespace boost */
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/uintptr_type.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/uintptr_type.hpp
new file mode 100644
index 00000000000..9c92d01d4de
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/uintptr_type.hpp
@@ -0,0 +1,76 @@
+/* Copyright 2003-2013 Joaquin M Lopez Munoz.
+ * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
+ */
+
+#ifndef BOOST_MULTI_INDEX_DETAIL_UINTPTR_TYPE_HPP
+#define BOOST_MULTI_INDEX_DETAIL_UINTPTR_TYPE_HPP
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
+#include <boost/mpl/bool.hpp>
+
+namespace boost{
+
+namespace multi_index{
+
+namespace detail{
+
+/* has_uintptr_type is an MPL integral constant determining whether
+ * there exists an unsigned integral type with the same size as
+ * void *.
+ * uintptr_type is such a type if has_uintptr is true, or unsigned int
+ * otherwise.
+ * Note that uintptr_type is more restrictive than C99 uintptr_t,
+ * where an integral type with size greater than that of void *
+ * would be conformant.
+ */
+
+template<int N>struct uintptr_candidates;
+template<>struct uintptr_candidates<-1>{typedef unsigned int           type;};
+template<>struct uintptr_candidates<0> {typedef unsigned int           type;};
+template<>struct uintptr_candidates<1> {typedef unsigned short         type;};
+template<>struct uintptr_candidates<2> {typedef unsigned long          type;};
+
+#if defined(BOOST_HAS_LONG_LONG)
+template<>struct uintptr_candidates<3> {typedef boost::ulong_long_type type;};
+#else
+template<>struct uintptr_candidates<3> {typedef unsigned int           type;};
+#endif
+
+#if defined(BOOST_HAS_MS_INT64)
+template<>struct uintptr_candidates<4> {typedef unsigned __int64       type;};
+#else
+template<>struct uintptr_candidates<4> {typedef unsigned int           type;};
+#endif
+
+struct uintptr_aux
+{
+  BOOST_STATIC_CONSTANT(int,index=
+    sizeof(void*)==sizeof(uintptr_candidates<0>::type)?0:
+    sizeof(void*)==sizeof(uintptr_candidates<1>::type)?1:
+    sizeof(void*)==sizeof(uintptr_candidates<2>::type)?2:
+    sizeof(void*)==sizeof(uintptr_candidates<3>::type)?3:
+    sizeof(void*)==sizeof(uintptr_candidates<4>::type)?4:-1);
+
+  BOOST_STATIC_CONSTANT(bool,has_uintptr_type=(index>=0));
+
+  typedef uintptr_candidates<index>::type type;
+};
+
+typedef mpl::bool_<uintptr_aux::has_uintptr_type> has_uintptr_type;
+typedef uintptr_aux::type                         uintptr_type;
+
+} /* namespace multi_index::detail */
+
+} /* namespace multi_index */
+
+} /* namespace boost */
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/unbounded.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/unbounded.hpp
new file mode 100644
index 00000000000..dc09be1770d
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/unbounded.hpp
@@ -0,0 +1,66 @@
+/* Copyright 2003-2013 Joaquin M Lopez Munoz.
+ * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
+ */
+
+#ifndef BOOST_MULTI_INDEX_DETAIL_UNBOUNDED_HPP
+#define BOOST_MULTI_INDEX_DETAIL_UNBOUNDED_HPP
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
+#include <boost/detail/workaround.hpp>
+
+namespace boost{
+
+namespace multi_index{
+
+/* dummy type and variable for use in ordered_index::range() */
+
+/* ODR-abiding technique shown at the example attached to
+ * http://lists.boost.org/Archives/boost/2006/07/108355.php
+ */
+
+namespace detail{class unbounded_helper;}
+
+detail::unbounded_helper unbounded(detail::unbounded_helper);
+
+namespace detail{
+
+class unbounded_helper
+{
+  unbounded_helper(){}
+  unbounded_helper(const unbounded_helper&){}
+  friend unbounded_helper multi_index::unbounded(unbounded_helper);
+};
+
+typedef unbounded_helper (*unbounded_type)(unbounded_helper);
+
+} /* namespace multi_index::detail */
+
+inline detail::unbounded_helper unbounded(detail::unbounded_helper)
+{
+  return detail::unbounded_helper();
+}
+
+/* tags used in the implementation of range */
+
+namespace detail{
+
+struct none_unbounded_tag{};
+struct lower_unbounded_tag{};
+struct upper_unbounded_tag{};
+struct both_unbounded_tag{};
+
+} /* namespace multi_index::detail */
+
+} /* namespace multi_index */
+
+} /* namespace boost */
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/value_compare.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/value_compare.hpp
new file mode 100644
index 00000000000..ac42e8779aa
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/value_compare.hpp
@@ -0,0 +1,56 @@
+/* Copyright 2003-2015 Joaquin M Lopez Munoz.
+ * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
+ */
+
+#ifndef BOOST_MULTI_INDEX_DETAIL_VALUE_COMPARE_HPP
+#define BOOST_MULTI_INDEX_DETAIL_VALUE_COMPARE_HPP
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
+#include <boost/call_traits.hpp>
+
+namespace boost{
+
+namespace multi_index{
+
+namespace detail{
+
+template<typename Value,typename KeyFromValue,typename Compare>
+struct value_comparison
+{
+  typedef Value first_argument_type;
+  typedef Value second_argument_type;
+  typedef bool  result_type;
+
+  value_comparison(
+    const KeyFromValue& key_=KeyFromValue(),const Compare& comp_=Compare()):
+    key(key_),comp(comp_)
+  {
+  }
+
+  bool operator()(
+    typename call_traits<Value>::param_type x,
+    typename call_traits<Value>::param_type y)const
+  {
+    return comp(key(x),key(y));
+  }
+
+private:
+  KeyFromValue key;
+  Compare      comp;
+};
+
+} /* namespace multi_index::detail */
+
+} /* namespace multi_index */
+
+} /* namespace boost */
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/vartempl_support.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/vartempl_support.hpp
new file mode 100644
index 00000000000..06ff430f4be
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/vartempl_support.hpp
@@ -0,0 +1,247 @@
+/* Copyright 2003-2013 Joaquin M Lopez Munoz.
+ * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
+ */
+
+#ifndef BOOST_MULTI_INDEX_DETAIL_VARTEMPL_SUPPORT_HPP
+#define BOOST_MULTI_INDEX_DETAIL_VARTEMPL_SUPPORT_HPP
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+/* Utilities for emulation of variadic template functions. Variadic packs are
+ * replaced by lists of BOOST_MULTI_INDEX_LIMIT_VARTEMPL_ARGS parameters:
+ *
+ *   - typename... Args            --> BOOST_MULTI_INDEX_TEMPLATE_PARAM_PACK
+ *   - Args&&... args              --> BOOST_MULTI_INDEX_FUNCTION_PARAM_PACK
+ *   - std::forward<Args>(args)... --> BOOST_MULTI_INDEX_FORWARD_PARAM_PACK
+ *
+ * Forwarding emulated with Boost.Move. A template functions foo_imp
+ * defined in such way accepts *exactly* BOOST_MULTI_INDEX_LIMIT_VARTEMPL_ARGS
+ * arguments: variable number of arguments is emulated by providing a set of
+ * overloads foo forwarding to foo_impl with
+ * 
+ *   BOOST_MULTI_INDEX_OVERLOADS_TO_VARTEMPL
+ *   BOOST_MULTI_INDEX_OVERLOADS_TO_VARTEMPL_EXTRA_ARG (initial extra arg)
+ *
+ * which fill the extra args with boost::multi_index::detail::noarg's.
+ * boost::multi_index::detail::vartempl_placement_new works the opposite
+ * way: it acceps a full a pointer x to Value and a
+ * BOOST_MULTI_INDEX_FUNCTION_PARAM_PACK and forwards to
+ * new(x) Value(args) where args is the argument pack after discarding
+ * noarg's.
+ *
+ * Emulation decays to the real thing when the compiler supports variadic
+ * templates and move semantics natively.
+ */
+
+#include <boost/config.hpp>
+
+#if defined(BOOST_NO_CXX11_RVALUE_REFERENCES)||\
+    defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+
+#include <boost/move/core.hpp>
+#include <boost/move/utility.hpp>
+#include <boost/preprocessor/arithmetic/add.hpp>
+#include <boost/preprocessor/arithmetic/sub.hpp>
+#include <boost/preprocessor/cat.hpp>
+#include <boost/preprocessor/control/if.hpp>
+#include <boost/preprocessor/facilities/empty.hpp>
+#include <boost/preprocessor/facilities/intercept.hpp>
+#include <boost/preprocessor/logical/and.hpp>
+#include <boost/preprocessor/punctuation/comma.hpp>
+#include <boost/preprocessor/punctuation/comma_if.hpp>
+#include <boost/preprocessor/repetition/enum.hpp>
+#include <boost/preprocessor/repetition/enum_params.hpp>
+#include <boost/preprocessor/repetition/repeat_from_to.hpp>
+#include <boost/preprocessor/seq/elem.hpp>
+
+#if !defined(BOOST_MULTI_INDEX_LIMIT_VARTEMPL_ARGS)
+#define BOOST_MULTI_INDEX_LIMIT_VARTEMPL_ARGS 5
+#endif
+
+#define BOOST_MULTI_INDEX_TEMPLATE_PARAM_PACK                        \
+BOOST_PP_ENUM_PARAMS(                                                \
+  BOOST_MULTI_INDEX_LIMIT_VARTEMPL_ARGS,typename T)
+
+#define BOOST_MULTI_INDEX_VARTEMPL_ARG(z,n,_)                        \
+BOOST_FWD_REF(BOOST_PP_CAT(T,n)) BOOST_PP_CAT(t,n)
+
+#define BOOST_MULTI_INDEX_FUNCTION_PARAM_PACK                        \
+BOOST_PP_ENUM(                                                       \
+  BOOST_MULTI_INDEX_LIMIT_VARTEMPL_ARGS,                             \
+  BOOST_MULTI_INDEX_VARTEMPL_ARG,~)
+
+#define BOOST_MULTI_INDEX_VARTEMPL_FORWARD_ARG(z,n,_)                \
+boost::forward<BOOST_PP_CAT(T,n)>(BOOST_PP_CAT(t,n))
+
+#define BOOST_MULTI_INDEX_FORWARD_PARAM_PACK                         \
+BOOST_PP_ENUM(                                                       \
+  BOOST_MULTI_INDEX_LIMIT_VARTEMPL_ARGS,                             \
+  BOOST_MULTI_INDEX_VARTEMPL_FORWARD_ARG,~)
+
+namespace boost{namespace multi_index{namespace detail{
+struct noarg{};
+}}}
+
+/* call vartempl function without args */
+
+#define BOOST_MULTI_INDEX_NULL_PARAM_PACK                            \
+BOOST_PP_ENUM_PARAMS(                                                \
+  BOOST_MULTI_INDEX_LIMIT_VARTEMPL_ARGS,                             \
+  boost::multi_index::detail::noarg() BOOST_PP_INTERCEPT)
+
+#define BOOST_MULTI_INDEX_TEMPLATE_N(n)                              \
+template<BOOST_PP_ENUM_PARAMS(n,typename T)>
+
+#define BOOST_MULTI_INDEX_TEMPLATE_0(n)
+
+#define BOOST_MULTI_INDEX_OVERLOADS_TO_VARTEMPL_AUX(z,n,data)        \
+BOOST_PP_IF(n,                                                       \
+  BOOST_MULTI_INDEX_TEMPLATE_N,                                      \
+  BOOST_MULTI_INDEX_TEMPLATE_0)(n)                                   \
+BOOST_PP_SEQ_ELEM(0,data) /* ret */                                  \
+BOOST_PP_SEQ_ELEM(1,data) /* name_from */ (                          \
+  BOOST_PP_ENUM(n,BOOST_MULTI_INDEX_VARTEMPL_ARG,~))                 \
+{                                                                    \
+  return BOOST_PP_SEQ_ELEM(2,data) /* name_to */ (                   \
+    BOOST_PP_ENUM(n,BOOST_MULTI_INDEX_VARTEMPL_FORWARD_ARG,~)        \
+    BOOST_PP_COMMA_IF(                                               \
+      BOOST_PP_AND(                                                  \
+        n,BOOST_PP_SUB(BOOST_MULTI_INDEX_LIMIT_VARTEMPL_ARGS,n)))    \
+    BOOST_PP_ENUM_PARAMS(                                            \
+      BOOST_PP_SUB(BOOST_MULTI_INDEX_LIMIT_VARTEMPL_ARGS,n),         \
+      boost::multi_index::detail::noarg() BOOST_PP_INTERCEPT)        \
+  );                                                                 \
+}
+
+#define BOOST_MULTI_INDEX_OVERLOADS_TO_VARTEMPL(                     \
+  ret,name_from,name_to)                                             \
+BOOST_PP_REPEAT_FROM_TO(                                             \
+  0,BOOST_PP_ADD(BOOST_MULTI_INDEX_LIMIT_VARTEMPL_ARGS,1),           \
+  BOOST_MULTI_INDEX_OVERLOADS_TO_VARTEMPL_AUX,                       \
+  (ret)(name_from)(name_to))
+
+#define BOOST_MULTI_INDEX_OVERLOADS_TO_VARTEMPL_EXTRA_ARG_AUX(       \
+  z,n,data)                                                          \
+BOOST_PP_IF(n,                                                       \
+  BOOST_MULTI_INDEX_TEMPLATE_N,                                      \
+  BOOST_MULTI_INDEX_TEMPLATE_0)(n)                                   \
+BOOST_PP_SEQ_ELEM(0,data) /* ret */                                  \
+BOOST_PP_SEQ_ELEM(1,data) /* name_from */ (                          \
+  BOOST_PP_SEQ_ELEM(3,data) BOOST_PP_SEQ_ELEM(4,data) /* extra arg */\
+  BOOST_PP_COMMA_IF(n)                                               \
+  BOOST_PP_ENUM(n,BOOST_MULTI_INDEX_VARTEMPL_ARG,~))                 \
+{                                                                    \
+  return BOOST_PP_SEQ_ELEM(2,data) /* name_to */ (                   \
+    BOOST_PP_SEQ_ELEM(4,data) /* extra_arg_name */                   \
+    BOOST_PP_COMMA_IF(n)                                             \
+    BOOST_PP_ENUM(n,BOOST_MULTI_INDEX_VARTEMPL_FORWARD_ARG,~)        \
+    BOOST_PP_COMMA_IF(                                               \
+      BOOST_PP_SUB(BOOST_MULTI_INDEX_LIMIT_VARTEMPL_ARGS,n))         \
+    BOOST_PP_ENUM_PARAMS(                                            \
+      BOOST_PP_SUB(BOOST_MULTI_INDEX_LIMIT_VARTEMPL_ARGS,n),         \
+      boost::multi_index::detail::noarg() BOOST_PP_INTERCEPT)        \
+  );                                                                 \
+}
+
+#define BOOST_MULTI_INDEX_OVERLOADS_TO_VARTEMPL_EXTRA_ARG(           \
+  ret,name_from,name_to,extra_arg_type,extra_arg_name)               \
+BOOST_PP_REPEAT_FROM_TO(                                             \
+  0,BOOST_PP_ADD(BOOST_MULTI_INDEX_LIMIT_VARTEMPL_ARGS,1),           \
+  BOOST_MULTI_INDEX_OVERLOADS_TO_VARTEMPL_EXTRA_ARG_AUX,             \
+  (ret)(name_from)(name_to)(extra_arg_type)(extra_arg_name))
+
+namespace boost{
+  
+namespace multi_index{
+  
+namespace detail{
+
+#define BOOST_MULTI_INDEX_VARTEMPL_TO_PLACEMENT_NEW_AUX(z,n,name)    \
+template<                                                            \
+  typename Value                                                     \
+  BOOST_PP_COMMA_IF(n)                                               \
+  BOOST_PP_ENUM_PARAMS(n,typename T)                                 \
+>                                                                    \
+Value* name(                                                         \
+  Value* x                                                           \
+  BOOST_PP_COMMA_IF(n)                                               \
+  BOOST_PP_ENUM(n,BOOST_MULTI_INDEX_VARTEMPL_ARG,~)                  \
+  BOOST_PP_COMMA_IF(                                                 \
+    BOOST_PP_SUB(BOOST_MULTI_INDEX_LIMIT_VARTEMPL_ARGS,n))           \
+  BOOST_PP_ENUM_PARAMS(                                              \
+    BOOST_PP_SUB(BOOST_MULTI_INDEX_LIMIT_VARTEMPL_ARGS,n),           \
+    BOOST_FWD_REF(noarg) BOOST_PP_INTERCEPT))                        \
+{                                                                    \
+  return new(x) Value(                                               \
+    BOOST_PP_ENUM(n,BOOST_MULTI_INDEX_VARTEMPL_FORWARD_ARG,~));      \
+}
+
+#define BOOST_MULTI_INDEX_VARTEMPL_TO_PLACEMENT_NEW(name)            \
+BOOST_PP_REPEAT_FROM_TO(                                             \
+  0,BOOST_PP_ADD(BOOST_MULTI_INDEX_LIMIT_VARTEMPL_ARGS,1),           \
+  BOOST_MULTI_INDEX_VARTEMPL_TO_PLACEMENT_NEW_AUX,                   \
+  name)
+
+BOOST_MULTI_INDEX_VARTEMPL_TO_PLACEMENT_NEW(vartempl_placement_new)
+
+#undef BOOST_MULTI_INDEX_VARTEMPL_TO_PLACEMENT_NEW_AUX
+#undef BOOST_MULTI_INDEX_VARTEMPL_TO_PLACEMENT_NEW
+
+} /* namespace multi_index::detail */
+
+} /* namespace multi_index */
+
+} /* namespace boost */
+
+#else
+
+/* native variadic templates support */
+
+#include <utility>
+
+#define BOOST_MULTI_INDEX_TEMPLATE_PARAM_PACK typename... Args
+#define BOOST_MULTI_INDEX_FUNCTION_PARAM_PACK Args&&... args
+#define BOOST_MULTI_INDEX_FORWARD_PARAM_PACK  std::forward<Args>(args)...
+#define BOOST_MULTI_INDEX_NULL_PARAM_PACK
+
+#define BOOST_MULTI_INDEX_OVERLOADS_TO_VARTEMPL(                     \
+  ret,name_from,name_to)                                             \
+template<typename... Args> ret name_from(Args&&... args)             \
+{                                                                    \
+  return name_to(std::forward<Args>(args)...);                       \
+}
+
+#define BOOST_MULTI_INDEX_OVERLOADS_TO_VARTEMPL_EXTRA_ARG(           \
+  ret,name_from,name_to,extra_arg_type,extra_arg_name)               \
+template<typename... Args> ret name_from(                            \
+  extra_arg_type extra_arg_name,Args&&... args)                      \
+{                                                                    \
+  return name_to(extra_arg_name,std::forward<Args>(args)...);        \
+}
+
+namespace boost{
+  
+namespace multi_index{
+  
+namespace detail{
+
+template<typename Value,typename... Args>
+Value* vartempl_placement_new(Value*x,Args&&... args)
+{
+  return new(x) Value(std::forward<Args>(args)...);
+}
+
+} /* namespace multi_index::detail */
+
+} /* namespace multi_index */
+
+} /* namespace boost */
+
+#endif
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/global_fun.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/global_fun.hpp
new file mode 100644
index 00000000000..2c13769100c
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/multi_index/global_fun.hpp
@@ -0,0 +1,185 @@
+/* Copyright 2003-2015 Joaquin M Lopez Munoz.
+ * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
+ */
+
+#ifndef BOOST_MULTI_INDEX_GLOBAL_FUN_HPP
+#define BOOST_MULTI_INDEX_GLOBAL_FUN_HPP
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
+#include <boost/detail/workaround.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/type_traits/is_const.hpp>
+#include <boost/type_traits/is_reference.hpp>
+#include <boost/type_traits/remove_const.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+#include <boost/utility/enable_if.hpp>
+
+#if !defined(BOOST_NO_SFINAE)
+#include <boost/type_traits/is_convertible.hpp>
+#endif
+
+namespace boost{
+
+template<class T> class reference_wrapper; /* fwd decl. */
+
+namespace multi_index{
+
+namespace detail{
+
+/* global_fun is a read-only key extractor from Value based on a given global
+ * (or static member) function with signature:
+ *
+ *   Type f([const] Value [&]);
+ *
+ * Additionally, global_fun  and const_global_fun are overloaded to support
+ * referece_wrappers of Value and "chained pointers" to Value's. By chained
+ * pointer to T we  mean a type P such that, given a p of Type P
+ *   *...n...*x is convertible to T&, for some n>=1.
+ * Examples of chained pointers are raw and smart pointers, iterators and
+ * arbitrary combinations of these (vg. T** or unique_ptr<T*>.)
+ */
+
+template<class Value,typename Type,Type (*PtrToFunction)(Value)>
+struct const_ref_global_fun_base
+{
+  typedef typename remove_reference<Type>::type result_type;
+
+  template<typename ChainedPtr>
+
+#if !defined(BOOST_NO_SFINAE)
+  typename disable_if<
+    is_convertible<const ChainedPtr&,Value>,Type>::type
+#else
+  Type
+#endif
+
+  operator()(const ChainedPtr& x)const
+  {
+    return operator()(*x);
+  }
+
+  Type operator()(Value x)const
+  {
+    return PtrToFunction(x);
+  }
+
+  Type operator()(
+    const reference_wrapper<
+      typename remove_reference<Value>::type>& x)const
+  { 
+    return operator()(x.get());
+  }
+
+  Type operator()(
+    const reference_wrapper<
+      typename remove_const<
+        typename remove_reference<Value>::type>::type>& x
+
+#if BOOST_WORKAROUND(BOOST_MSVC,==1310)
+/* http://lists.boost.org/Archives/boost/2015/10/226135.php */
+    ,int=0
+#endif
+
+  )const
+  { 
+    return operator()(x.get());
+  }
+};
+
+template<class Value,typename Type,Type (*PtrToFunction)(Value)>
+struct non_const_ref_global_fun_base
+{
+  typedef typename remove_reference<Type>::type result_type;
+
+  template<typename ChainedPtr>
+
+#if !defined(BOOST_NO_SFINAE)
+  typename disable_if<
+    is_convertible<ChainedPtr&,Value>,Type>::type
+#else
+  Type
+#endif
+
+  operator()(const ChainedPtr& x)const
+  {
+    return operator()(*x);
+  }
+
+  Type operator()(Value x)const
+  {
+    return PtrToFunction(x);
+  }
+
+  Type operator()(
+    const reference_wrapper<
+      typename remove_reference<Value>::type>& x)const
+  { 
+    return operator()(x.get());
+  }
+};
+
+template<class Value,typename Type,Type (*PtrToFunction)(Value)>
+struct non_ref_global_fun_base
+{
+  typedef typename remove_reference<Type>::type result_type;
+
+  template<typename ChainedPtr>
+
+#if !defined(BOOST_NO_SFINAE)
+  typename disable_if<
+    is_convertible<const ChainedPtr&,const Value&>,Type>::type
+#else
+  Type
+#endif
+
+  operator()(const ChainedPtr& x)const
+  {
+    return operator()(*x);
+  }
+
+  Type operator()(const Value& x)const
+  {
+    return PtrToFunction(x);
+  }
+
+  Type operator()(const reference_wrapper<const Value>& x)const
+  { 
+    return operator()(x.get());
+  }
+
+  Type operator()(
+    const reference_wrapper<typename remove_const<Value>::type>& x)const
+  { 
+    return operator()(x.get());
+  }
+};
+
+} /* namespace multi_index::detail */
+
+template<class Value,typename Type,Type (*PtrToFunction)(Value)>
+struct global_fun:
+  mpl::if_c<
+    is_reference<Value>::value,
+    typename mpl::if_c<
+      is_const<typename remove_reference<Value>::type>::value,
+      detail::const_ref_global_fun_base<Value,Type,PtrToFunction>,
+      detail::non_const_ref_global_fun_base<Value,Type,PtrToFunction>
+    >::type,
+    detail::non_ref_global_fun_base<Value,Type,PtrToFunction>
+  >::type
+{
+};
+
+} /* namespace multi_index */
+
+} /* namespace boost */
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/hashed_index.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/hashed_index.hpp
new file mode 100644
index 00000000000..352d0c13f17
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/multi_index/hashed_index.hpp
@@ -0,0 +1,1725 @@
+/* Copyright 2003-2015 Joaquin M Lopez Munoz.
+ * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
+ */
+
+#ifndef BOOST_MULTI_INDEX_HASHED_INDEX_HPP
+#define BOOST_MULTI_INDEX_HASHED_INDEX_HPP
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
+#include <algorithm>
+#include <boost/call_traits.hpp>
+#include <boost/detail/allocator_utilities.hpp>
+#include <boost/detail/no_exceptions_support.hpp>
+#include <boost/detail/workaround.hpp>
+#include <boost/foreach_fwd.hpp>
+#include <boost/limits.hpp>
+#include <boost/move/core.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/mpl/push_front.hpp>
+#include <boost/multi_index/detail/access_specifier.hpp>
+#include <boost/multi_index/detail/auto_space.hpp>
+#include <boost/multi_index/detail/bucket_array.hpp>
+#include <boost/multi_index/detail/do_not_copy_elements_tag.hpp>
+#include <boost/multi_index/detail/hash_index_iterator.hpp>
+#include <boost/multi_index/detail/index_node_base.hpp>
+#include <boost/multi_index/detail/modify_key_adaptor.hpp>
+#include <boost/multi_index/detail/promotes_arg.hpp>
+#include <boost/multi_index/detail/safe_mode.hpp>
+#include <boost/multi_index/detail/scope_guard.hpp>
+#include <boost/multi_index/detail/vartempl_support.hpp>
+#include <boost/multi_index/hashed_index_fwd.hpp>
+#include <boost/tuple/tuple.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <cmath>
+#include <cstddef>
+#include <functional>
+#include <iterator>
+#include <utility>
+
+#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
+#include <initializer_list>
+#endif
+
+#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
+#include <boost/serialization/nvp.hpp>
+#endif
+
+#if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING)
+#define BOOST_MULTI_INDEX_HASHED_INDEX_CHECK_INVARIANT_OF(x)                 \
+  detail::scope_guard BOOST_JOIN(check_invariant_,__LINE__)=                 \
+    detail::make_obj_guard(x,&hashed_index::check_invariant_);               \
+  BOOST_JOIN(check_invariant_,__LINE__).touch();
+#define BOOST_MULTI_INDEX_HASHED_INDEX_CHECK_INVARIANT                       \
+  BOOST_MULTI_INDEX_HASHED_INDEX_CHECK_INVARIANT_OF(*this)
+#else
+#define BOOST_MULTI_INDEX_HASHED_INDEX_CHECK_INVARIANT_OF(x)
+#define BOOST_MULTI_INDEX_HASHED_INDEX_CHECK_INVARIANT
+#endif
+
+namespace boost{
+
+namespace multi_index{
+
+namespace detail{
+
+/* hashed_index adds a layer of hashed indexing to a given Super */
+
+/* Most of the implementation of unique and non-unique indices is
+ * shared. We tell from one another on instantiation time by using
+ * Category tags defined in hash_index_node.hpp.
+ */
+
+template<
+  typename KeyFromValue,typename Hash,typename Pred,
+  typename SuperMeta,typename TagList,typename Category
+>
+class hashed_index:
+  BOOST_MULTI_INDEX_PROTECTED_IF_MEMBER_TEMPLATE_FRIENDS SuperMeta::type
+
+#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
+  ,public safe_mode::safe_container<
+    hashed_index<KeyFromValue,Hash,Pred,SuperMeta,TagList,Category> >
+#endif
+
+{ 
+#if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING)&&\
+    BOOST_WORKAROUND(__MWERKS__,<=0x3003)
+/* The "ISO C++ Template Parser" option in CW8.3 has a problem with the
+ * lifetime of const references bound to temporaries --precisely what
+ * scopeguards are.
+ */
+
+#pragma parse_mfunc_templ off
+#endif
+
+  typedef typename SuperMeta::type                   super;
+
+protected:
+  typedef hashed_index_node<
+    typename super::node_type,Category>              node_type;
+
+private:
+  typedef typename node_type::node_alg               node_alg;
+  typedef typename node_type::impl_type              node_impl_type;
+  typedef typename node_impl_type::pointer           node_impl_pointer;
+  typedef typename node_impl_type::base_pointer      node_impl_base_pointer;
+  typedef bucket_array<
+    typename super::final_allocator_type>            bucket_array_type;
+
+public:
+  /* types */
+
+  typedef typename KeyFromValue::result_type         key_type;
+  typedef typename node_type::value_type             value_type;
+  typedef KeyFromValue                               key_from_value;
+  typedef Hash                                       hasher;
+  typedef Pred                                       key_equal;
+  typedef tuple<std::size_t,
+    key_from_value,hasher,key_equal>                 ctor_args;
+  typedef typename super::final_allocator_type       allocator_type;
+  typedef typename allocator_type::pointer           pointer;
+  typedef typename allocator_type::const_pointer     const_pointer;
+  typedef typename allocator_type::reference         reference;
+  typedef typename allocator_type::const_reference   const_reference;
+  typedef std::size_t                                size_type;      
+  typedef std::ptrdiff_t                             difference_type;
+
+#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
+  typedef safe_mode::safe_iterator<
+    hashed_index_iterator<
+      node_type,bucket_array_type,
+      hashed_index_global_iterator_tag>,
+    hashed_index>                                    iterator;
+#else
+  typedef hashed_index_iterator<
+    node_type,bucket_array_type,
+    hashed_index_global_iterator_tag>                iterator;
+#endif
+
+  typedef iterator                                   const_iterator;
+
+  typedef hashed_index_iterator<
+    node_type,bucket_array_type,
+    hashed_index_local_iterator_tag>                 local_iterator;
+  typedef local_iterator                             const_local_iterator;
+
+  typedef TagList                                    tag_list;
+
+protected:
+  typedef typename super::final_node_type     final_node_type;
+  typedef tuples::cons<
+    ctor_args, 
+    typename super::ctor_args_list>           ctor_args_list;
+  typedef typename mpl::push_front<
+    typename super::index_type_list,
+    hashed_index>::type                       index_type_list;
+  typedef typename mpl::push_front<
+    typename super::iterator_type_list,
+    iterator>::type                           iterator_type_list;
+  typedef typename mpl::push_front<
+    typename super::const_iterator_type_list,
+    const_iterator>::type                     const_iterator_type_list;
+  typedef typename super::copy_map_type       copy_map_type;
+
+#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
+  typedef typename super::index_saver_type    index_saver_type;
+  typedef typename super::index_loader_type   index_loader_type;
+#endif
+
+private:
+#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
+  typedef safe_mode::safe_container<
+    hashed_index>                             safe_super;
+#endif
+
+  typedef typename call_traits<value_type>::param_type value_param_type;
+  typedef typename call_traits<
+    key_type>::param_type                              key_param_type;
+
+  /* Needed to avoid commas in BOOST_MULTI_INDEX_OVERLOADS_TO_VARTEMPL
+   * expansion.
+   */
+
+  typedef std::pair<iterator,bool>                     emplace_return_type;
+
+public:
+
+  /* construct/destroy/copy
+   * Default and copy ctors are in the protected section as indices are
+   * not supposed to be created on their own. No range ctor either.
+   */
+
+  hashed_index<KeyFromValue,Hash,Pred,SuperMeta,TagList,Category>& operator=(
+    const hashed_index<KeyFromValue,Hash,Pred,SuperMeta,TagList,Category>& x)
+  {
+    this->final()=x.final();
+    return *this;
+  }
+
+#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
+  hashed_index<KeyFromValue,Hash,Pred,SuperMeta,TagList,Category>& operator=(
+    std::initializer_list<value_type> list)
+  {
+    this->final()=list;
+    return *this;
+  }
+#endif
+
+  allocator_type get_allocator()const BOOST_NOEXCEPT
+  {
+    return this->final().get_allocator();
+  }
+
+  /* size and capacity */
+
+  bool      empty()const BOOST_NOEXCEPT{return this->final_empty_();}
+  size_type size()const BOOST_NOEXCEPT{return this->final_size_();}
+  size_type max_size()const BOOST_NOEXCEPT{return this->final_max_size_();}
+
+  /* iterators */
+
+  iterator begin()BOOST_NOEXCEPT
+    {return make_iterator(node_type::from_impl(header()->next()->prior()));}
+  const_iterator begin()const BOOST_NOEXCEPT
+    {return make_iterator(node_type::from_impl(header()->next()->prior()));}
+  iterator       end()BOOST_NOEXCEPT{return make_iterator(header());}
+  const_iterator end()const BOOST_NOEXCEPT{return make_iterator(header());}
+  const_iterator cbegin()const BOOST_NOEXCEPT{return begin();}
+  const_iterator cend()const BOOST_NOEXCEPT{return end();}
+
+  iterator iterator_to(const value_type& x)
+  {
+    return make_iterator(node_from_value<node_type>(&x));
+  }
+
+  const_iterator iterator_to(const value_type& x)const
+  {
+    return make_iterator(node_from_value<node_type>(&x));
+  }
+
+  /* modifiers */
+
+  BOOST_MULTI_INDEX_OVERLOADS_TO_VARTEMPL(
+    emplace_return_type,emplace,emplace_impl)
+
+  BOOST_MULTI_INDEX_OVERLOADS_TO_VARTEMPL_EXTRA_ARG(
+    iterator,emplace_hint,emplace_hint_impl,iterator,position)
+
+  std::pair<iterator,bool> insert(const value_type& x)
+  {
+    BOOST_MULTI_INDEX_HASHED_INDEX_CHECK_INVARIANT;
+    std::pair<final_node_type*,bool> p=this->final_insert_(x);
+    return std::pair<iterator,bool>(make_iterator(p.first),p.second);
+  }
+
+  std::pair<iterator,bool> insert(BOOST_RV_REF(value_type) x)
+  {
+    BOOST_MULTI_INDEX_HASHED_INDEX_CHECK_INVARIANT;
+    std::pair<final_node_type*,bool> p=this->final_insert_rv_(x);
+    return std::pair<iterator,bool>(make_iterator(p.first),p.second);
+  }
+
+  iterator insert(iterator position,const value_type& x)
+  {
+    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
+    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
+    BOOST_MULTI_INDEX_HASHED_INDEX_CHECK_INVARIANT;
+    std::pair<final_node_type*,bool> p=this->final_insert_(
+      x,static_cast<final_node_type*>(position.get_node()));
+    return make_iterator(p.first);
+  }
+    
+  iterator insert(iterator position,BOOST_RV_REF(value_type) x)
+  {
+    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
+    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
+    BOOST_MULTI_INDEX_HASHED_INDEX_CHECK_INVARIANT;
+    std::pair<final_node_type*,bool> p=this->final_insert_rv_(
+      x,static_cast<final_node_type*>(position.get_node()));
+    return make_iterator(p.first);
+  }
+
+  template<typename InputIterator>
+  void insert(InputIterator first,InputIterator last)
+  {
+    BOOST_MULTI_INDEX_HASHED_INDEX_CHECK_INVARIANT;
+    for(;first!=last;++first)this->final_insert_ref_(*first);
+  }
+
+#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
+  void insert(std::initializer_list<value_type> list)
+  {
+    insert(list.begin(),list.end());
+  }
+#endif
+
+  iterator erase(iterator position)
+  {
+    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
+    BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(position);
+    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
+    BOOST_MULTI_INDEX_HASHED_INDEX_CHECK_INVARIANT;
+    this->final_erase_(static_cast<final_node_type*>(position++.get_node()));
+    return position;
+  }
+
+  size_type erase(key_param_type k)
+  {
+    BOOST_MULTI_INDEX_HASHED_INDEX_CHECK_INVARIANT;
+
+    std::size_t buc=buckets.position(hash_(k));
+    for(node_impl_pointer x=buckets.at(buc)->prior();
+        x!=node_impl_pointer(0);x=node_alg::next_to_inspect(x)){
+      if(eq_(k,key(node_type::from_impl(x)->value()))){
+        node_impl_pointer y=end_of_range(x);
+        size_type         s=0;
+        do{
+          node_impl_pointer z=node_alg::after(x);
+          this->final_erase_(
+            static_cast<final_node_type*>(node_type::from_impl(x)));
+          x=z;
+          ++s;
+        }while(x!=y);
+        return s;
+      }
+    }
+    return 0;
+  }
+
+  iterator erase(iterator first,iterator last)
+  {
+    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(first);
+    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(last);
+    BOOST_MULTI_INDEX_CHECK_IS_OWNER(first,*this);
+    BOOST_MULTI_INDEX_CHECK_IS_OWNER(last,*this);
+    BOOST_MULTI_INDEX_CHECK_VALID_RANGE(first,last);
+    BOOST_MULTI_INDEX_HASHED_INDEX_CHECK_INVARIANT;
+    while(first!=last){
+      first=erase(first);
+    }
+    return first;
+  }
+
+  bool replace(iterator position,const value_type& x)
+  {
+    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
+    BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(position);
+    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
+    BOOST_MULTI_INDEX_HASHED_INDEX_CHECK_INVARIANT;
+    return this->final_replace_(
+      x,static_cast<final_node_type*>(position.get_node()));
+  }
+
+  bool replace(iterator position,BOOST_RV_REF(value_type) x)
+  {
+    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
+    BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(position);
+    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
+    BOOST_MULTI_INDEX_HASHED_INDEX_CHECK_INVARIANT;
+    return this->final_replace_rv_(
+      x,static_cast<final_node_type*>(position.get_node()));
+  }
+
+  template<typename Modifier>
+  bool modify(iterator position,Modifier mod)
+  {
+    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
+    BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(position);
+    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
+    BOOST_MULTI_INDEX_HASHED_INDEX_CHECK_INVARIANT;
+
+#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
+    /* MSVC++ 6.0 optimizer on safe mode code chokes if this
+     * this is not added. Left it for all compilers as it does no
+     * harm.
+     */
+
+    position.detach();
+#endif
+
+    return this->final_modify_(
+      mod,static_cast<final_node_type*>(position.get_node()));
+  }
+
+  template<typename Modifier,typename Rollback>
+  bool modify(iterator position,Modifier mod,Rollback back_)
+  {
+    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
+    BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(position);
+    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
+    BOOST_MULTI_INDEX_HASHED_INDEX_CHECK_INVARIANT;
+
+#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
+    /* MSVC++ 6.0 optimizer on safe mode code chokes if this
+     * this is not added. Left it for all compilers as it does no
+     * harm.
+     */
+
+    position.detach();
+#endif
+
+    return this->final_modify_(
+      mod,back_,static_cast<final_node_type*>(position.get_node()));
+  }
+
+  template<typename Modifier>
+  bool modify_key(iterator position,Modifier mod)
+  {
+    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
+    BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(position);
+    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
+    BOOST_MULTI_INDEX_HASHED_INDEX_CHECK_INVARIANT;
+    return modify(
+      position,modify_key_adaptor<Modifier,value_type,KeyFromValue>(mod,key));
+  }
+
+  template<typename Modifier,typename Rollback>
+  bool modify_key(iterator position,Modifier mod,Rollback back_)
+  {
+    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
+    BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(position);
+    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
+    BOOST_MULTI_INDEX_HASHED_INDEX_CHECK_INVARIANT;
+    return modify(
+      position,
+      modify_key_adaptor<Modifier,value_type,KeyFromValue>(mod,key),
+      modify_key_adaptor<Rollback,value_type,KeyFromValue>(back_,key));
+  }
+
+  void clear()BOOST_NOEXCEPT
+  {
+    BOOST_MULTI_INDEX_HASHED_INDEX_CHECK_INVARIANT;
+    this->final_clear_();
+  }
+
+  void swap(hashed_index<KeyFromValue,Hash,Pred,SuperMeta,TagList,Category>& x)
+  {
+    BOOST_MULTI_INDEX_HASHED_INDEX_CHECK_INVARIANT;
+    BOOST_MULTI_INDEX_HASHED_INDEX_CHECK_INVARIANT_OF(x);
+    this->final_swap_(x.final());
+  }
+
+  /* observers */
+
+  key_from_value key_extractor()const{return key;}
+  hasher         hash_function()const{return hash_;}
+  key_equal      key_eq()const{return eq_;}
+  
+  /* lookup */
+
+  /* Internally, these ops rely on const_iterator being the same
+   * type as iterator.
+   */
+
+  /* Implementation note: When CompatibleKey is consistently promoted to
+   * KeyFromValue::result_type for equality comparison, the promotion is made
+   * once in advance to increase efficiency.
+   */
+
+  template<typename CompatibleKey>
+  iterator find(const CompatibleKey& k)const
+  {
+    return find(k,hash_,eq_);
+  }
+
+  template<
+    typename CompatibleKey,typename CompatibleHash,typename CompatiblePred
+  >
+  iterator find(
+    const CompatibleKey& k,
+    const CompatibleHash& hash,const CompatiblePred& eq)const
+  {
+    return find(
+      k,hash,eq,promotes_1st_arg<CompatiblePred,CompatibleKey,key_type>());
+  }
+
+  template<typename CompatibleKey>
+  size_type count(const CompatibleKey& k)const
+  {
+    return count(k,hash_,eq_);
+  }
+
+  template<
+    typename CompatibleKey,typename CompatibleHash,typename CompatiblePred
+  >
+  size_type count(
+    const CompatibleKey& k,
+    const CompatibleHash& hash,const CompatiblePred& eq)const
+  {
+    return count(
+      k,hash,eq,promotes_1st_arg<CompatiblePred,CompatibleKey,key_type>());
+  }
+
+  template<typename CompatibleKey>
+  std::pair<iterator,iterator> equal_range(const CompatibleKey& k)const
+  {
+    return equal_range(k,hash_,eq_);
+  }
+
+  template<
+    typename CompatibleKey,typename CompatibleHash,typename CompatiblePred
+  >
+  std::pair<iterator,iterator> equal_range(
+    const CompatibleKey& k,
+    const CompatibleHash& hash,const CompatiblePred& eq)const
+  {
+    return equal_range(
+      k,hash,eq,promotes_1st_arg<CompatiblePred,CompatibleKey,key_type>());
+  }
+
+  /* bucket interface */
+
+  size_type bucket_count()const BOOST_NOEXCEPT{return buckets.size();}
+  size_type max_bucket_count()const BOOST_NOEXCEPT{return static_cast<size_type>(-1);}
+
+  size_type bucket_size(size_type n)const
+  {
+    size_type res=0;
+    for(node_impl_pointer x=buckets.at(n)->prior();
+        x!=node_impl_pointer(0);x=node_alg::after_local(x)){
+      ++res;
+    }
+    return res;
+  }
+
+  size_type bucket(key_param_type k)const
+  {
+    return buckets.position(hash_(k));
+  }
+
+  local_iterator begin(size_type n)
+  {
+    return const_cast<const hashed_index*>(this)->begin(n);
+  }
+
+  const_local_iterator begin(size_type n)const
+  {
+    node_impl_pointer x=buckets.at(n)->prior();
+    if(x==node_impl_pointer(0))return end(n);
+    return make_local_iterator(node_type::from_impl(x));
+  }
+
+  local_iterator end(size_type n)
+  {
+    return const_cast<const hashed_index*>(this)->end(n);
+  }
+
+  const_local_iterator end(size_type)const
+  {
+    return make_local_iterator(0);
+  }
+
+  const_local_iterator cbegin(size_type n)const{return begin(n);}
+  const_local_iterator cend(size_type n)const{return end(n);}
+
+  local_iterator local_iterator_to(const value_type& x)
+  {
+    return make_local_iterator(node_from_value<node_type>(&x));
+  }
+
+  const_local_iterator local_iterator_to(const value_type& x)const
+  {
+    return make_local_iterator(node_from_value<node_type>(&x));
+  }
+
+  /* hash policy */
+
+  float load_factor()const BOOST_NOEXCEPT
+    {return static_cast<float>(size())/bucket_count();}
+  float max_load_factor()const BOOST_NOEXCEPT{return mlf;}
+  void  max_load_factor(float z){mlf=z;calculate_max_load();}
+
+  void rehash(size_type n)
+  {
+    BOOST_MULTI_INDEX_HASHED_INDEX_CHECK_INVARIANT;
+    if(size()<=max_load&&n<=bucket_count())return;
+
+    size_type bc =(std::numeric_limits<size_type>::max)();
+    float     fbc=static_cast<float>(1+size()/mlf);
+    if(bc>fbc){
+      bc=static_cast<size_type>(fbc);
+      if(bc<n)bc=n;
+    }
+    unchecked_rehash(bc);
+  }
+
+  void reserve(size_type n)
+  {
+    rehash(static_cast<size_type>(std::ceil(static_cast<double>(n)/mlf)));
+  }
+
+BOOST_MULTI_INDEX_PROTECTED_IF_MEMBER_TEMPLATE_FRIENDS:
+  hashed_index(const ctor_args_list& args_list,const allocator_type& al):
+    super(args_list.get_tail(),al),
+    key(tuples::get<1>(args_list.get_head())),
+    hash_(tuples::get<2>(args_list.get_head())),
+    eq_(tuples::get<3>(args_list.get_head())),
+    buckets(al,header()->impl(),tuples::get<0>(args_list.get_head())),
+    mlf(1.0f)
+  {
+    calculate_max_load();
+  }
+
+  hashed_index(
+    const hashed_index<KeyFromValue,Hash,Pred,SuperMeta,TagList,Category>& x):
+    super(x),
+
+#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
+    safe_super(),
+#endif
+
+    key(x.key),
+    hash_(x.hash_),
+    eq_(x.eq_),
+    buckets(x.get_allocator(),header()->impl(),x.buckets.size()),
+    mlf(x.mlf),
+    max_load(x.max_load)
+  {
+    /* Copy ctor just takes the internal configuration objects from x. The rest
+     * is done in subsequent call to copy_().
+     */
+  }
+
+  hashed_index(
+    const hashed_index<KeyFromValue,Hash,Pred,SuperMeta,TagList,Category>& x,
+    do_not_copy_elements_tag):
+    super(x,do_not_copy_elements_tag()),
+
+#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
+    safe_super(),
+#endif
+
+    key(x.key),
+    hash_(x.hash_),
+    eq_(x.eq_),
+    buckets(x.get_allocator(),header()->impl(),0),
+    mlf(1.0f)
+  {
+     calculate_max_load();
+  }
+
+  ~hashed_index()
+  {
+    /* the container is guaranteed to be empty by now */
+  }
+
+#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
+  iterator make_iterator(node_type* node)
+  {
+    return iterator(node,this);
+  }
+
+  const_iterator make_iterator(node_type* node)const
+  {
+    return const_iterator(node,const_cast<hashed_index*>(this));
+  }
+#else
+  iterator make_iterator(node_type* node)
+  {
+    return iterator(node);
+  }
+
+  const_iterator make_iterator(node_type* node)const
+  {
+    return const_iterator(node);
+  }
+#endif
+
+  local_iterator make_local_iterator(node_type* node)
+  {
+    return local_iterator(node);
+  }
+
+  const_local_iterator make_local_iterator(node_type* node)const
+  {
+    return const_local_iterator(node);
+  }
+
+  void copy_(
+    const hashed_index<KeyFromValue,Hash,Pred,SuperMeta,TagList,Category>& x,
+    const copy_map_type& map)
+  {
+    copy_(x,map,Category());
+  }
+
+  void copy_(
+    const hashed_index<KeyFromValue,Hash,Pred,SuperMeta,TagList,Category>& x,
+    const copy_map_type& map,hashed_unique_tag)
+  {
+    if(x.size()!=0){
+      node_impl_pointer end_org=x.header()->impl(),
+                        org=end_org,
+                        cpy=header()->impl();
+      do{
+        node_impl_pointer prev_org=org->prior(),
+                          prev_cpy=
+          static_cast<node_type*>(map.find(static_cast<final_node_type*>(
+            node_type::from_impl(prev_org))))->impl();
+        cpy->prior()=prev_cpy;
+        if(node_alg::is_first_of_bucket(org)){
+          node_impl_base_pointer buc_org=prev_org->next(),
+                                 buc_cpy=
+            buckets.begin()+(buc_org-x.buckets.begin());
+          prev_cpy->next()=buc_cpy;
+          buc_cpy->prior()=cpy;
+        }
+        else{
+          prev_cpy->next()=node_impl_type::base_pointer_from(cpy);
+        }
+        org=prev_org;
+        cpy=prev_cpy;
+      }while(org!=end_org);
+    }
+
+    super::copy_(x,map);
+  }
+  
+  void copy_(
+    const hashed_index<KeyFromValue,Hash,Pred,SuperMeta,TagList,Category>& x,
+    const copy_map_type& map,hashed_non_unique_tag)
+  {
+    if(x.size()!=0){
+      node_impl_pointer end_org=x.header()->impl(),
+                        org=end_org,
+                        cpy=header()->impl();
+      do{
+        node_impl_pointer next_org=node_alg::after(org),
+                          next_cpy=
+          static_cast<node_type*>(map.find(static_cast<final_node_type*>(
+            node_type::from_impl(next_org))))->impl();
+        if(node_alg::is_first_of_bucket(next_org)){
+          node_impl_base_pointer buc_org=org->next(),
+                                 buc_cpy=
+            buckets.begin()+(buc_org-x.buckets.begin());
+          cpy->next()=buc_cpy;
+          buc_cpy->prior()=next_cpy;
+          next_cpy->prior()=cpy;
+        }
+        else{
+          if(org->next()==node_impl_type::base_pointer_from(next_org)){
+            cpy->next()=node_impl_type::base_pointer_from(next_cpy);
+          }
+          else{
+            cpy->next()=
+              node_impl_type::base_pointer_from(
+                static_cast<node_type*>(map.find(static_cast<final_node_type*>(
+                  node_type::from_impl(
+                    node_impl_type::pointer_from(org->next())))))->impl());
+          }
+
+          if(next_org->prior()!=org){
+            next_cpy->prior()=
+              static_cast<node_type*>(map.find(static_cast<final_node_type*>(
+                node_type::from_impl(next_org->prior()))))->impl();
+          }
+          else{
+            next_cpy->prior()=cpy;
+          }
+        }
+        org=next_org;
+        cpy=next_cpy;
+      }while(org!=end_org);
+    }
+
+    super::copy_(x,map);
+  }
+
+  template<typename Variant>
+  final_node_type* insert_(
+    value_param_type v,final_node_type*& x,Variant variant)
+  {
+    reserve_for_insert(size()+1);
+
+    std::size_t buc=find_bucket(v);
+    link_info   pos(buckets.at(buc));
+    if(!link_point(v,pos)){
+      return static_cast<final_node_type*>(
+        node_type::from_impl(node_impl_type::pointer_from(pos)));
+    }
+
+    final_node_type* res=super::insert_(v,x,variant);
+    if(res==x)link(static_cast<node_type*>(x),pos);
+    return res;
+  }
+
+  template<typename Variant>
+  final_node_type* insert_(
+    value_param_type v,node_type* position,final_node_type*& x,Variant variant)
+  {
+    reserve_for_insert(size()+1);
+
+    std::size_t buc=find_bucket(v);
+    link_info   pos(buckets.at(buc));
+    if(!link_point(v,pos)){
+      return static_cast<final_node_type*>(
+        node_type::from_impl(node_impl_type::pointer_from(pos)));
+    }
+
+    final_node_type* res=super::insert_(v,position,x,variant);
+    if(res==x)link(static_cast<node_type*>(x),pos);
+    return res;
+  }
+
+  void erase_(node_type* x)
+  {
+    unlink(x);
+    super::erase_(x);
+
+#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
+    detach_iterators(x);
+#endif
+  }
+
+  void delete_all_nodes_()
+  {
+    delete_all_nodes_(Category());
+  }
+
+  void delete_all_nodes_(hashed_unique_tag)
+  {
+    for(node_impl_pointer x_end=header()->impl(),x=x_end->prior();x!=x_end;){
+      node_impl_pointer y=x->prior();
+      this->final_delete_node_(
+        static_cast<final_node_type*>(node_type::from_impl(x)));
+      x=y;
+    }
+  }
+
+  void delete_all_nodes_(hashed_non_unique_tag)
+  {
+    for(node_impl_pointer x_end=header()->impl(),x=x_end->prior();x!=x_end;){
+      node_impl_pointer y=x->prior();
+      if(y->next()!=node_impl_type::base_pointer_from(x)&&
+         y->next()->prior()!=x){ /* n-1 of group */
+        /* Make the second node prior() pointer back-linked so that it won't
+         * refer to a deleted node when the time for its own destruction comes.
+         */
+
+        node_impl_pointer first=node_impl_type::pointer_from(y->next());
+        first->next()->prior()=first;
+      }
+      this->final_delete_node_(
+        static_cast<final_node_type*>(node_type::from_impl(x)));
+      x=y;
+    }
+  }
+
+  void clear_()
+  {
+    super::clear_();
+    buckets.clear(header()->impl());
+
+#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
+    safe_super::detach_dereferenceable_iterators();
+#endif
+  }
+
+  void swap_(
+    hashed_index<KeyFromValue,Hash,Pred,SuperMeta,TagList,Category>& x)
+  {
+    std::swap(key,x.key);
+    std::swap(hash_,x.hash_);
+    std::swap(eq_,x.eq_);
+    buckets.swap(x.buckets);
+    std::swap(mlf,x.mlf);
+    std::swap(max_load,x.max_load);
+
+#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
+    safe_super::swap(x);
+#endif
+
+    super::swap_(x);
+  }
+
+  void swap_elements_(
+    hashed_index<KeyFromValue,Hash,Pred,SuperMeta,TagList,Category>& x)
+  {
+    buckets.swap(x.buckets);
+    std::swap(mlf,x.mlf);
+    std::swap(max_load,x.max_load);
+
+#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
+    safe_super::swap(x);
+#endif
+
+    super::swap_elements_(x);
+  }
+
+  template<typename Variant>
+  bool replace_(value_param_type v,node_type* x,Variant variant)
+  {
+    if(eq_(key(v),key(x->value()))){
+      return super::replace_(v,x,variant);
+    }
+      
+    unlink_undo undo;
+    unlink(x,undo);
+
+    BOOST_TRY{
+      std::size_t  buc=find_bucket(v);
+      link_info    pos(buckets.at(buc));
+      if(link_point(v,pos)&&super::replace_(v,x,variant)){
+        link(x,pos);
+        return true;
+      }
+      undo();
+      return false;
+    }
+    BOOST_CATCH(...){
+      undo();
+      BOOST_RETHROW;
+    }
+    BOOST_CATCH_END
+  }
+
+  bool modify_(node_type* x)
+  {
+    std::size_t buc;
+    bool        b; 
+    BOOST_TRY{
+      buc=find_bucket(x->value());
+      b=in_place(x->impl(),key(x->value()),buc);
+    }
+    BOOST_CATCH(...){
+      erase_(x);
+      BOOST_RETHROW;
+    }
+    BOOST_CATCH_END
+    if(!b){
+      unlink(x);
+      BOOST_TRY{
+        link_info pos(buckets.at(buc));
+        if(!link_point(x->value(),pos)){
+          super::erase_(x);
+
+#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
+          detach_iterators(x);
+#endif
+          return false;
+        }
+        link(x,pos);
+      }
+      BOOST_CATCH(...){
+        super::erase_(x);
+
+#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
+      detach_iterators(x);
+#endif
+
+        BOOST_RETHROW;
+      }
+      BOOST_CATCH_END
+    }
+
+    BOOST_TRY{
+      if(!super::modify_(x)){
+        unlink(x);
+
+#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
+        detach_iterators(x);
+#endif
+        return false;
+      }
+      else return true;
+    }
+    BOOST_CATCH(...){
+      unlink(x);
+
+#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
+      detach_iterators(x);
+#endif
+
+      BOOST_RETHROW;
+    }
+    BOOST_CATCH_END
+  }
+
+  bool modify_rollback_(node_type* x)
+  {
+    std::size_t buc=find_bucket(x->value());
+    if(in_place(x->impl(),key(x->value()),buc)){
+      return super::modify_rollback_(x);
+    }
+
+    unlink_undo undo;
+    unlink(x,undo);
+
+    BOOST_TRY{
+      link_info pos(buckets.at(buc));
+      if(link_point(x->value(),pos)&&super::modify_rollback_(x)){
+        link(x,pos);
+        return true;
+      }
+      undo();
+      return false;
+    }
+    BOOST_CATCH(...){
+      undo();
+      BOOST_RETHROW;
+    }
+    BOOST_CATCH_END
+  }
+
+  /* comparison */
+
+#if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
+  /* defect macro refers to class, not function, templates, but anyway */
+
+  template<typename K,typename H,typename P,typename S,typename T,typename C>
+  friend bool operator==(
+    const hashed_index<K,H,P,S,T,C>&,const hashed_index<K,H,P,S,T,C>& y);
+#endif
+
+  bool equals(const hashed_index& x)const{return equals(x,Category());}
+
+  bool equals(const hashed_index& x,hashed_unique_tag)const
+  {
+    if(size()!=x.size())return false;
+    for(const_iterator it=begin(),it_end=end(),it2_end=x.end();
+        it!=it_end;++it){
+      const_iterator it2=x.find(key(*it));
+      if(it2==it2_end||!(*it==*it2))return false;
+    }
+    return true;
+  }
+
+  bool equals(const hashed_index& x,hashed_non_unique_tag)const
+  {
+    if(size()!=x.size())return false;
+    for(const_iterator it=begin(),it_end=end();it!=it_end;){
+      const_iterator it2,it2_last;
+      boost::tie(it2,it2_last)=x.equal_range(key(*it));
+      if(it2==it2_last)return false;
+
+      const_iterator it_last=make_iterator(
+        node_type::from_impl(end_of_range(it.get_node()->impl())));
+      if(std::distance(it,it_last)!=std::distance(it2,it2_last))return false;
+
+      /* From is_permutation code in
+       * http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3068.pdf
+       */
+
+      for(;it!=it_last;++it,++it2){
+        if(!(*it==*it2))break;
+      }
+      if(it!=it_last){
+        for(const_iterator scan=it;scan!=it_last;++scan){
+          if(std::find(it,scan,*scan)!=scan)continue;
+          std::ptrdiff_t matches=std::count(it2,it2_last,*scan);
+          if(matches==0||matches!=std::count(scan,it_last,*scan))return false;
+        }
+        it=it_last;
+      }
+    }
+    return true;
+  }
+
+#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
+  /* serialization */
+
+  template<typename Archive>
+  void save_(
+    Archive& ar,const unsigned int version,const index_saver_type& sm)const
+  {
+    ar<<serialization::make_nvp("position",buckets);
+    super::save_(ar,version,sm);
+  }
+
+  template<typename Archive>
+  void load_(Archive& ar,const unsigned int version,const index_loader_type& lm)
+  {
+    ar>>serialization::make_nvp("position",buckets);
+    super::load_(ar,version,lm);
+  }
+#endif
+
+#if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING)
+  /* invariant stuff */
+
+  bool invariant_()const
+  {
+    if(size()==0||begin()==end()){
+      if(size()!=0||begin()!=end())return false;
+    }
+    else{
+      size_type s0=0;
+      for(const_iterator it=begin(),it_end=end();it!=it_end;++it,++s0){}
+      if(s0!=size())return false;
+
+      size_type s1=0;
+      for(size_type buc=0;buc<bucket_count();++buc){
+        size_type ss1=0;
+        for(const_local_iterator it=begin(buc),it_end=end(buc);
+            it!=it_end;++it,++ss1){
+          if(find_bucket(*it)!=buc)return false;
+        }
+        if(ss1!=bucket_size(buc))return false;
+        s1+=ss1;
+      }
+      if(s1!=size())return false;
+    }
+
+    return super::invariant_();
+  }
+
+  /* This forwarding function eases things for the boost::mem_fn construct
+   * in BOOST_MULTI_INDEX_HASHED_INDEX_CHECK_INVARIANT. Actually,
+   * final_check_invariant is already an inherited member function of index.
+   */
+  void check_invariant_()const{this->final_check_invariant_();}
+#endif
+
+private:
+  node_type* header()const{return this->final_header();}
+
+  std::size_t find_bucket(value_param_type v)const
+  {
+    return bucket(key(v));
+  }
+
+  struct link_info_non_unique
+  {
+    link_info_non_unique(node_impl_base_pointer pos):
+      first(pos),last(node_impl_base_pointer(0)){}
+
+    operator const node_impl_base_pointer&()const{return this->first;}
+
+    node_impl_base_pointer first,last;
+  };
+
+  typedef typename mpl::if_<
+    is_same<Category,hashed_unique_tag>,
+    node_impl_base_pointer,
+    link_info_non_unique
+  >::type                                link_info;
+
+  bool link_point(value_param_type v,link_info& pos)
+  {
+    return link_point(v,pos,Category());
+  }
+
+  bool link_point(
+    value_param_type v,node_impl_base_pointer& pos,hashed_unique_tag)
+  {
+    for(node_impl_pointer x=pos->prior();x!=node_impl_pointer(0);
+        x=node_alg::after_local(x)){
+      if(eq_(key(v),key(node_type::from_impl(x)->value()))){
+        pos=node_impl_type::base_pointer_from(x);
+        return false;
+      }
+    }
+    return true;
+  }
+
+  bool link_point(
+    value_param_type v,link_info_non_unique& pos,hashed_non_unique_tag)
+  {
+    for(node_impl_pointer x=pos.first->prior();x!=node_impl_pointer(0);
+        x=node_alg::next_to_inspect(x)){
+      if(eq_(key(v),key(node_type::from_impl(x)->value()))){
+        pos.first=node_impl_type::base_pointer_from(x);
+        pos.last=node_impl_type::base_pointer_from(last_of_range(x));
+        return true;
+      }
+    }
+    return true;
+  }
+
+  node_impl_pointer last_of_range(node_impl_pointer x)const
+  {
+    return last_of_range(x,Category());
+  }
+
+  node_impl_pointer last_of_range(node_impl_pointer x,hashed_unique_tag)const
+  {
+    return x;
+  }
+
+  node_impl_pointer last_of_range(
+    node_impl_pointer x,hashed_non_unique_tag)const
+  {
+    node_impl_base_pointer y=x->next();
+    node_impl_pointer      z=y->prior();
+    if(z==x){                      /* range of size 1 or 2 */
+      node_impl_pointer yy=node_impl_type::pointer_from(y);
+      return
+        eq_(
+          key(node_type::from_impl(x)->value()),
+          key(node_type::from_impl(yy)->value()))?yy:x;
+    }
+    else if(z->prior()==x)               /* last of bucket */
+      return x;
+    else                                /* group of size>2 */        
+      return z;
+  }
+
+  node_impl_pointer end_of_range(node_impl_pointer x)const
+  {
+    return end_of_range(x,Category());
+  }
+
+  node_impl_pointer end_of_range(node_impl_pointer x,hashed_unique_tag)const
+  {
+    return node_alg::after(last_of_range(x));
+  }
+
+  node_impl_pointer end_of_range(
+    node_impl_pointer x,hashed_non_unique_tag)const
+  {
+    node_impl_base_pointer y=x->next();
+    node_impl_pointer      z=y->prior();
+    if(z==x){                      /* range of size 1 or 2 */
+      node_impl_pointer yy=node_impl_type::pointer_from(y);
+      if(!eq_(
+           key(node_type::from_impl(x)->value()),
+           key(node_type::from_impl(yy)->value())))yy=x;
+      return yy->next()->prior()==yy?
+               node_impl_type::pointer_from(yy->next()):
+               yy->next()->prior();
+    }
+    else if(z->prior()==x)               /* last of bucket */
+      return z;
+    else                                /* group of size>2 */        
+      return z->next()->prior()==z?
+               node_impl_type::pointer_from(z->next()):
+               z->next()->prior();
+  }
+
+  void link(node_type* x,const link_info& pos)
+  {
+    link(x,pos,Category());
+  }
+
+  void link(node_type* x,node_impl_base_pointer pos,hashed_unique_tag)
+  {
+    node_alg::link(x->impl(),pos,header()->impl());
+  }
+
+  void link(node_type* x,const link_info_non_unique& pos,hashed_non_unique_tag)
+  {
+    if(pos.last==node_impl_base_pointer(0)){
+      node_alg::link(x->impl(),pos.first,header()->impl());
+    }
+    else{
+      node_alg::link(
+        x->impl(),
+        node_impl_type::pointer_from(pos.first),
+        node_impl_type::pointer_from(pos.last));
+    }
+  }
+
+  void unlink(node_type* x)
+  {
+    node_alg::unlink(x->impl());
+  }
+
+  typedef typename node_alg::unlink_undo unlink_undo;
+
+  void unlink(node_type* x,unlink_undo& undo)
+  {
+    node_alg::unlink(x->impl(),undo);
+  }
+
+  void calculate_max_load()
+  {
+    float fml=static_cast<float>(mlf*static_cast<float>(bucket_count()));
+    max_load=(std::numeric_limits<size_type>::max)();
+    if(max_load>fml)max_load=static_cast<size_type>(fml);
+  }
+
+  void reserve_for_insert(size_type n)
+  {
+    if(n>max_load){
+      size_type bc =(std::numeric_limits<size_type>::max)();
+      float     fbc=static_cast<float>(1+static_cast<double>(n)/mlf);
+      if(bc>fbc)bc =static_cast<size_type>(fbc);
+      unchecked_rehash(bc);
+    }
+  }
+
+  void unchecked_rehash(size_type n){unchecked_rehash(n,Category());}
+
+  void unchecked_rehash(size_type n,hashed_unique_tag)
+  {
+    node_impl_type    cpy_end_node;
+    node_impl_pointer cpy_end=node_impl_pointer(&cpy_end_node),
+                      end_=header()->impl();
+    bucket_array_type buckets_cpy(get_allocator(),cpy_end,n);
+
+    if(size()!=0){
+      auto_space<
+        std::size_t,allocator_type>       hashes(get_allocator(),size());
+      auto_space<
+        node_impl_pointer,allocator_type> node_ptrs(get_allocator(),size());
+      std::size_t                         i=0,size_=size();
+      bool                                within_bucket=false;
+      BOOST_TRY{
+        for(;i!=size_;++i){
+          node_impl_pointer x=end_->prior();
+
+          /* only this can possibly throw */
+          std::size_t h=hash_(key(node_type::from_impl(x)->value()));
+
+          hashes.data()[i]=h;
+          node_ptrs.data()[i]=x;
+          within_bucket=!node_alg::unlink_last(end_);
+          node_alg::link(x,buckets_cpy.at(buckets_cpy.position(h)),cpy_end);
+        }
+      }
+      BOOST_CATCH(...){
+        if(i!=0){
+          std::size_t prev_buc=buckets.position(hashes.data()[i-1]);
+          if(!within_bucket)prev_buc=~prev_buc;
+
+          for(std::size_t j=i;j--;){
+            std::size_t       buc=buckets.position(hashes.data()[j]);
+            node_impl_pointer x=node_ptrs.data()[j];
+            if(buc==prev_buc)node_alg::append(x,end_);
+            else node_alg::link(x,buckets.at(buc),end_);
+            prev_buc=buc;
+          }
+        }
+        BOOST_RETHROW;
+      }
+      BOOST_CATCH_END
+    }
+
+    end_->prior()=cpy_end->prior()!=cpy_end?cpy_end->prior():end_;
+    end_->next()=cpy_end->next();
+    end_->prior()->next()->prior()=end_->next()->prior()->prior()=end_;
+    buckets.swap(buckets_cpy);
+    calculate_max_load();
+  }
+
+  void unchecked_rehash(size_type n,hashed_non_unique_tag)
+  {
+    node_impl_type    cpy_end_node;
+    node_impl_pointer cpy_end=node_impl_pointer(&cpy_end_node),
+                      end_=header()->impl();
+    bucket_array_type buckets_cpy(get_allocator(),cpy_end,n);
+
+    if(size()!=0){
+      auto_space<
+        std::size_t,allocator_type>       hashes(get_allocator(),size());
+      auto_space<
+        node_impl_pointer,allocator_type> node_ptrs(get_allocator(),size());
+      std::size_t                         i=0;
+      bool                                within_bucket=false;
+      BOOST_TRY{
+        for(;;++i){
+          node_impl_pointer x=end_->prior();
+          if(x==end_)break;
+
+          /* only this can possibly throw */
+          std::size_t h=hash_(key(node_type::from_impl(x)->value()));
+
+          hashes.data()[i]=h;
+          node_ptrs.data()[i]=x;
+          std::pair<node_impl_pointer,bool> p=
+            node_alg::unlink_last_group(end_);
+          node_alg::link_range(
+            p.first,x,buckets_cpy.at(buckets_cpy.position(h)),cpy_end);
+          within_bucket=!(p.second);
+        }
+      }
+      BOOST_CATCH(...){
+        if(i!=0){
+          std::size_t prev_buc=buckets.position(hashes.data()[i-1]);
+          if(!within_bucket)prev_buc=~prev_buc;
+
+          for(std::size_t j=i;j--;){
+            std::size_t       buc=buckets.position(hashes.data()[j]);
+            node_impl_pointer x=node_ptrs.data()[j],
+                              y=
+              x->prior()->next()!=node_impl_type::base_pointer_from(x)&&
+              x->prior()->next()->prior()!=x?
+                node_impl_type::pointer_from(x->prior()->next()):x;
+            node_alg::unlink_range(y,x);
+            if(buc==prev_buc)node_alg::append_range(y,x,end_);
+            else node_alg::link_range(y,x,buckets.at(buc),end_);
+            prev_buc=buc;
+          }
+        }
+        BOOST_RETHROW;
+      }
+      BOOST_CATCH_END
+    }
+
+    end_->prior()=cpy_end->prior()!=cpy_end?cpy_end->prior():end_;
+    end_->next()=cpy_end->next();
+    end_->prior()->next()->prior()=end_->next()->prior()->prior()=end_;
+    buckets.swap(buckets_cpy);
+    calculate_max_load();
+  }
+
+  bool in_place(node_impl_pointer x,key_param_type k,std::size_t buc)const
+  {
+    return in_place(x,k,buc,Category());
+  }
+
+  bool in_place(
+    node_impl_pointer x,key_param_type k,std::size_t buc,
+    hashed_unique_tag)const
+  {
+    bool found=false;
+    for(node_impl_pointer y=buckets.at(buc)->prior();
+        y!=node_impl_pointer(0);y=node_alg::after_local(y)){
+      if(y==x)found=true;
+      else if(eq_(k,key(node_type::from_impl(y)->value())))return false;
+    }
+    return found;
+  }
+
+  bool in_place(
+    node_impl_pointer x,key_param_type k,std::size_t buc,
+    hashed_non_unique_tag)const
+  {
+    bool found=false;
+    int  range_size=0;
+    for(node_impl_pointer y=buckets.at(buc)->prior();y!=node_impl_pointer(0);){
+      if(node_alg::is_first_of_group(y)){ /* group of 3 or more */
+        if(y==x){
+          /* in place <-> equal to some other member of the group */
+          return eq_(
+            k,
+            key(node_type::from_impl(
+              node_impl_type::pointer_from(y->next()))->value()));
+        }
+        else{
+          node_impl_pointer z=
+            node_alg::after_local(y->next()->prior()); /* end of range */
+          if(eq_(k,key(node_type::from_impl(y)->value()))){
+            if(found)return false; /* x lies outside */
+            do{
+              if(y==x)return true;
+              y=node_alg::after_local(y);
+            }while(y!=z);
+            return false; /* x not found */
+          }
+          else{
+            if(range_size==1&&!found)return false;
+            if(range_size==2)return found;
+            range_size=0;
+            y=z; /* skip range (and potentially x, too, which is fine) */
+          }
+        }
+      }
+      else{ /* group of 1 or 2 */
+        if(y==x){
+          if(range_size==1)return true;
+          range_size=1;
+          found=true;
+        }
+        else if(eq_(k,key(node_type::from_impl(y)->value()))){
+          if(range_size==0&&found)return false;
+          if(range_size==1&&!found)return false;
+          if(range_size==2)return false;
+          ++range_size;
+        }
+        else{
+          if(range_size==1&&!found)return false;
+          if(range_size==2)return found;
+          range_size=0;
+        }
+        y=node_alg::after_local(y);
+      }
+    }
+    return found;
+  }
+
+#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
+  void detach_iterators(node_type* x)
+  {
+    iterator it=make_iterator(x);
+    safe_mode::detach_equivalent_iterators(it);
+  }
+#endif
+
+  template<BOOST_MULTI_INDEX_TEMPLATE_PARAM_PACK>
+  std::pair<iterator,bool> emplace_impl(BOOST_MULTI_INDEX_FUNCTION_PARAM_PACK)
+  {
+    BOOST_MULTI_INDEX_HASHED_INDEX_CHECK_INVARIANT;
+    std::pair<final_node_type*,bool>p=
+      this->final_emplace_(BOOST_MULTI_INDEX_FORWARD_PARAM_PACK);
+    return std::pair<iterator,bool>(make_iterator(p.first),p.second);
+  }
+
+  template<BOOST_MULTI_INDEX_TEMPLATE_PARAM_PACK>
+  iterator emplace_hint_impl(
+    iterator position,BOOST_MULTI_INDEX_FUNCTION_PARAM_PACK)
+  {
+    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
+    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
+    BOOST_MULTI_INDEX_HASHED_INDEX_CHECK_INVARIANT;
+    std::pair<final_node_type*,bool>p=
+      this->final_emplace_hint_(
+        static_cast<final_node_type*>(position.get_node()),
+        BOOST_MULTI_INDEX_FORWARD_PARAM_PACK);
+    return make_iterator(p.first);
+  }
+
+  template<
+    typename CompatibleHash,typename CompatiblePred
+  >
+  iterator find(
+    const key_type& k,
+    const CompatibleHash& hash,const CompatiblePred& eq,mpl::true_)const
+  {
+    return find(k,hash,eq,mpl::false_());
+  }
+
+  template<
+    typename CompatibleKey,typename CompatibleHash,typename CompatiblePred
+  >
+  iterator find(
+    const CompatibleKey& k,
+    const CompatibleHash& hash,const CompatiblePred& eq,mpl::false_)const
+  {
+    std::size_t buc=buckets.position(hash(k));
+    for(node_impl_pointer x=buckets.at(buc)->prior();
+        x!=node_impl_pointer(0);x=node_alg::next_to_inspect(x)){
+      if(eq(k,key(node_type::from_impl(x)->value()))){
+        return make_iterator(node_type::from_impl(x));
+      }
+    }
+    return end();
+  }
+
+  template<
+    typename CompatibleHash,typename CompatiblePred
+  >
+  size_type count(
+    const key_type& k,
+    const CompatibleHash& hash,const CompatiblePred& eq,mpl::true_)const
+  {
+    return count(k,hash,eq,mpl::false_());
+  }
+
+  template<
+    typename CompatibleKey,typename CompatibleHash,typename CompatiblePred
+  >
+  size_type count(
+    const CompatibleKey& k,
+    const CompatibleHash& hash,const CompatiblePred& eq,mpl::false_)const
+  {
+    std::size_t buc=buckets.position(hash(k));
+    for(node_impl_pointer x=buckets.at(buc)->prior();
+        x!=node_impl_pointer(0);x=node_alg::next_to_inspect(x)){
+      if(eq(k,key(node_type::from_impl(x)->value()))){
+        size_type         res=0;
+        node_impl_pointer y=end_of_range(x);
+        do{
+          ++res;
+          x=node_alg::after(x);
+        }while(x!=y);
+        return res;
+      }
+    }
+    return 0;
+  }
+
+  template<
+    typename CompatibleHash,typename CompatiblePred
+  >
+  std::pair<iterator,iterator> equal_range(
+    const key_type& k,
+    const CompatibleHash& hash,const CompatiblePred& eq,mpl::true_)const
+  {
+    return equal_range(k,hash,eq,mpl::false_());
+  }
+
+  template<
+    typename CompatibleKey,typename CompatibleHash,typename CompatiblePred
+  >
+  std::pair<iterator,iterator> equal_range(
+    const CompatibleKey& k,
+    const CompatibleHash& hash,const CompatiblePred& eq,mpl::false_)const
+  {
+    std::size_t buc=buckets.position(hash(k));
+    for(node_impl_pointer x=buckets.at(buc)->prior();
+        x!=node_impl_pointer(0);x=node_alg::next_to_inspect(x)){
+      if(eq(k,key(node_type::from_impl(x)->value()))){
+        return std::pair<iterator,iterator>(
+          make_iterator(node_type::from_impl(x)),
+          make_iterator(node_type::from_impl(end_of_range(x))));
+      }
+    }
+    return std::pair<iterator,iterator>(end(),end());
+  }
+
+  key_from_value               key;
+  hasher                       hash_;
+  key_equal                    eq_;
+  bucket_array_type            buckets;
+  float                        mlf;
+  size_type                    max_load;
+      
+#if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING)&&\
+    BOOST_WORKAROUND(__MWERKS__,<=0x3003)
+#pragma parse_mfunc_templ reset
+#endif
+};
+
+/* comparison */
+
+template<
+  typename KeyFromValue,typename Hash,typename Pred,
+  typename SuperMeta,typename TagList,typename Category
+>
+bool operator==(
+  const hashed_index<KeyFromValue,Hash,Pred,SuperMeta,TagList,Category>& x,
+  const hashed_index<KeyFromValue,Hash,Pred,SuperMeta,TagList,Category>& y)
+{
+  return x.equals(y);
+}
+
+template<
+  typename KeyFromValue,typename Hash,typename Pred,
+  typename SuperMeta,typename TagList,typename Category
+>
+bool operator!=(
+  const hashed_index<KeyFromValue,Hash,Pred,SuperMeta,TagList,Category>& x,
+  const hashed_index<KeyFromValue,Hash,Pred,SuperMeta,TagList,Category>& y)
+{
+  return !(x==y);
+}
+
+/*  specialized algorithms */
+
+template<
+  typename KeyFromValue,typename Hash,typename Pred,
+  typename SuperMeta,typename TagList,typename Category
+>
+void swap(
+  hashed_index<KeyFromValue,Hash,Pred,SuperMeta,TagList,Category>& x,
+  hashed_index<KeyFromValue,Hash,Pred,SuperMeta,TagList,Category>& y)
+{
+  x.swap(y);
+}
+
+} /* namespace multi_index::detail */
+
+/* hashed index specifiers */
+
+template<typename Arg1,typename Arg2,typename Arg3,typename Arg4>
+struct hashed_unique
+{
+  typedef typename detail::hashed_index_args<
+    Arg1,Arg2,Arg3,Arg4>                           index_args;
+  typedef typename index_args::tag_list_type::type tag_list_type;
+  typedef typename index_args::key_from_value_type key_from_value_type;
+  typedef typename index_args::hash_type           hash_type;
+  typedef typename index_args::pred_type           pred_type;
+
+  template<typename Super>
+  struct node_class
+  {
+    typedef detail::hashed_index_node<Super,detail::hashed_unique_tag> type;
+  };
+
+  template<typename SuperMeta>
+  struct index_class
+  {
+    typedef detail::hashed_index<
+      key_from_value_type,hash_type,pred_type,
+      SuperMeta,tag_list_type,detail::hashed_unique_tag> type;
+  };
+};
+
+template<typename Arg1,typename Arg2,typename Arg3,typename Arg4>
+struct hashed_non_unique
+{
+  typedef typename detail::hashed_index_args<
+    Arg1,Arg2,Arg3,Arg4>                           index_args;
+  typedef typename index_args::tag_list_type::type tag_list_type;
+  typedef typename index_args::key_from_value_type key_from_value_type;
+  typedef typename index_args::hash_type           hash_type;
+  typedef typename index_args::pred_type           pred_type;
+
+  template<typename Super>
+  struct node_class
+  {
+    typedef detail::hashed_index_node<
+      Super,detail::hashed_non_unique_tag> type;
+  };
+
+  template<typename SuperMeta>
+  struct index_class
+  {
+    typedef detail::hashed_index<
+      key_from_value_type,hash_type,pred_type,
+      SuperMeta,tag_list_type,detail::hashed_non_unique_tag> type;
+  };
+};
+
+} /* namespace multi_index */
+
+} /* namespace boost */
+
+/* Boost.Foreach compatibility */
+
+template<
+  typename KeyFromValue,typename Hash,typename Pred,
+  typename SuperMeta,typename TagList,typename Category
+>
+inline boost::mpl::true_* boost_foreach_is_noncopyable(
+  boost::multi_index::detail::hashed_index<
+    KeyFromValue,Hash,Pred,SuperMeta,TagList,Category>*&,
+  boost_foreach_argument_dependent_lookup_hack)
+{
+  return 0;
+}
+
+#undef BOOST_MULTI_INDEX_HASHED_INDEX_CHECK_INVARIANT
+#undef BOOST_MULTI_INDEX_HASHED_INDEX_CHECK_INVARIANT_OF
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/hashed_index_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/hashed_index_fwd.hpp
new file mode 100644
index 00000000000..d77e36c321b
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/multi_index/hashed_index_fwd.hpp
@@ -0,0 +1,74 @@
+/* Copyright 2003-2013 Joaquin M Lopez Munoz.
+ * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
+ */
+
+#ifndef BOOST_MULTI_INDEX_HASHED_INDEX_FWD_HPP
+#define BOOST_MULTI_INDEX_HASHED_INDEX_FWD_HPP
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/multi_index/detail/hash_index_args.hpp>
+
+namespace boost{
+
+namespace multi_index{
+
+namespace detail{
+
+template<
+  typename KeyFromValue,typename Hash,typename Pred,
+  typename SuperMeta,typename TagList,typename Category
+>
+class hashed_index;
+
+template<
+  typename KeyFromValue,typename Hash,typename Pred,
+  typename SuperMeta,typename TagList,typename Category
+>
+bool operator==(
+  const hashed_index<KeyFromValue,Hash,Pred,SuperMeta,TagList,Category>& x,
+  const hashed_index<KeyFromValue,Hash,Pred,SuperMeta,TagList,Category>& y);
+
+template<
+  typename KeyFromValue,typename Hash,typename Pred,
+  typename SuperMeta,typename TagList,typename Category
+>
+bool operator!=(
+  const hashed_index<KeyFromValue,Hash,Pred,SuperMeta,TagList,Category>& x,
+  const hashed_index<KeyFromValue,Hash,Pred,SuperMeta,TagList,Category>& y);
+
+template<
+  typename KeyFromValue,typename Hash,typename Pred,
+  typename SuperMeta,typename TagList,typename Category
+>
+void swap(
+  hashed_index<KeyFromValue,Hash,Pred,SuperMeta,TagList,Category>& x,
+  hashed_index<KeyFromValue,Hash,Pred,SuperMeta,TagList,Category>& y);
+
+} /* namespace multi_index::detail */
+
+/* hashed_index specifiers */
+
+template<
+  typename Arg1,typename Arg2=mpl::na,
+  typename Arg3=mpl::na,typename Arg4=mpl::na
+>
+struct hashed_unique;
+
+template<
+  typename Arg1,typename Arg2=mpl::na,
+  typename Arg3=mpl::na,typename Arg4=mpl::na
+>
+struct hashed_non_unique;
+
+} /* namespace multi_index */
+
+} /* namespace boost */
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/identity.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/identity.hpp
new file mode 100644
index 00000000000..6c832ce1562
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/multi_index/identity.hpp
@@ -0,0 +1,145 @@
+/* Copyright 2003-2015 Joaquin M Lopez Munoz.
+ * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
+ */
+
+#ifndef BOOST_MULTI_INDEX_IDENTITY_HPP
+#define BOOST_MULTI_INDEX_IDENTITY_HPP
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/multi_index/identity_fwd.hpp>
+#include <boost/type_traits/is_const.hpp>
+#include <boost/type_traits/remove_const.hpp>
+#include <boost/utility/enable_if.hpp>
+
+#if !defined(BOOST_NO_SFINAE)
+#include <boost/type_traits/is_convertible.hpp>
+#endif
+
+namespace boost{
+
+template<class Type> class reference_wrapper; /* fwd decl. */
+
+namespace multi_index{
+
+namespace detail{
+
+/* identity is a do-nothing key extractor that returns the [const] Type&
+ * object passed.
+ * Additionally, identity is overloaded to support referece_wrappers
+ * of Type and "chained pointers" to Type's. By chained pointer to Type we
+ * mean a  type  P such that, given a p of type P
+ *   *...n...*x is convertible to Type&, for some n>=1.
+ * Examples of chained pointers are raw and smart pointers, iterators and
+ * arbitrary combinations of these (vg. Type** or unique_ptr<Type*>.)
+ */
+
+template<typename Type>
+struct const_identity_base
+{
+  typedef Type result_type;
+
+  template<typename ChainedPtr>
+
+#if !defined(BOOST_NO_SFINAE)
+  typename disable_if<is_convertible<const ChainedPtr&,Type&>,Type&>::type
+#else
+  Type&
+#endif 
+  
+  operator()(const ChainedPtr& x)const
+  {
+    return operator()(*x);
+  }
+
+  Type& operator()(Type& x)const
+  {
+    return x;
+  }
+
+  Type& operator()(const reference_wrapper<Type>& x)const
+  { 
+    return x.get();
+  }
+
+  Type& operator()(
+    const reference_wrapper<typename remove_const<Type>::type>& x
+
+#if BOOST_WORKAROUND(BOOST_MSVC,==1310)
+/* http://lists.boost.org/Archives/boost/2015/10/226135.php */
+    ,int=0
+#endif
+
+  )const
+  { 
+    return x.get();
+  }
+};
+
+template<typename Type>
+struct non_const_identity_base
+{
+  typedef Type result_type;
+
+  /* templatized for pointer-like types */
+  
+  template<typename ChainedPtr>
+
+#if !defined(BOOST_NO_SFINAE)
+  typename disable_if<
+    is_convertible<const ChainedPtr&,const Type&>,Type&>::type
+#else
+  Type&
+#endif 
+    
+  operator()(const ChainedPtr& x)const
+  {
+    return operator()(*x);
+  }
+
+  const Type& operator()(const Type& x)const
+  {
+    return x;
+  }
+
+  Type& operator()(Type& x)const
+  {
+    return x;
+  }
+
+  const Type& operator()(const reference_wrapper<const Type>& x)const
+  { 
+    return x.get();
+  }
+
+  Type& operator()(const reference_wrapper<Type>& x)const
+  { 
+    return x.get();
+  }
+};
+
+} /* namespace multi_index::detail */
+
+template<class Type>
+struct identity:
+  mpl::if_c<
+    is_const<Type>::value,
+    detail::const_identity_base<Type>,detail::non_const_identity_base<Type>
+  >::type
+{
+};
+
+} /* namespace multi_index */
+
+} /* namespace boost */
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/identity_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/identity_fwd.hpp
new file mode 100644
index 00000000000..af6bd55ef5f
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/multi_index/identity_fwd.hpp
@@ -0,0 +1,26 @@
+/* Copyright 2003-2013 Joaquin M Lopez Munoz.
+ * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
+ */
+
+#ifndef BOOST_MULTI_INDEX_IDENTITY_FWD_HPP
+#define BOOST_MULTI_INDEX_IDENTITY_FWD_HPP
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+namespace boost{
+
+namespace multi_index{
+
+template<class Type> struct identity;
+
+} /* namespace multi_index */
+
+} /* namespace boost */
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/indexed_by.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/indexed_by.hpp
new file mode 100644
index 00000000000..d2217e39166
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/multi_index/indexed_by.hpp
@@ -0,0 +1,68 @@
+/* Copyright 2003-2013 Joaquin M Lopez Munoz.
+ * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
+ */
+
+#ifndef BOOST_MULTI_INDEX_INDEXED_BY_HPP
+#define BOOST_MULTI_INDEX_INDEXED_BY_HPP
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
+#include <boost/mpl/vector.hpp>
+#include <boost/preprocessor/cat.hpp>
+#include <boost/preprocessor/control/expr_if.hpp>
+#include <boost/preprocessor/repetition/enum.hpp>
+#include <boost/preprocessor/repetition/enum_params.hpp> 
+
+/* An alias to mpl::vector used to hide MPL from the user.
+ * indexed_by contains the index specifiers for instantiation
+ * of a multi_index_container.
+ */
+
+/* This user_definable macro limits the number of elements of an index list;
+ * useful for shortening resulting symbol names (MSVC++ 6.0, for instance,
+ * has problems coping with very long symbol names.)
+ */
+
+#if !defined(BOOST_MULTI_INDEX_LIMIT_INDEXED_BY_SIZE)
+#define BOOST_MULTI_INDEX_LIMIT_INDEXED_BY_SIZE BOOST_MPL_LIMIT_VECTOR_SIZE
+#endif
+
+#if BOOST_MULTI_INDEX_LIMIT_INDEXED_BY_SIZE<BOOST_MPL_LIMIT_VECTOR_SIZE
+#define BOOST_MULTI_INDEX_INDEXED_BY_SIZE \
+  BOOST_MULTI_INDEX_LIMIT_INDEXED_BY_SIZE
+#else
+#define BOOST_MULTI_INDEX_INDEXED_BY_SIZE BOOST_MPL_LIMIT_VECTOR_SIZE
+#endif
+
+#define BOOST_MULTI_INDEX_INDEXED_BY_TEMPLATE_PARM(z,n,var) \
+  typename BOOST_PP_CAT(var,n) BOOST_PP_EXPR_IF(n,=mpl::na)
+
+namespace boost{
+
+namespace multi_index{
+
+template<
+  BOOST_PP_ENUM(
+    BOOST_MULTI_INDEX_INDEXED_BY_SIZE,
+    BOOST_MULTI_INDEX_INDEXED_BY_TEMPLATE_PARM,T)
+>
+struct indexed_by:
+  mpl::vector<BOOST_PP_ENUM_PARAMS(BOOST_MULTI_INDEX_INDEXED_BY_SIZE,T)>
+{
+};
+
+} /* namespace multi_index */
+
+} /* namespace boost */
+
+#undef BOOST_MULTI_INDEX_INDEXED_BY_TEMPLATE_PARM
+#undef BOOST_MULTI_INDEX_INDEXED_BY_SIZE
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/key_extractors.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/key_extractors.hpp
new file mode 100644
index 00000000000..60179ba2339
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/multi_index/key_extractors.hpp
@@ -0,0 +1,22 @@
+/* Copyright 2003-2013 Joaquin M Lopez Munoz.
+ * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
+ */
+
+#ifndef BOOST_MULTI_INDEX_KEY_EXTRACTORS_HPP
+#define BOOST_MULTI_INDEX_KEY_EXTRACTORS_HPP
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/multi_index/composite_key.hpp>
+#include <boost/multi_index/identity.hpp>
+#include <boost/multi_index/global_fun.hpp>
+#include <boost/multi_index/member.hpp>
+#include <boost/multi_index/mem_fun.hpp>
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/mem_fun.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/mem_fun.hpp
new file mode 100644
index 00000000000..111c386c5f5
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/multi_index/mem_fun.hpp
@@ -0,0 +1,205 @@
+/* Copyright 2003-2015 Joaquin M Lopez Munoz.
+ * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
+ */
+
+#ifndef BOOST_MULTI_INDEX_MEM_FUN_HPP
+#define BOOST_MULTI_INDEX_MEM_FUN_HPP
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
+#include <boost/mpl/if.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+#include <boost/utility/enable_if.hpp>
+
+#if !defined(BOOST_NO_SFINAE)
+#include <boost/type_traits/is_convertible.hpp>
+#endif
+
+namespace boost{
+
+template<class T> class reference_wrapper; /* fwd decl. */
+
+namespace multi_index{
+
+/* mem_fun implements a read-only key extractor based on a given non-const
+ * member function of a class.
+ * const_mem_fun does the same for const member functions.
+ * Additionally, mem_fun  and const_mem_fun are overloaded to support
+ * referece_wrappers of T and "chained pointers" to T's. By chained pointer
+ * to T we  mean a type P such that, given a p of Type P
+ *   *...n...*x is convertible to T&, for some n>=1.
+ * Examples of chained pointers are raw and smart pointers, iterators and
+ * arbitrary combinations of these (vg. T** or unique_ptr<T*>.)
+ */
+
+template<class Class,typename Type,Type (Class::*PtrToMemberFunction)()const>
+struct const_mem_fun
+{
+  typedef typename remove_reference<Type>::type result_type;
+
+  template<typename ChainedPtr>
+
+#if !defined(BOOST_NO_SFINAE)
+  typename disable_if<
+    is_convertible<const ChainedPtr&,const Class&>,Type>::type
+#else
+  Type
+#endif
+
+  operator()(const ChainedPtr& x)const
+  {
+    return operator()(*x);
+  }
+
+  Type operator()(const Class& x)const
+  {
+    return (x.*PtrToMemberFunction)();
+  }
+
+  Type operator()(const reference_wrapper<const Class>& x)const
+  { 
+    return operator()(x.get());
+  }
+
+  Type operator()(const reference_wrapper<Class>& x)const
+  { 
+    return operator()(x.get());
+  }
+};
+
+template<class Class,typename Type,Type (Class::*PtrToMemberFunction)()>
+struct mem_fun
+{
+  typedef typename remove_reference<Type>::type result_type;
+
+  template<typename ChainedPtr>
+
+#if !defined(BOOST_NO_SFINAE)
+  typename disable_if<
+    is_convertible<ChainedPtr&,Class&>,Type>::type
+#else
+  Type
+#endif
+
+  operator()(const ChainedPtr& x)const
+  {
+    return operator()(*x);
+  }
+
+  Type operator()(Class& x)const
+  {
+    return (x.*PtrToMemberFunction)();
+  }
+
+  Type operator()(const reference_wrapper<Class>& x)const
+  { 
+    return operator()(x.get());
+  }
+};
+
+/* MSVC++ 6.0 has problems with const member functions as non-type template
+ * parameters, somehow it takes them as non-const. const_mem_fun_explicit
+ * workarounds this deficiency by accepting an extra type parameter that
+ * specifies the signature of the member function. The workaround was found at:
+ *   Daniel, C.:"Re: weird typedef problem in VC",
+ *   news:microsoft.public.vc.language, 21st nov 2002, 
+ *   http://groups.google.com/groups?
+ *     hl=en&lr=&ie=UTF-8&selm=ukwvg3O0BHA.1512%40tkmsftngp05
+ *
+ * MSVC++ 6.0 support has been dropped and [const_]mem_fun_explicit is
+ * deprecated.
+ */
+
+template<
+  class Class,typename Type,
+  typename PtrToMemberFunctionType,PtrToMemberFunctionType PtrToMemberFunction>
+struct const_mem_fun_explicit
+{
+  typedef typename remove_reference<Type>::type result_type;
+
+  template<typename ChainedPtr>
+
+#if !defined(BOOST_NO_SFINAE)
+  typename disable_if<
+    is_convertible<const ChainedPtr&,const Class&>,Type>::type
+#else
+  Type
+#endif
+
+  operator()(const ChainedPtr& x)const
+  {
+    return operator()(*x);
+  }
+
+  Type operator()(const Class& x)const
+  {
+    return (x.*PtrToMemberFunction)();
+  }
+
+  Type operator()(const reference_wrapper<const Class>& x)const
+  { 
+    return operator()(x.get());
+  }
+
+  Type operator()(const reference_wrapper<Class>& x)const
+  { 
+    return operator()(x.get());
+  }
+};
+
+template<
+  class Class,typename Type,
+  typename PtrToMemberFunctionType,PtrToMemberFunctionType PtrToMemberFunction>
+struct mem_fun_explicit
+{
+  typedef typename remove_reference<Type>::type result_type;
+
+  template<typename ChainedPtr>
+
+#if !defined(BOOST_NO_SFINAE)
+  typename disable_if<
+    is_convertible<ChainedPtr&,Class&>,Type>::type
+#else
+  Type
+#endif
+
+  operator()(const ChainedPtr& x)const
+  {
+    return operator()(*x);
+  }
+
+  Type operator()(Class& x)const
+  {
+    return (x.*PtrToMemberFunction)();
+  }
+
+  Type operator()(const reference_wrapper<Class>& x)const
+  { 
+    return operator()(x.get());
+  }
+};
+
+/* BOOST_MULTI_INDEX_CONST_MEM_FUN and BOOST_MULTI_INDEX_MEM_FUN used to
+ * resolve to [const_]mem_fun_explicit for MSVC++ 6.0 and to
+ * [const_]mem_fun otherwise. Support for this compiler having been dropped,
+ * they are now just wrappers over [const_]mem_fun kept for backwards-
+ * compatibility reasons.
+ */
+
+#define BOOST_MULTI_INDEX_CONST_MEM_FUN(Class,Type,MemberFunName) \
+::boost::multi_index::const_mem_fun< Class,Type,&Class::MemberFunName >
+#define BOOST_MULTI_INDEX_MEM_FUN(Class,Type,MemberFunName) \
+::boost::multi_index::mem_fun< Class,Type,&Class::MemberFunName >
+
+} /* namespace multi_index */
+
+} /* namespace boost */
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/member.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/member.hpp
new file mode 100644
index 00000000000..a8e645074a2
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/multi_index/member.hpp
@@ -0,0 +1,262 @@
+/* Copyright 2003-2015 Joaquin M Lopez Munoz.
+ * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
+ */
+
+#ifndef BOOST_MULTI_INDEX_MEMBER_HPP
+#define BOOST_MULTI_INDEX_MEMBER_HPP
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
+#include <boost/mpl/if.hpp>
+#include <boost/type_traits/is_const.hpp>
+#include <boost/utility/enable_if.hpp>
+#include <cstddef>
+
+#if !defined(BOOST_NO_SFINAE)
+#include <boost/type_traits/is_convertible.hpp>
+#endif
+
+namespace boost{
+
+template<class T> class reference_wrapper; /* fwd decl. */
+
+namespace multi_index{
+
+namespace detail{
+
+/* member is a read/write key extractor for accessing a given
+ * member of a class.
+ * Additionally, member is overloaded to support referece_wrappers
+ * of T and "chained pointers" to T's. By chained pointer to T we mean
+ * a type P  such that, given a p of Type P
+ *   *...n...*x is convertible to T&, for some n>=1.
+ * Examples of chained pointers are raw and smart pointers, iterators and
+ * arbitrary combinations of these (vg. T** or unique_ptr<T*>.)
+ */
+
+template<class Class,typename Type,Type Class::*PtrToMember>
+struct const_member_base
+{
+  typedef Type result_type;
+
+  template<typename ChainedPtr>
+
+#if !defined(BOOST_NO_SFINAE)
+  typename disable_if<
+    is_convertible<const ChainedPtr&,const Class&>,Type&>::type
+#else
+  Type&
+#endif
+  
+  operator()(const ChainedPtr& x)const
+  {
+    return operator()(*x);
+  }
+
+  Type& operator()(const Class& x)const
+  {
+    return x.*PtrToMember;
+  }
+
+  Type& operator()(const reference_wrapper<const Class>& x)const
+  {
+    return operator()(x.get());
+  }
+
+  Type& operator()(const reference_wrapper<Class>& x)const
+  { 
+    return operator()(x.get());
+  }
+};
+
+template<class Class,typename Type,Type Class::*PtrToMember>
+struct non_const_member_base
+{
+  typedef Type result_type;
+
+  template<typename ChainedPtr>
+
+#if !defined(BOOST_NO_SFINAE)
+  typename disable_if<
+    is_convertible<const ChainedPtr&,const Class&>,Type&>::type
+#else
+  Type&
+#endif
+
+  operator()(const ChainedPtr& x)const
+  {
+    return operator()(*x);
+  }
+
+  const Type& operator()(const Class& x)const
+  {
+    return x.*PtrToMember;
+  }
+
+  Type& operator()(Class& x)const
+  { 
+    return x.*PtrToMember;
+  }
+
+  const Type& operator()(const reference_wrapper<const Class>& x)const
+  {
+    return operator()(x.get());
+  }
+
+  Type& operator()(const reference_wrapper<Class>& x)const
+  { 
+    return operator()(x.get());
+  }
+};
+
+} /* namespace multi_index::detail */
+
+template<class Class,typename Type,Type Class::*PtrToMember>
+struct member:
+  mpl::if_c<
+    is_const<Type>::value,
+    detail::const_member_base<Class,Type,PtrToMember>,
+    detail::non_const_member_base<Class,Type,PtrToMember>
+  >::type
+{
+};
+
+namespace detail{
+
+/* MSVC++ 6.0 does not support properly pointers to members as
+ * non-type template arguments, as reported in
+ *   http://support.microsoft.com/default.aspx?scid=kb;EN-US;249045
+ * A similar problem (though not identical) is shown by MSVC++ 7.0.
+ * We provide an alternative to member<> accepting offsets instead
+ * of pointers to members. This happens to work even for non-POD
+ * types (although the standard forbids use of offsetof on these),
+ * so it serves as a workaround in this compiler for all practical
+ * purposes.
+ * Surprisingly enough, other compilers, like Intel C++ 7.0/7.1 and
+ * Visual Age 6.0, have similar bugs. This replacement of member<>
+ * can be used for them too.
+ *
+ * Support for such old compilers is dropped and
+ * [non_]const_member_offset_base is deprecated.
+ */
+
+template<class Class,typename Type,std::size_t OffsetOfMember>
+struct const_member_offset_base
+{
+  typedef Type result_type;
+
+  template<typename ChainedPtr>
+
+#if !defined(BOOST_NO_SFINAE)
+  typename disable_if<
+    is_convertible<const ChainedPtr&,const Class&>,Type&>::type
+#else
+  Type&
+#endif 
+    
+  operator()(const ChainedPtr& x)const
+  {
+    return operator()(*x);
+  }
+
+  Type& operator()(const Class& x)const
+  {
+    return *static_cast<const Type*>(
+      static_cast<const void*>(
+        static_cast<const char*>(
+          static_cast<const void *>(&x))+OffsetOfMember));
+  }
+
+  Type& operator()(const reference_wrapper<const Class>& x)const
+  {
+    return operator()(x.get());
+  }
+
+  Type& operator()(const reference_wrapper<Class>& x)const
+  {
+    return operator()(x.get());
+  }
+};
+
+template<class Class,typename Type,std::size_t OffsetOfMember>
+struct non_const_member_offset_base
+{
+  typedef Type result_type;
+
+  template<typename ChainedPtr>
+
+#if !defined(BOOST_NO_SFINAE)
+  typename disable_if<
+    is_convertible<const ChainedPtr&,const Class&>,Type&>::type
+#else
+  Type&
+#endif 
+  
+  operator()(const ChainedPtr& x)const
+  {
+    return operator()(*x);
+  }
+
+  const Type& operator()(const Class& x)const
+  {
+    return *static_cast<const Type*>(
+      static_cast<const void*>(
+        static_cast<const char*>(
+          static_cast<const void *>(&x))+OffsetOfMember));
+  }
+
+  Type& operator()(Class& x)const
+  { 
+    return *static_cast<Type*>(
+      static_cast<void*>(
+        static_cast<char*>(static_cast<void *>(&x))+OffsetOfMember));
+  }
+
+  const Type& operator()(const reference_wrapper<const Class>& x)const
+  {
+    return operator()(x.get());
+  }
+
+  Type& operator()(const reference_wrapper<Class>& x)const
+  {
+    return operator()(x.get());
+  }
+};
+
+} /* namespace multi_index::detail */
+
+template<class Class,typename Type,std::size_t OffsetOfMember>
+struct member_offset:
+  mpl::if_c<
+    is_const<Type>::value,
+    detail::const_member_offset_base<Class,Type,OffsetOfMember>,
+    detail::non_const_member_offset_base<Class,Type,OffsetOfMember>
+  >::type
+{
+};
+
+/* BOOST_MULTI_INDEX_MEMBER resolves to member in the normal cases,
+ * and to member_offset as a workaround in those defective compilers for
+ * which BOOST_NO_POINTER_TO_MEMBER_TEMPLATE_PARAMETERS is defined.
+ */
+
+#if defined(BOOST_NO_POINTER_TO_MEMBER_TEMPLATE_PARAMETERS)
+#define BOOST_MULTI_INDEX_MEMBER(Class,Type,MemberName) \
+::boost::multi_index::member_offset< Class,Type,offsetof(Class,MemberName) >
+#else
+#define BOOST_MULTI_INDEX_MEMBER(Class,Type,MemberName) \
+::boost::multi_index::member< Class,Type,&Class::MemberName >
+#endif
+
+} /* namespace multi_index */
+
+} /* namespace boost */
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/ordered_index.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/ordered_index.hpp
new file mode 100644
index 00000000000..5bcd69de8c9
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/multi_index/ordered_index.hpp
@@ -0,0 +1,114 @@
+/* Copyright 2003-2015 Joaquin M Lopez Munoz.
+ * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
+ */
+
+#ifndef BOOST_MULTI_INDEX_ORDERED_INDEX_HPP
+#define BOOST_MULTI_INDEX_ORDERED_INDEX_HPP
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
+#include <boost/multi_index/detail/ord_index_impl.hpp>
+#include <boost/multi_index/ordered_index_fwd.hpp>
+
+namespace boost{
+
+namespace multi_index{
+
+namespace detail{
+
+/* no augment policy for plain ordered indices */
+
+struct null_augment_policy
+{
+  template<typename OrderedIndexImpl>
+  struct augmented_interface
+  {
+    typedef OrderedIndexImpl type;
+  };
+
+  template<typename OrderedIndexNodeImpl>
+  struct augmented_node
+  {
+    typedef OrderedIndexNodeImpl type;
+  };
+
+  template<typename Pointer> static void add(Pointer,Pointer){}
+  template<typename Pointer> static void remove(Pointer,Pointer){}
+  template<typename Pointer> static void copy(Pointer,Pointer){}
+  template<typename Pointer> static void rotate_left(Pointer,Pointer){}
+  template<typename Pointer> static void rotate_right(Pointer,Pointer){}
+
+#if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING)
+  /* invariant stuff */
+
+  template<typename Pointer> static bool invariant(Pointer){return true;}
+
+#endif
+};
+
+} /* namespace multi_index::detail */
+
+/* ordered_index specifiers */
+
+template<typename Arg1,typename Arg2,typename Arg3>
+struct ordered_unique
+{
+  typedef typename detail::ordered_index_args<
+    Arg1,Arg2,Arg3>                                index_args;
+  typedef typename index_args::tag_list_type::type tag_list_type;
+  typedef typename index_args::key_from_value_type key_from_value_type;
+  typedef typename index_args::compare_type        compare_type;
+
+  template<typename Super>
+  struct node_class
+  {
+    typedef detail::ordered_index_node<detail::null_augment_policy,Super> type;
+  };
+
+  template<typename SuperMeta>
+  struct index_class
+  {
+    typedef detail::ordered_index<
+      key_from_value_type,compare_type,
+      SuperMeta,tag_list_type,detail::ordered_unique_tag,
+      detail::null_augment_policy>                        type;
+  };
+};
+
+template<typename Arg1,typename Arg2,typename Arg3>
+struct ordered_non_unique
+{
+  typedef detail::ordered_index_args<
+    Arg1,Arg2,Arg3>                                index_args;
+  typedef typename index_args::tag_list_type::type tag_list_type;
+  typedef typename index_args::key_from_value_type key_from_value_type;
+  typedef typename index_args::compare_type        compare_type;
+
+  template<typename Super>
+  struct node_class
+  {
+    typedef detail::ordered_index_node<detail::null_augment_policy,Super> type;
+  };
+
+  template<typename SuperMeta>
+  struct index_class
+  {
+    typedef detail::ordered_index<
+      key_from_value_type,compare_type,
+      SuperMeta,tag_list_type,detail::ordered_non_unique_tag,
+      detail::null_augment_policy>                            type;
+  };
+};
+
+} /* namespace multi_index */
+
+} /* namespace boost */
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/ordered_index_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/ordered_index_fwd.hpp
new file mode 100644
index 00000000000..fe44aaf860d
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/multi_index/ordered_index_fwd.hpp
@@ -0,0 +1,35 @@
+/* Copyright 2003-2015 Joaquin M Lopez Munoz.
+ * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
+ */
+
+#ifndef BOOST_MULTI_INDEX_ORDERED_INDEX_FWD_HPP
+#define BOOST_MULTI_INDEX_ORDERED_INDEX_FWD_HPP
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/multi_index/detail/ord_index_args.hpp>
+#include <boost/multi_index/detail/ord_index_impl_fwd.hpp>
+
+namespace boost{
+
+namespace multi_index{
+
+/* ordered_index specifiers */
+
+template<typename Arg1,typename Arg2=mpl::na,typename Arg3=mpl::na>
+struct ordered_unique;
+
+template<typename Arg1,typename Arg2=mpl::na,typename Arg3=mpl::na>
+struct ordered_non_unique;
+
+} /* namespace multi_index */
+
+} /* namespace boost */
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/random_access_index.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/random_access_index.hpp
new file mode 100644
index 00000000000..fe1884ddd38
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/multi_index/random_access_index.hpp
@@ -0,0 +1,1167 @@
+/* Copyright 2003-2015 Joaquin M Lopez Munoz.
+ * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
+ */
+
+#ifndef BOOST_MULTI_INDEX_RANDOM_ACCESS_INDEX_HPP
+#define BOOST_MULTI_INDEX_RANDOM_ACCESS_INDEX_HPP
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
+#include <algorithm>
+#include <boost/bind.hpp>
+#include <boost/call_traits.hpp>
+#include <boost/detail/no_exceptions_support.hpp>
+#include <boost/detail/workaround.hpp>
+#include <boost/foreach_fwd.hpp>
+#include <boost/iterator/reverse_iterator.hpp>
+#include <boost/move/core.hpp>
+#include <boost/move/utility.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/mpl/not.hpp>
+#include <boost/mpl/push_front.hpp>
+#include <boost/multi_index/detail/access_specifier.hpp>
+#include <boost/multi_index/detail/do_not_copy_elements_tag.hpp>
+#include <boost/multi_index/detail/index_node_base.hpp>
+#include <boost/multi_index/detail/rnd_node_iterator.hpp>
+#include <boost/multi_index/detail/rnd_index_node.hpp>
+#include <boost/multi_index/detail/rnd_index_ops.hpp>
+#include <boost/multi_index/detail/rnd_index_ptr_array.hpp>
+#include <boost/multi_index/detail/safe_mode.hpp>
+#include <boost/multi_index/detail/scope_guard.hpp>
+#include <boost/multi_index/detail/vartempl_support.hpp>
+#include <boost/multi_index/random_access_index_fwd.hpp>
+#include <boost/throw_exception.hpp> 
+#include <boost/tuple/tuple.hpp>
+#include <boost/type_traits/is_integral.hpp>
+#include <cstddef>
+#include <functional>
+#include <stdexcept> 
+#include <utility>
+
+#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
+#include<initializer_list>
+#endif
+
+#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
+#include <boost/multi_index/detail/rnd_index_loader.hpp>
+#endif
+
+#if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING)
+#define BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT_OF(x)                    \
+  detail::scope_guard BOOST_JOIN(check_invariant_,__LINE__)=                 \
+    detail::make_obj_guard(x,&random_access_index::check_invariant_);        \
+  BOOST_JOIN(check_invariant_,__LINE__).touch();
+#define BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT                          \
+  BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT_OF(*this)
+#else
+#define BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT_OF(x)
+#define BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT
+#endif
+
+namespace boost{
+
+namespace multi_index{
+
+namespace detail{
+
+/* random_access_index adds a layer of random access indexing
+ * to a given Super
+ */
+
+template<typename SuperMeta,typename TagList>
+class random_access_index:
+  BOOST_MULTI_INDEX_PROTECTED_IF_MEMBER_TEMPLATE_FRIENDS SuperMeta::type
+
+#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
+  ,public safe_mode::safe_container<
+    random_access_index<SuperMeta,TagList> >
+#endif
+
+{ 
+#if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING)&&\
+    BOOST_WORKAROUND(__MWERKS__,<=0x3003)
+/* The "ISO C++ Template Parser" option in CW8.3 has a problem with the
+ * lifetime of const references bound to temporaries --precisely what
+ * scopeguards are.
+ */
+
+#pragma parse_mfunc_templ off
+#endif
+
+  typedef typename SuperMeta::type                 super;
+
+protected:
+  typedef random_access_index_node<
+    typename super::node_type>                     node_type;
+
+private:
+  typedef typename node_type::impl_type            node_impl_type;
+  typedef random_access_index_ptr_array<
+    typename super::final_allocator_type>          ptr_array;
+  typedef typename ptr_array::pointer              node_impl_ptr_pointer;
+
+public:
+  /* types */
+
+  typedef typename node_type::value_type           value_type;
+  typedef tuples::null_type                        ctor_args;
+  typedef typename super::final_allocator_type     allocator_type;
+  typedef typename allocator_type::reference       reference;
+  typedef typename allocator_type::const_reference const_reference;
+
+#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
+  typedef safe_mode::safe_iterator<
+    rnd_node_iterator<node_type>,
+    random_access_index>                           iterator;
+#else
+  typedef rnd_node_iterator<node_type>             iterator;
+#endif
+
+  typedef iterator                                 const_iterator;
+
+  typedef std::size_t                              size_type;      
+  typedef std::ptrdiff_t                           difference_type;
+  typedef typename allocator_type::pointer         pointer;
+  typedef typename allocator_type::const_pointer   const_pointer;
+  typedef typename
+    boost::reverse_iterator<iterator>              reverse_iterator;
+  typedef typename
+    boost::reverse_iterator<const_iterator>        const_reverse_iterator;
+  typedef TagList                                  tag_list;
+
+protected:
+  typedef typename super::final_node_type     final_node_type;
+  typedef tuples::cons<
+    ctor_args, 
+    typename super::ctor_args_list>           ctor_args_list;
+  typedef typename mpl::push_front<
+    typename super::index_type_list,
+    random_access_index>::type                index_type_list;
+  typedef typename mpl::push_front<
+    typename super::iterator_type_list,
+    iterator>::type                           iterator_type_list;
+  typedef typename mpl::push_front<
+    typename super::const_iterator_type_list,
+    const_iterator>::type                     const_iterator_type_list;
+  typedef typename super::copy_map_type       copy_map_type;
+
+#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
+  typedef typename super::index_saver_type    index_saver_type;
+  typedef typename super::index_loader_type   index_loader_type;
+#endif
+
+private:
+#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
+  typedef safe_mode::safe_container<
+    random_access_index>                      safe_super;
+#endif
+
+  typedef typename call_traits<
+    value_type>::param_type                   value_param_type;
+
+  /* Needed to avoid commas in BOOST_MULTI_INDEX_OVERLOADS_TO_VARTEMPL
+   * expansion.
+   */
+
+  typedef std::pair<iterator,bool>            emplace_return_type;
+
+public:
+
+  /* construct/copy/destroy
+   * Default and copy ctors are in the protected section as indices are
+   * not supposed to be created on their own. No range ctor either.
+   */
+
+  random_access_index<SuperMeta,TagList>& operator=(
+    const random_access_index<SuperMeta,TagList>& x)
+  {
+    this->final()=x.final();
+    return *this;
+  }
+
+#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
+  random_access_index<SuperMeta,TagList>& operator=(
+    std::initializer_list<value_type> list)
+  {
+    this->final()=list;
+    return *this;
+  }
+#endif
+
+  template <class InputIterator>
+  void assign(InputIterator first,InputIterator last)
+  {
+    assign_iter(first,last,mpl::not_<is_integral<InputIterator> >());
+  }
+
+#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
+  void assign(std::initializer_list<value_type> list)
+  {
+    assign(list.begin(),list.end());
+  }
+#endif
+
+  void assign(size_type n,value_param_type value)
+  {
+    BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
+    clear();
+    for(size_type i=0;i<n;++i)push_back(value);
+  }
+    
+  allocator_type get_allocator()const BOOST_NOEXCEPT
+  {
+    return this->final().get_allocator();
+  }
+
+  /* iterators */
+
+  iterator begin()BOOST_NOEXCEPT
+    {return make_iterator(node_type::from_impl(*ptrs.begin()));}
+  const_iterator begin()const BOOST_NOEXCEPT
+    {return make_iterator(node_type::from_impl(*ptrs.begin()));}
+  iterator
+    end()BOOST_NOEXCEPT{return make_iterator(header());}
+  const_iterator
+    end()const BOOST_NOEXCEPT{return make_iterator(header());}
+  reverse_iterator
+    rbegin()BOOST_NOEXCEPT{return boost::make_reverse_iterator(end());}
+  const_reverse_iterator
+    rbegin()const BOOST_NOEXCEPT{return boost::make_reverse_iterator(end());}
+  reverse_iterator
+    rend()BOOST_NOEXCEPT{return boost::make_reverse_iterator(begin());}
+  const_reverse_iterator
+    rend()const BOOST_NOEXCEPT{return boost::make_reverse_iterator(begin());}
+  const_iterator
+    cbegin()const BOOST_NOEXCEPT{return begin();}
+  const_iterator
+    cend()const BOOST_NOEXCEPT{return end();}
+  const_reverse_iterator
+    crbegin()const BOOST_NOEXCEPT{return rbegin();}
+  const_reverse_iterator
+    crend()const BOOST_NOEXCEPT{return rend();}
+
+  iterator iterator_to(const value_type& x)
+  {
+    return make_iterator(node_from_value<node_type>(&x));
+  }
+
+  const_iterator iterator_to(const value_type& x)const
+  {
+    return make_iterator(node_from_value<node_type>(&x));
+  }
+
+  /* capacity */
+
+  bool      empty()const BOOST_NOEXCEPT{return this->final_empty_();}
+  size_type size()const BOOST_NOEXCEPT{return this->final_size_();}
+  size_type max_size()const BOOST_NOEXCEPT{return this->final_max_size_();}
+  size_type capacity()const BOOST_NOEXCEPT{return ptrs.capacity();}
+
+  void reserve(size_type n)
+  {
+    BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
+    ptrs.reserve(n);
+  }
+  
+  void shrink_to_fit()
+  {
+    BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
+    ptrs.shrink_to_fit();
+  }
+
+  void resize(size_type n)
+  {
+    BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
+    if(n>size())
+      for(size_type m=n-size();m--;)
+        this->final_emplace_(BOOST_MULTI_INDEX_NULL_PARAM_PACK);
+    else if(n<size())erase(begin()+n,end());
+  }
+
+  void resize(size_type n,value_param_type x)
+  {
+    BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
+    if(n>size())for(size_type m=n-size();m--;)this->final_insert_(x); 
+    else if(n<size())erase(begin()+n,end());
+  }
+
+  /* access: no non-const versions provided as random_access_index
+   * handles const elements.
+   */
+
+  const_reference operator[](size_type n)const
+  {
+    BOOST_MULTI_INDEX_SAFE_MODE_ASSERT(n<size(),safe_mode::out_of_bounds);
+    return node_type::from_impl(*ptrs.at(n))->value();
+  }
+
+  const_reference at(size_type n)const
+  {
+    if(n>=size())throw_exception(std::out_of_range("random access index"));
+    return node_type::from_impl(*ptrs.at(n))->value();
+  }
+
+  const_reference front()const{return operator[](0);}
+  const_reference back()const{return operator[](size()-1);}
+
+  /* modifiers */
+
+  BOOST_MULTI_INDEX_OVERLOADS_TO_VARTEMPL(
+    emplace_return_type,emplace_front,emplace_front_impl)
+    
+  std::pair<iterator,bool> push_front(const value_type& x)
+                             {return insert(begin(),x);}
+  std::pair<iterator,bool> push_front(BOOST_RV_REF(value_type) x)
+                             {return insert(begin(),boost::move(x));}
+  void                     pop_front(){erase(begin());}
+
+  BOOST_MULTI_INDEX_OVERLOADS_TO_VARTEMPL(
+    emplace_return_type,emplace_back,emplace_back_impl)
+
+  std::pair<iterator,bool> push_back(const value_type& x)
+                             {return insert(end(),x);}
+  std::pair<iterator,bool> push_back(BOOST_RV_REF(value_type) x)
+                             {return insert(end(),boost::move(x));}
+  void                     pop_back(){erase(--end());}
+
+  BOOST_MULTI_INDEX_OVERLOADS_TO_VARTEMPL_EXTRA_ARG(
+    emplace_return_type,emplace,emplace_impl,iterator,position)
+    
+  std::pair<iterator,bool> insert(iterator position,const value_type& x)
+  {
+    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
+    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
+    BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
+    std::pair<final_node_type*,bool> p=this->final_insert_(x);
+    if(p.second&&position.get_node()!=header()){
+      relocate(position.get_node(),p.first);
+    }
+    return std::pair<iterator,bool>(make_iterator(p.first),p.second);
+  }
+
+  std::pair<iterator,bool> insert(iterator position,BOOST_RV_REF(value_type) x)
+  {
+    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
+    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
+    BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
+    std::pair<final_node_type*,bool> p=this->final_insert_rv_(x);
+    if(p.second&&position.get_node()!=header()){
+      relocate(position.get_node(),p.first);
+    }
+    return std::pair<iterator,bool>(make_iterator(p.first),p.second);
+  }
+
+  void insert(iterator position,size_type n,value_param_type x)
+  {
+    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
+    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
+    BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
+    size_type s=0;
+    BOOST_TRY{
+      while(n--){
+        if(push_back(x).second)++s;
+      }
+    }
+    BOOST_CATCH(...){
+      relocate(position,end()-s,end());
+      BOOST_RETHROW;
+    }
+    BOOST_CATCH_END
+    relocate(position,end()-s,end());
+  }
+ 
+  template<typename InputIterator>
+  void insert(iterator position,InputIterator first,InputIterator last)
+  {
+    insert_iter(position,first,last,mpl::not_<is_integral<InputIterator> >());
+  }
+
+#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
+  void insert(iterator position,std::initializer_list<value_type> list)
+  {
+    insert(position,list.begin(),list.end());
+  }
+#endif
+
+  iterator erase(iterator position)
+  {
+    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
+    BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(position);
+    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
+    BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
+    this->final_erase_(static_cast<final_node_type*>(position++.get_node()));
+    return position;
+  }
+  
+  iterator erase(iterator first,iterator last)
+  {
+    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(first);
+    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(last);
+    BOOST_MULTI_INDEX_CHECK_IS_OWNER(first,*this);
+    BOOST_MULTI_INDEX_CHECK_IS_OWNER(last,*this);
+    BOOST_MULTI_INDEX_CHECK_VALID_RANGE(first,last);
+    BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
+    difference_type n=last-first;
+    relocate(end(),first,last);
+    while(n--)pop_back();
+    return last;
+  }
+
+  bool replace(iterator position,const value_type& x)
+  {
+    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
+    BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(position);
+    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
+    BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
+    return this->final_replace_(
+      x,static_cast<final_node_type*>(position.get_node()));
+  }
+
+  bool replace(iterator position,BOOST_RV_REF(value_type) x)
+  {
+    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
+    BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(position);
+    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
+    BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
+    return this->final_replace_rv_(
+      x,static_cast<final_node_type*>(position.get_node()));
+  }
+
+  template<typename Modifier>
+  bool modify(iterator position,Modifier mod)
+  {
+    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
+    BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(position);
+    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
+    BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
+
+#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
+    /* MSVC++ 6.0 optimizer on safe mode code chokes if this
+     * this is not added. Left it for all compilers as it does no
+     * harm.
+     */
+
+    position.detach();
+#endif
+
+    return this->final_modify_(
+      mod,static_cast<final_node_type*>(position.get_node()));
+  }
+
+  template<typename Modifier,typename Rollback>
+  bool modify(iterator position,Modifier mod,Rollback back_)
+  {
+    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
+    BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(position);
+    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
+    BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
+
+#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
+    /* MSVC++ 6.0 optimizer on safe mode code chokes if this
+     * this is not added. Left it for all compilers as it does no
+     * harm.
+     */
+
+    position.detach();
+#endif
+
+    return this->final_modify_(
+      mod,back_,static_cast<final_node_type*>(position.get_node()));
+  }
+
+  void swap(random_access_index<SuperMeta,TagList>& x)
+  {
+    BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
+    BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT_OF(x);
+    this->final_swap_(x.final());
+  }
+
+  void clear()BOOST_NOEXCEPT
+  {
+    BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
+    this->final_clear_();
+  }
+
+  /* list operations */
+
+  void splice(iterator position,random_access_index<SuperMeta,TagList>& x)
+  {
+    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
+    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
+    BOOST_MULTI_INDEX_CHECK_DIFFERENT_CONTAINER(*this,x);
+    BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
+    iterator  first=x.begin(),last=x.end();
+    size_type n=0;
+    BOOST_TRY{
+      while(first!=last){
+        if(push_back(*first).second){
+          first=x.erase(first);
+          ++n;
+        }
+        else ++first;
+      }
+    }
+    BOOST_CATCH(...){
+      relocate(position,end()-n,end());
+      BOOST_RETHROW;
+    }
+    BOOST_CATCH_END
+    relocate(position,end()-n,end());
+  }
+
+  void splice(
+    iterator position,random_access_index<SuperMeta,TagList>& x,iterator i)
+  {
+    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
+    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
+    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(i);
+    BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(i);
+    BOOST_MULTI_INDEX_CHECK_IS_OWNER(i,x);
+    BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
+    if(&x==this)relocate(position,i);
+    else{
+      if(insert(position,*i).second){
+
+#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
+    /* MSVC++ 6.0 optimizer has a hard time with safe mode, and the following
+     * workaround is needed. Left it for all compilers as it does no
+     * harm.
+     */
+        i.detach();
+        x.erase(x.make_iterator(i.get_node()));
+#else
+        x.erase(i);
+#endif
+
+      }
+    }
+  }
+
+  void splice(
+    iterator position,random_access_index<SuperMeta,TagList>& x,
+    iterator first,iterator last)
+  {
+    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
+    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
+    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(first);
+    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(last);
+    BOOST_MULTI_INDEX_CHECK_IS_OWNER(first,x);
+    BOOST_MULTI_INDEX_CHECK_IS_OWNER(last,x);
+    BOOST_MULTI_INDEX_CHECK_VALID_RANGE(first,last);
+    BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
+    if(&x==this)relocate(position,first,last);
+    else{
+      size_type n=0;
+      BOOST_TRY{
+        while(first!=last){
+          if(push_back(*first).second){
+            first=x.erase(first);
+            ++n;
+          }
+          else ++first;
+        }
+      }
+      BOOST_CATCH(...){
+        relocate(position,end()-n,end());
+        BOOST_RETHROW;
+      }
+      BOOST_CATCH_END
+      relocate(position,end()-n,end());
+    }
+  }
+
+  void remove(value_param_type value)
+  {
+    BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
+    difference_type n=
+      end()-make_iterator(
+        random_access_index_remove<node_type>(
+          ptrs,
+          ::boost::bind(std::equal_to<value_type>(),::boost::arg<1>(),value)));
+    while(n--)pop_back();
+  }
+
+  template<typename Predicate>
+  void remove_if(Predicate pred)
+  {
+    BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
+    difference_type n=
+      end()-make_iterator(random_access_index_remove<node_type>(ptrs,pred));
+    while(n--)pop_back();
+  }
+
+  void unique()
+  {
+    BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
+    difference_type n=
+      end()-make_iterator(
+        random_access_index_unique<node_type>(
+          ptrs,std::equal_to<value_type>()));
+    while(n--)pop_back();
+  }
+
+  template <class BinaryPredicate>
+  void unique(BinaryPredicate binary_pred)
+  {
+    BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
+    difference_type n=
+      end()-make_iterator(
+        random_access_index_unique<node_type>(ptrs,binary_pred));
+    while(n--)pop_back();
+  }
+
+  void merge(random_access_index<SuperMeta,TagList>& x)
+  {
+    if(this!=&x){
+      BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
+      size_type s=size();
+      splice(end(),x);
+      random_access_index_inplace_merge<node_type>(
+        get_allocator(),ptrs,ptrs.at(s),std::less<value_type>());
+    }
+  }
+
+  template <typename Compare>
+  void merge(random_access_index<SuperMeta,TagList>& x,Compare comp)
+  {
+    if(this!=&x){
+      BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
+      size_type s=size();
+      splice(end(),x);
+      random_access_index_inplace_merge<node_type>(
+        get_allocator(),ptrs,ptrs.at(s),comp);
+    }
+  }
+
+  void sort()
+  {
+    BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
+    random_access_index_sort<node_type>(
+      get_allocator(),ptrs,std::less<value_type>());
+  }
+
+  template <typename Compare>
+  void sort(Compare comp)
+  {
+    BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
+    random_access_index_sort<node_type>(
+      get_allocator(),ptrs,comp);
+  }
+
+  void reverse()BOOST_NOEXCEPT
+  {
+    BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
+    node_impl_type::reverse(ptrs.begin(),ptrs.end());
+  }
+
+  /* rearrange operations */
+
+  void relocate(iterator position,iterator i)
+  {
+    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
+    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
+    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(i);
+    BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(i);
+    BOOST_MULTI_INDEX_CHECK_IS_OWNER(i,*this);
+    BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
+    if(position!=i)relocate(position.get_node(),i.get_node());
+  }
+
+  void relocate(iterator position,iterator first,iterator last)
+  {
+    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
+    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
+    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(first);
+    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(last);
+    BOOST_MULTI_INDEX_CHECK_IS_OWNER(first,*this);
+    BOOST_MULTI_INDEX_CHECK_IS_OWNER(last,*this);
+    BOOST_MULTI_INDEX_CHECK_VALID_RANGE(first,last);
+    BOOST_MULTI_INDEX_CHECK_OUTSIDE_RANGE(position,first,last);
+    BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
+    if(position!=last)relocate(
+      position.get_node(),first.get_node(),last.get_node());
+  }
+
+  template<typename InputIterator>
+  void rearrange(InputIterator first)
+  {
+    BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
+    for(node_impl_ptr_pointer p0=ptrs.begin(),p0_end=ptrs.end();
+        p0!=p0_end;++first,++p0){
+      const value_type& v1=*first;
+      node_impl_ptr_pointer p1=node_from_value<node_type>(&v1)->up();
+
+      std::swap(*p0,*p1);
+      (*p0)->up()=p0;
+      (*p1)->up()=p1;
+    }
+  }
+    
+BOOST_MULTI_INDEX_PROTECTED_IF_MEMBER_TEMPLATE_FRIENDS:
+  random_access_index(
+    const ctor_args_list& args_list,const allocator_type& al):
+    super(args_list.get_tail(),al),
+    ptrs(al,header()->impl(),0)
+  {
+  }
+
+  random_access_index(const random_access_index<SuperMeta,TagList>& x):
+    super(x),
+
+#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
+    safe_super(),
+#endif
+
+    ptrs(x.get_allocator(),header()->impl(),x.size())
+  {
+    /* The actual copying takes place in subsequent call to copy_().
+     */
+  }
+
+  random_access_index(
+    const random_access_index<SuperMeta,TagList>& x,do_not_copy_elements_tag):
+    super(x,do_not_copy_elements_tag()),
+
+#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
+    safe_super(),
+#endif
+
+    ptrs(x.get_allocator(),header()->impl(),0)
+  {
+  }
+
+  ~random_access_index()
+  {
+    /* the container is guaranteed to be empty by now */
+  }
+
+#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
+  iterator       make_iterator(node_type* node){return iterator(node,this);}
+  const_iterator make_iterator(node_type* node)const
+    {return const_iterator(node,const_cast<random_access_index*>(this));}
+#else
+  iterator       make_iterator(node_type* node){return iterator(node);}
+  const_iterator make_iterator(node_type* node)const
+                   {return const_iterator(node);}
+#endif
+
+  void copy_(
+    const random_access_index<SuperMeta,TagList>& x,const copy_map_type& map)
+  {
+    for(node_impl_ptr_pointer begin_org=x.ptrs.begin(),
+                              begin_cpy=ptrs.begin(),
+                              end_org=x.ptrs.end();
+        begin_org!=end_org;++begin_org,++begin_cpy){
+      *begin_cpy=
+         static_cast<node_type*>(
+           map.find(
+             static_cast<final_node_type*>(
+               node_type::from_impl(*begin_org))))->impl();
+      (*begin_cpy)->up()=begin_cpy;
+    }
+
+    super::copy_(x,map);
+  }
+
+  template<typename Variant>
+  final_node_type* insert_(
+    value_param_type v,final_node_type*& x,Variant variant)
+  {
+    ptrs.room_for_one();
+    final_node_type* res=super::insert_(v,x,variant);
+    if(res==x)ptrs.push_back(static_cast<node_type*>(x)->impl());
+    return res;
+  }
+
+  template<typename Variant>
+  final_node_type* insert_(
+    value_param_type v,node_type* position,final_node_type*& x,Variant variant)
+  {
+    ptrs.room_for_one();
+    final_node_type* res=super::insert_(v,position,x,variant);
+    if(res==x)ptrs.push_back(static_cast<node_type*>(x)->impl());
+    return res;
+  }
+
+  void erase_(node_type* x)
+  {
+    ptrs.erase(x->impl());
+    super::erase_(x);
+
+#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
+    detach_iterators(x);
+#endif
+  }
+
+  void delete_all_nodes_()
+  {
+    for(node_impl_ptr_pointer x=ptrs.begin(),x_end=ptrs.end();x!=x_end;++x){
+      this->final_delete_node_(
+        static_cast<final_node_type*>(node_type::from_impl(*x)));
+    }
+  }
+
+  void clear_()
+  {
+    super::clear_();
+    ptrs.clear();
+
+#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
+    safe_super::detach_dereferenceable_iterators();
+#endif
+  }
+
+  void swap_(random_access_index<SuperMeta,TagList>& x)
+  {
+    ptrs.swap(x.ptrs);
+
+#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
+    safe_super::swap(x);
+#endif
+
+    super::swap_(x);
+  }
+
+  void swap_elements_(random_access_index<SuperMeta,TagList>& x)
+  {
+    ptrs.swap(x.ptrs);
+
+#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
+    safe_super::swap(x);
+#endif
+
+    super::swap_elements_(x);
+  }
+
+  template<typename Variant>
+  bool replace_(value_param_type v,node_type* x,Variant variant)
+  {
+    return super::replace_(v,x,variant);
+  }
+
+  bool modify_(node_type* x)
+  {
+    BOOST_TRY{
+      if(!super::modify_(x)){
+        ptrs.erase(x->impl());
+
+#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
+        detach_iterators(x);
+#endif
+
+        return false;
+      }
+      else return true;
+    }
+    BOOST_CATCH(...){
+      ptrs.erase(x->impl());
+
+#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
+      detach_iterators(x);
+#endif
+
+      BOOST_RETHROW;
+    }
+    BOOST_CATCH_END
+  }
+
+  bool modify_rollback_(node_type* x)
+  {
+    return super::modify_rollback_(x);
+  }
+
+#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
+  /* serialization */
+
+  template<typename Archive>
+  void save_(
+    Archive& ar,const unsigned int version,const index_saver_type& sm)const
+  {
+    sm.save(begin(),end(),ar,version);
+    super::save_(ar,version,sm);
+  }
+
+  template<typename Archive>
+  void load_(
+    Archive& ar,const unsigned int version,const index_loader_type& lm)
+  {
+    {
+      typedef random_access_index_loader<node_type,allocator_type> loader;
+
+      loader ld(get_allocator(),ptrs);
+      lm.load(
+        ::boost::bind(
+          &loader::rearrange,&ld,::boost::arg<1>(),::boost::arg<2>()),
+        ar,version);
+    } /* exit scope so that ld frees its resources */
+    super::load_(ar,version,lm);
+  }
+#endif
+
+#if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING)
+  /* invariant stuff */
+
+  bool invariant_()const
+  {
+    if(size()>capacity())return false;
+    if(size()==0||begin()==end()){
+      if(size()!=0||begin()!=end())return false;
+    }
+    else{
+      size_type s=0;
+      for(const_iterator it=begin(),it_end=end();;++it,++s){
+        if(*(it.get_node()->up())!=it.get_node()->impl())return false;
+        if(it==it_end)break;
+      }
+      if(s!=size())return false;
+    }
+
+    return super::invariant_();
+  }
+
+  /* This forwarding function eases things for the boost::mem_fn construct
+   * in BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT. Actually,
+   * final_check_invariant is already an inherited member function of index.
+   */
+  void check_invariant_()const{this->final_check_invariant_();}
+#endif
+
+private:
+  node_type* header()const{return this->final_header();}
+
+  static void relocate(node_type* position,node_type* x)
+  {
+    node_impl_type::relocate(position->up(),x->up());
+  }
+
+  static void relocate(node_type* position,node_type* first,node_type* last)
+  {
+    node_impl_type::relocate(
+      position->up(),first->up(),last->up());
+  }
+
+#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
+  void detach_iterators(node_type* x)
+  {
+    iterator it=make_iterator(x);
+    safe_mode::detach_equivalent_iterators(it);
+  }
+#endif
+
+  template <class InputIterator>
+  void assign_iter(InputIterator first,InputIterator last,mpl::true_)
+  {
+    BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
+    clear();
+    for(;first!=last;++first)this->final_insert_ref_(*first);
+  }
+
+  void assign_iter(size_type n,value_param_type value,mpl::false_)
+  {
+    BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
+    clear();
+    for(size_type i=0;i<n;++i)push_back(value);
+  }
+
+  template<typename InputIterator>
+  void insert_iter(
+    iterator position,InputIterator first,InputIterator last,mpl::true_)
+  {
+    BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
+    size_type s=0;
+    BOOST_TRY{
+      for(;first!=last;++first){
+        if(this->final_insert_ref_(*first).second)++s;
+      }
+    }
+    BOOST_CATCH(...){
+      relocate(position,end()-s,end());
+      BOOST_RETHROW;
+    }
+    BOOST_CATCH_END
+    relocate(position,end()-s,end());
+  }
+
+  void insert_iter(
+    iterator position,size_type n,value_param_type x,mpl::false_)
+  {
+    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
+    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
+    BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
+    size_type  s=0;
+    BOOST_TRY{
+      while(n--){
+        if(push_back(x).second)++s;
+      }
+    }
+    BOOST_CATCH(...){
+      relocate(position,end()-s,end());
+      BOOST_RETHROW;
+    }
+    BOOST_CATCH_END
+    relocate(position,end()-s,end());
+  }
+ 
+  template<BOOST_MULTI_INDEX_TEMPLATE_PARAM_PACK>
+  std::pair<iterator,bool> emplace_front_impl(
+    BOOST_MULTI_INDEX_FUNCTION_PARAM_PACK)
+  {
+    return emplace_impl(begin(),BOOST_MULTI_INDEX_FORWARD_PARAM_PACK);
+  }
+
+  template<BOOST_MULTI_INDEX_TEMPLATE_PARAM_PACK>
+  std::pair<iterator,bool> emplace_back_impl(
+    BOOST_MULTI_INDEX_FUNCTION_PARAM_PACK)
+  {
+    return emplace_impl(end(),BOOST_MULTI_INDEX_FORWARD_PARAM_PACK);
+  }
+
+  template<BOOST_MULTI_INDEX_TEMPLATE_PARAM_PACK>
+  std::pair<iterator,bool> emplace_impl(
+    iterator position,BOOST_MULTI_INDEX_FUNCTION_PARAM_PACK)
+  {
+    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
+    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
+    BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
+    std::pair<final_node_type*,bool> p=
+      this->final_emplace_(BOOST_MULTI_INDEX_FORWARD_PARAM_PACK);
+    if(p.second&&position.get_node()!=header()){
+      relocate(position.get_node(),p.first);
+    }
+    return std::pair<iterator,bool>(make_iterator(p.first),p.second);
+  }
+
+  ptr_array ptrs;
+
+#if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING)&&\
+    BOOST_WORKAROUND(__MWERKS__,<=0x3003)
+#pragma parse_mfunc_templ reset
+#endif
+};
+
+/* comparison */
+
+template<
+  typename SuperMeta1,typename TagList1,
+  typename SuperMeta2,typename TagList2
+>
+bool operator==(
+  const random_access_index<SuperMeta1,TagList1>& x,
+  const random_access_index<SuperMeta2,TagList2>& y)
+{
+  return x.size()==y.size()&&std::equal(x.begin(),x.end(),y.begin());
+}
+
+template<
+  typename SuperMeta1,typename TagList1,
+  typename SuperMeta2,typename TagList2
+>
+bool operator<(
+  const random_access_index<SuperMeta1,TagList1>& x,
+  const random_access_index<SuperMeta2,TagList2>& y)
+{
+  return std::lexicographical_compare(x.begin(),x.end(),y.begin(),y.end());
+}
+
+template<
+  typename SuperMeta1,typename TagList1,
+  typename SuperMeta2,typename TagList2
+>
+bool operator!=(
+  const random_access_index<SuperMeta1,TagList1>& x,
+  const random_access_index<SuperMeta2,TagList2>& y)
+{
+  return !(x==y);
+}
+
+template<
+  typename SuperMeta1,typename TagList1,
+  typename SuperMeta2,typename TagList2
+>
+bool operator>(
+  const random_access_index<SuperMeta1,TagList1>& x,
+  const random_access_index<SuperMeta2,TagList2>& y)
+{
+  return y<x;
+}
+
+template<
+  typename SuperMeta1,typename TagList1,
+  typename SuperMeta2,typename TagList2
+>
+bool operator>=(
+  const random_access_index<SuperMeta1,TagList1>& x,
+  const random_access_index<SuperMeta2,TagList2>& y)
+{
+  return !(x<y);
+}
+
+template<
+  typename SuperMeta1,typename TagList1,
+  typename SuperMeta2,typename TagList2
+>
+bool operator<=(
+  const random_access_index<SuperMeta1,TagList1>& x,
+  const random_access_index<SuperMeta2,TagList2>& y)
+{
+  return !(x>y);
+}
+
+/*  specialized algorithms */
+
+template<typename SuperMeta,typename TagList>
+void swap(
+  random_access_index<SuperMeta,TagList>& x,
+  random_access_index<SuperMeta,TagList>& y)
+{
+  x.swap(y);
+}
+
+} /* namespace multi_index::detail */
+
+/* random access index specifier */
+
+template <typename TagList>
+struct random_access
+{
+  BOOST_STATIC_ASSERT(detail::is_tag<TagList>::value);
+
+  template<typename Super>
+  struct node_class
+  {
+    typedef detail::random_access_index_node<Super> type;
+  };
+
+  template<typename SuperMeta>
+  struct index_class
+  {
+    typedef detail::random_access_index<
+      SuperMeta,typename TagList::type>  type;
+  };
+};
+
+} /* namespace multi_index */
+
+} /* namespace boost */
+
+/* Boost.Foreach compatibility */
+
+template<typename SuperMeta,typename TagList>
+inline boost::mpl::true_* boost_foreach_is_noncopyable(
+  boost::multi_index::detail::random_access_index<SuperMeta,TagList>*&,
+  boost_foreach_argument_dependent_lookup_hack)
+{
+  return 0;
+}
+
+#undef BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT
+#undef BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT_OF
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/random_access_index_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/random_access_index_fwd.hpp
new file mode 100644
index 00000000000..2ea19295426
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/multi_index/random_access_index_fwd.hpp
@@ -0,0 +1,91 @@
+/* Copyright 2003-2013 Joaquin M Lopez Munoz.
+ * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
+ */
+
+#ifndef BOOST_MULTI_INDEX_RANDOM_ACCESS_INDEX_FWD_HPP
+#define BOOST_MULTI_INDEX_RANDOM_ACCESS_INDEX_FWD_HPP
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/multi_index/tag.hpp>
+
+namespace boost{
+
+namespace multi_index{
+
+namespace detail{
+
+template<typename SuperMeta,typename TagList>
+class random_access_index;
+
+template<
+  typename SuperMeta1,typename TagList1,
+  typename SuperMeta2,typename TagList2
+>
+bool operator==(
+  const random_access_index<SuperMeta1,TagList1>& x,
+  const random_access_index<SuperMeta2,TagList2>& y);
+
+template<
+  typename SuperMeta1,typename TagList1,
+  typename SuperMeta2,typename TagList2
+>
+bool operator<(
+  const random_access_index<SuperMeta1,TagList1>& x,
+  const random_access_index<SuperMeta2,TagList2>& y);
+
+template<
+  typename SuperMeta1,typename TagList1,
+  typename SuperMeta2,typename TagList2
+>
+bool operator!=(
+  const random_access_index<SuperMeta1,TagList1>& x,
+  const random_access_index<SuperMeta2,TagList2>& y);
+
+template<
+  typename SuperMeta1,typename TagList1,
+  typename SuperMeta2,typename TagList2
+>
+bool operator>(
+  const random_access_index<SuperMeta1,TagList1>& x,
+  const random_access_index<SuperMeta2,TagList2>& y);
+
+template<
+  typename SuperMeta1,typename TagList1,
+  typename SuperMeta2,typename TagList2
+>
+bool operator>=(
+  const random_access_index<SuperMeta1,TagList1>& x,
+  const random_access_index<SuperMeta2,TagList2>& y);
+
+template<
+  typename SuperMeta1,typename TagList1,
+  typename SuperMeta2,typename TagList2
+>
+bool operator<=(
+  const random_access_index<SuperMeta1,TagList1>& x,
+  const random_access_index<SuperMeta2,TagList2>& y);
+
+template<typename SuperMeta,typename TagList>
+void swap(
+  random_access_index<SuperMeta,TagList>& x,
+  random_access_index<SuperMeta,TagList>& y);
+
+} /* namespace multi_index::detail */
+
+/* index specifiers */
+
+template <typename TagList=tag<> >
+struct random_access;
+
+} /* namespace multi_index */
+
+} /* namespace boost */
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/ranked_index.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/ranked_index.hpp
new file mode 100644
index 00000000000..4b24c4f5937
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/multi_index/ranked_index.hpp
@@ -0,0 +1,382 @@
+/* Copyright 2003-2017 Joaquin M Lopez Munoz.
+ * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
+ */
+
+#ifndef BOOST_MULTI_INDEX_RANKED_INDEX_HPP
+#define BOOST_MULTI_INDEX_RANKED_INDEX_HPP
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
+#include <boost/multi_index/detail/ord_index_impl.hpp>
+#include <boost/multi_index/detail/rnk_index_ops.hpp>
+#include <boost/multi_index/ranked_index_fwd.hpp>
+
+namespace boost{
+
+namespace multi_index{
+
+namespace detail{
+
+/* ranked_index augments a given ordered index to provide rank operations */
+
+template<typename OrderedIndexNodeImpl>
+struct ranked_node:OrderedIndexNodeImpl
+{
+  std::size_t size;
+};
+
+template<typename OrderedIndexImpl>
+class ranked_index:public OrderedIndexImpl
+{
+  typedef          OrderedIndexImpl         super;
+
+protected:
+  typedef typename super::node_type         node_type;
+  typedef typename super::node_impl_pointer node_impl_pointer;
+
+public:
+  typedef typename super::ctor_args_list ctor_args_list;
+  typedef typename super::allocator_type allocator_type;
+  typedef typename super::iterator       iterator;
+
+  /* rank operations */
+
+  iterator nth(std::size_t n)const
+  {
+    return this->make_iterator(node_type::from_impl(
+      ranked_index_nth(n,this->header()->impl())));
+  }
+
+  std::size_t rank(iterator position)const
+  {
+    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
+    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
+
+    return ranked_index_rank(
+      position.get_node()->impl(),this->header()->impl());
+  }
+
+  template<typename CompatibleKey>
+  std::size_t find_rank(const CompatibleKey& x)const
+  {
+    return ranked_index_find_rank(
+      this->root(),this->header(),this->key,x,this->comp_);
+  }
+
+  template<typename CompatibleKey,typename CompatibleCompare>
+  std::size_t find_rank(
+    const CompatibleKey& x,const CompatibleCompare& comp)const
+  {
+    return ranked_index_find_rank(
+      this->root(),this->header(),this->key,x,comp);
+  }
+
+  template<typename CompatibleKey>
+  std::size_t lower_bound_rank(const CompatibleKey& x)const
+  {
+    return ranked_index_lower_bound_rank(
+      this->root(),this->header(),this->key,x,this->comp_);
+  }
+
+  template<typename CompatibleKey,typename CompatibleCompare>
+  std::size_t lower_bound_rank(
+    const CompatibleKey& x,const CompatibleCompare& comp)const
+  {
+    return ranked_index_lower_bound_rank(
+      this->root(),this->header(),this->key,x,comp);
+  }
+
+  template<typename CompatibleKey>
+  std::size_t upper_bound_rank(const CompatibleKey& x)const
+  {
+    return ranked_index_upper_bound_rank(
+      this->root(),this->header(),this->key,x,this->comp_);
+  }
+
+  template<typename CompatibleKey,typename CompatibleCompare>
+  std::size_t upper_bound_rank(
+    const CompatibleKey& x,const CompatibleCompare& comp)const
+  {
+    return ranked_index_upper_bound_rank(
+      this->root(),this->header(),this->key,x,comp);
+  }
+
+  template<typename CompatibleKey>
+  std::pair<std::size_t,std::size_t> equal_range_rank(
+    const CompatibleKey& x)const
+  {
+    return ranked_index_equal_range_rank(
+      this->root(),this->header(),this->key,x,this->comp_);
+  }
+
+  template<typename CompatibleKey,typename CompatibleCompare>
+  std::pair<std::size_t,std::size_t> equal_range_rank(
+    const CompatibleKey& x,const CompatibleCompare& comp)const
+  {
+    return ranked_index_equal_range_rank(
+      this->root(),this->header(),this->key,x,comp);
+  }
+
+  template<typename LowerBounder,typename UpperBounder>
+  std::pair<std::size_t,std::size_t>
+  range_rank(LowerBounder lower,UpperBounder upper)const
+  {
+    typedef typename mpl::if_<
+      is_same<LowerBounder,unbounded_type>,
+      BOOST_DEDUCED_TYPENAME mpl::if_<
+        is_same<UpperBounder,unbounded_type>,
+        both_unbounded_tag,
+        lower_unbounded_tag
+      >::type,
+      BOOST_DEDUCED_TYPENAME mpl::if_<
+        is_same<UpperBounder,unbounded_type>,
+        upper_unbounded_tag,
+        none_unbounded_tag
+      >::type
+    >::type dispatch;
+
+    return range_rank(lower,upper,dispatch());
+  }
+
+protected:
+  ranked_index(const ranked_index& x):super(x){};
+
+  ranked_index(const ranked_index& x,do_not_copy_elements_tag):
+    super(x,do_not_copy_elements_tag()){};
+
+  ranked_index(
+    const ctor_args_list& args_list,const allocator_type& al):
+    super(args_list,al){}
+
+private:
+  template<typename LowerBounder,typename UpperBounder>
+  std::pair<std::size_t,std::size_t>
+  range_rank(LowerBounder lower,UpperBounder upper,none_unbounded_tag)const
+  {
+    node_type* y=this->header();
+    node_type* z=this->root();
+
+    if(!z)return std::pair<std::size_t,std::size_t>(0,0);
+
+    std::size_t s=z->impl()->size;
+
+    do{
+      if(!lower(this->key(z->value()))){
+        z=node_type::from_impl(z->right());
+      }
+      else if(!upper(this->key(z->value()))){
+        y=z;
+        s-=ranked_node_size(y->right())+1;
+        z=node_type::from_impl(z->left());
+      }
+      else{
+        return std::pair<std::size_t,std::size_t>(
+          s-z->impl()->size+
+            lower_range_rank(node_type::from_impl(z->left()),z,lower),
+          s-ranked_node_size(z->right())+
+            upper_range_rank(node_type::from_impl(z->right()),y,upper));
+      }
+    }while(z);
+
+    return std::pair<std::size_t,std::size_t>(s,s);
+  }
+
+  template<typename LowerBounder,typename UpperBounder>
+  std::pair<std::size_t,std::size_t>
+  range_rank(LowerBounder,UpperBounder upper,lower_unbounded_tag)const
+  {
+    return std::pair<std::size_t,std::size_t>(
+      0,
+      upper_range_rank(this->root(),this->header(),upper));
+  }
+
+  template<typename LowerBounder,typename UpperBounder>
+  std::pair<std::size_t,std::size_t>
+  range_rank(LowerBounder lower,UpperBounder,upper_unbounded_tag)const
+  {
+    return std::pair<std::size_t,std::size_t>(
+      lower_range_rank(this->root(),this->header(),lower),
+      this->size());
+  }
+
+  template<typename LowerBounder,typename UpperBounder>
+  std::pair<std::size_t,std::size_t>
+  range_rank(LowerBounder,UpperBounder,both_unbounded_tag)const
+  {
+    return std::pair<std::size_t,std::size_t>(0,this->size());
+  }
+
+  template<typename LowerBounder>
+  std::size_t
+  lower_range_rank(node_type* top,node_type* y,LowerBounder lower)const
+  {
+    if(!top)return 0;
+
+    std::size_t s=top->impl()->size;
+
+    do{
+      if(lower(this->key(top->value()))){
+        y=top;
+        s-=ranked_node_size(y->right())+1;
+        top=node_type::from_impl(top->left());
+      }
+      else top=node_type::from_impl(top->right());
+    }while(top);
+
+    return s;
+  }
+
+  template<typename UpperBounder>
+  std::size_t
+  upper_range_rank(node_type* top,node_type* y,UpperBounder upper)const
+  {
+    if(!top)return 0;
+
+    std::size_t s=top->impl()->size;
+
+    do{
+      if(!upper(this->key(top->value()))){
+        y=top;
+        s-=ranked_node_size(y->right())+1;
+        top=node_type::from_impl(top->left());
+      }
+      else top=node_type::from_impl(top->right());
+    }while(top);
+
+    return s;
+  }
+};
+
+/* augmenting policy for ordered_index */
+
+struct rank_policy
+{
+  template<typename OrderedIndexNodeImpl>
+  struct augmented_node
+  {
+    typedef ranked_node<OrderedIndexNodeImpl> type;
+  };
+
+  template<typename OrderedIndexImpl>
+  struct augmented_interface
+  {
+    typedef ranked_index<OrderedIndexImpl> type;
+  };
+
+  /* algorithmic stuff */
+
+  template<typename Pointer>
+  static void add(Pointer x,Pointer root)
+  {
+    x->size=1;
+    while(x!=root){
+      x=x->parent();
+      ++(x->size);
+    }
+  }
+
+  template<typename Pointer>
+  static void remove(Pointer x,Pointer root)
+  {
+    while(x!=root){
+      x=x->parent();
+      --(x->size);
+    }
+  }
+
+  template<typename Pointer>
+  static void copy(Pointer x,Pointer y)
+  {
+    y->size=x->size;
+  }
+
+  template<typename Pointer>
+  static void rotate_left(Pointer x,Pointer y) /* in: x==y->left() */
+  {
+    y->size=x->size;
+    x->size=ranked_node_size(x->left())+ranked_node_size(x->right())+1;
+  }
+
+  template<typename Pointer>
+  static void rotate_right(Pointer x,Pointer y) /* in: x==y->right() */
+  {
+    rotate_left(x,y);
+  }
+
+#if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING)
+  /* invariant stuff */
+
+  template<typename Pointer>
+  static bool invariant(Pointer x)
+  {
+    return x->size==ranked_node_size(x->left())+ranked_node_size(x->right())+1;
+  }
+#endif
+};
+
+} /* namespace multi_index::detail */
+
+/* ranked_index specifiers */
+
+template<typename Arg1,typename Arg2,typename Arg3>
+struct ranked_unique
+{
+  typedef typename detail::ordered_index_args<
+    Arg1,Arg2,Arg3>                                index_args;
+  typedef typename index_args::tag_list_type::type tag_list_type;
+  typedef typename index_args::key_from_value_type key_from_value_type;
+  typedef typename index_args::compare_type        compare_type;
+
+  template<typename Super>
+  struct node_class
+  {
+    typedef detail::ordered_index_node<detail::rank_policy,Super> type;
+  };
+
+  template<typename SuperMeta>
+  struct index_class
+  {
+    typedef detail::ordered_index<
+      key_from_value_type,compare_type,
+      SuperMeta,tag_list_type,detail::ordered_unique_tag,
+      detail::rank_policy>                                type;
+  };
+};
+
+template<typename Arg1,typename Arg2,typename Arg3>
+struct ranked_non_unique
+{
+  typedef detail::ordered_index_args<
+    Arg1,Arg2,Arg3>                                index_args;
+  typedef typename index_args::tag_list_type::type tag_list_type;
+  typedef typename index_args::key_from_value_type key_from_value_type;
+  typedef typename index_args::compare_type        compare_type;
+
+  template<typename Super>
+  struct node_class
+  {
+    typedef detail::ordered_index_node<detail::rank_policy,Super> type;
+  };
+
+  template<typename SuperMeta>
+  struct index_class
+  {
+    typedef detail::ordered_index<
+      key_from_value_type,compare_type,
+      SuperMeta,tag_list_type,detail::ordered_non_unique_tag,
+      detail::rank_policy>                                    type;
+  };
+};
+
+} /* namespace multi_index */
+
+} /* namespace boost */
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/ranked_index_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/ranked_index_fwd.hpp
new file mode 100644
index 00000000000..380d3480736
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/multi_index/ranked_index_fwd.hpp
@@ -0,0 +1,35 @@
+/* Copyright 2003-2015 Joaquin M Lopez Munoz.
+ * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
+ */
+
+#ifndef BOOST_MULTI_INDEX_RANKED_INDEX_FWD_HPP
+#define BOOST_MULTI_INDEX_RANKED_INDEX_FWD_HPP
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/multi_index/detail/ord_index_args.hpp>
+#include <boost/multi_index/detail/ord_index_impl_fwd.hpp>
+
+namespace boost{
+
+namespace multi_index{
+
+/* ranked_index specifiers */
+
+template<typename Arg1,typename Arg2=mpl::na,typename Arg3=mpl::na>
+struct ranked_unique;
+
+template<typename Arg1,typename Arg2=mpl::na,typename Arg3=mpl::na>
+struct ranked_non_unique;
+
+} /* namespace multi_index */
+
+} /* namespace boost */
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/safe_mode_errors.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/safe_mode_errors.hpp
new file mode 100644
index 00000000000..1904706edec
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/multi_index/safe_mode_errors.hpp
@@ -0,0 +1,48 @@
+/* Copyright 2003-2013 Joaquin M Lopez Munoz.
+ * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
+ */
+
+#ifndef BOOST_MULTI_INDEX_SAFE_MODE_ERRORS_HPP
+#define BOOST_MULTI_INDEX_SAFE_MODE_ERRORS_HPP
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+namespace boost{
+
+namespace multi_index{
+
+namespace safe_mode{
+
+/* Error codes for Boost.MultiIndex safe mode. These go in a separate
+ * header so that the user can include it when redefining
+ * BOOST_MULTI_INDEX_SAFE_MODE_ASSERT prior to the inclusion of
+ * any other header of Boost.MultiIndex.
+ */
+
+enum error_code
+{
+  invalid_iterator=0,
+  not_dereferenceable_iterator,
+  not_incrementable_iterator,
+  not_decrementable_iterator,
+  not_owner,
+  not_same_owner,
+  invalid_range,
+  inside_range,
+  out_of_bounds,
+  same_container
+};
+
+} /* namespace multi_index::safe_mode */
+
+} /* namespace multi_index */
+
+} /* namespace boost */
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/sequenced_index.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/sequenced_index.hpp
new file mode 100644
index 00000000000..424eebc376d
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/multi_index/sequenced_index.hpp
@@ -0,0 +1,1062 @@
+/* Copyright 2003-2015 Joaquin M Lopez Munoz.
+ * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
+ */
+
+#ifndef BOOST_MULTI_INDEX_SEQUENCED_INDEX_HPP
+#define BOOST_MULTI_INDEX_SEQUENCED_INDEX_HPP
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
+#include <boost/bind.hpp>
+#include <boost/call_traits.hpp>
+#include <boost/detail/allocator_utilities.hpp>
+#include <boost/detail/no_exceptions_support.hpp>
+#include <boost/detail/workaround.hpp>
+#include <boost/foreach_fwd.hpp>
+#include <boost/iterator/reverse_iterator.hpp>
+#include <boost/move/core.hpp>
+#include <boost/move/utility.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/mpl/not.hpp>
+#include <boost/mpl/push_front.hpp>
+#include <boost/multi_index/detail/access_specifier.hpp>
+#include <boost/multi_index/detail/bidir_node_iterator.hpp>
+#include <boost/multi_index/detail/do_not_copy_elements_tag.hpp>
+#include <boost/multi_index/detail/index_node_base.hpp>
+#include <boost/multi_index/detail/safe_mode.hpp>
+#include <boost/multi_index/detail/scope_guard.hpp>
+#include <boost/multi_index/detail/seq_index_node.hpp>
+#include <boost/multi_index/detail/seq_index_ops.hpp>
+#include <boost/multi_index/detail/vartempl_support.hpp>
+#include <boost/multi_index/sequenced_index_fwd.hpp>
+#include <boost/tuple/tuple.hpp>
+#include <boost/type_traits/is_integral.hpp>
+#include <cstddef>
+#include <functional>
+#include <utility>
+
+#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
+#include<initializer_list>
+#endif
+
+#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
+#include <boost/bind.hpp>
+#endif
+
+#if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING)
+#define BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT_OF(x)                    \
+  detail::scope_guard BOOST_JOIN(check_invariant_,__LINE__)=                 \
+    detail::make_obj_guard(x,&sequenced_index::check_invariant_);            \
+  BOOST_JOIN(check_invariant_,__LINE__).touch();
+#define BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT                          \
+  BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT_OF(*this)
+#else
+#define BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT_OF(x)
+#define BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT
+#endif
+
+namespace boost{
+
+namespace multi_index{
+
+namespace detail{
+
+/* sequenced_index adds a layer of sequenced indexing to a given Super */
+
+template<typename SuperMeta,typename TagList>
+class sequenced_index:
+  BOOST_MULTI_INDEX_PROTECTED_IF_MEMBER_TEMPLATE_FRIENDS SuperMeta::type
+
+#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
+  ,public safe_mode::safe_container<
+    sequenced_index<SuperMeta,TagList> >
+#endif
+
+{ 
+#if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING)&&\
+    BOOST_WORKAROUND(__MWERKS__,<=0x3003)
+/* The "ISO C++ Template Parser" option in CW8.3 has a problem with the
+ * lifetime of const references bound to temporaries --precisely what
+ * scopeguards are.
+ */
+
+#pragma parse_mfunc_templ off
+#endif
+
+  typedef typename SuperMeta::type                    super;
+
+protected:
+  typedef sequenced_index_node<
+    typename super::node_type>                        node_type;
+
+private:
+  typedef typename node_type::impl_type               node_impl_type;
+ 
+public:
+  /* types */
+
+  typedef typename node_type::value_type              value_type;
+  typedef tuples::null_type                           ctor_args;
+  typedef typename super::final_allocator_type        allocator_type;
+  typedef typename allocator_type::reference          reference;
+  typedef typename allocator_type::const_reference    const_reference;
+
+#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
+  typedef safe_mode::safe_iterator<
+    bidir_node_iterator<node_type>,
+    sequenced_index>                                  iterator;
+#else
+  typedef bidir_node_iterator<node_type>              iterator;
+#endif
+
+  typedef iterator                                    const_iterator;
+
+  typedef std::size_t                                 size_type;      
+  typedef std::ptrdiff_t                              difference_type;
+  typedef typename allocator_type::pointer            pointer;
+  typedef typename allocator_type::const_pointer      const_pointer;
+  typedef typename
+    boost::reverse_iterator<iterator>                 reverse_iterator;
+  typedef typename
+    boost::reverse_iterator<const_iterator>           const_reverse_iterator;
+  typedef TagList                                     tag_list;
+
+protected:
+  typedef typename super::final_node_type     final_node_type;
+  typedef tuples::cons<
+    ctor_args, 
+    typename super::ctor_args_list>           ctor_args_list;
+  typedef typename mpl::push_front<
+    typename super::index_type_list,
+    sequenced_index>::type                    index_type_list;
+  typedef typename mpl::push_front<
+    typename super::iterator_type_list,
+    iterator>::type                           iterator_type_list;
+  typedef typename mpl::push_front<
+    typename super::const_iterator_type_list,
+    const_iterator>::type                     const_iterator_type_list;
+  typedef typename super::copy_map_type       copy_map_type;
+
+#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
+  typedef typename super::index_saver_type    index_saver_type;
+  typedef typename super::index_loader_type   index_loader_type;
+#endif
+
+private:
+#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
+  typedef safe_mode::safe_container<
+    sequenced_index>                          safe_super;
+#endif
+
+  typedef typename call_traits<value_type>::param_type value_param_type;
+
+  /* Needed to avoid commas in BOOST_MULTI_INDEX_OVERLOADS_TO_VARTEMPL
+   * expansion.
+   */
+
+  typedef std::pair<iterator,bool>                     emplace_return_type;
+
+public:
+
+  /* construct/copy/destroy
+   * Default and copy ctors are in the protected section as indices are
+   * not supposed to be created on their own. No range ctor either.
+   */
+
+  sequenced_index<SuperMeta,TagList>& operator=(
+    const sequenced_index<SuperMeta,TagList>& x)
+  {
+    this->final()=x.final();
+    return *this;
+  }
+
+#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
+  sequenced_index<SuperMeta,TagList>& operator=(
+    std::initializer_list<value_type> list)
+  {
+    this->final()=list;
+    return *this;
+  }
+#endif
+
+  template <class InputIterator>
+  void assign(InputIterator first,InputIterator last)
+  {
+    assign_iter(first,last,mpl::not_<is_integral<InputIterator> >());
+  }
+
+#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
+  void assign(std::initializer_list<value_type> list)
+  {
+    assign(list.begin(),list.end());
+  }
+#endif
+
+  void assign(size_type n,value_param_type value)
+  {
+    BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT;
+    clear();
+    for(size_type i=0;i<n;++i)push_back(value);
+  }
+    
+  allocator_type get_allocator()const BOOST_NOEXCEPT
+  {
+    return this->final().get_allocator();
+  }
+
+  /* iterators */
+
+  iterator  begin()BOOST_NOEXCEPT
+    {return make_iterator(node_type::from_impl(header()->next()));}
+  const_iterator begin()const BOOST_NOEXCEPT
+    {return make_iterator(node_type::from_impl(header()->next()));}
+  iterator
+    end()BOOST_NOEXCEPT{return make_iterator(header());}
+  const_iterator
+    end()const BOOST_NOEXCEPT{return make_iterator(header());}
+  reverse_iterator
+    rbegin()BOOST_NOEXCEPT{return boost::make_reverse_iterator(end());}
+  const_reverse_iterator
+    rbegin()const BOOST_NOEXCEPT{return boost::make_reverse_iterator(end());}
+  reverse_iterator
+    rend()BOOST_NOEXCEPT{return boost::make_reverse_iterator(begin());}
+  const_reverse_iterator
+    rend()const BOOST_NOEXCEPT{return boost::make_reverse_iterator(begin());}
+  const_iterator
+    cbegin()const BOOST_NOEXCEPT{return begin();}
+  const_iterator
+    cend()const BOOST_NOEXCEPT{return end();}
+  const_reverse_iterator
+    crbegin()const BOOST_NOEXCEPT{return rbegin();}
+  const_reverse_iterator
+    crend()const BOOST_NOEXCEPT{return rend();}
+
+  iterator iterator_to(const value_type& x)
+  {
+    return make_iterator(node_from_value<node_type>(&x));
+  }
+
+  const_iterator iterator_to(const value_type& x)const
+  {
+    return make_iterator(node_from_value<node_type>(&x));
+  }
+
+  /* capacity */
+
+  bool      empty()const BOOST_NOEXCEPT{return this->final_empty_();}
+  size_type size()const BOOST_NOEXCEPT{return this->final_size_();}
+  size_type max_size()const BOOST_NOEXCEPT{return this->final_max_size_();}
+
+  void resize(size_type n)
+  {
+    BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT;
+    if(n>size()){
+      for(size_type m=n-size();m--;)
+        this->final_emplace_(BOOST_MULTI_INDEX_NULL_PARAM_PACK);
+    }
+    else if(n<size()){for(size_type m=size()-n;m--;)pop_back();}
+  }
+
+  void resize(size_type n,value_param_type x)
+  {
+    BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT;
+    if(n>size())insert(end(),n-size(),x);
+    else if(n<size())for(size_type m=size()-n;m--;)pop_back();
+  }
+
+  /* access: no non-const versions provided as sequenced_index
+   * handles const elements.
+   */
+
+  const_reference front()const{return *begin();}
+  const_reference back()const{return *--end();}
+
+  /* modifiers */
+
+  BOOST_MULTI_INDEX_OVERLOADS_TO_VARTEMPL(
+    emplace_return_type,emplace_front,emplace_front_impl)
+
+  std::pair<iterator,bool> push_front(const value_type& x)
+                             {return insert(begin(),x);}
+  std::pair<iterator,bool> push_front(BOOST_RV_REF(value_type) x)
+                             {return insert(begin(),boost::move(x));}
+  void                     pop_front(){erase(begin());}
+
+  BOOST_MULTI_INDEX_OVERLOADS_TO_VARTEMPL(
+    emplace_return_type,emplace_back,emplace_back_impl)
+
+  std::pair<iterator,bool> push_back(const value_type& x)
+                             {return insert(end(),x);}
+  std::pair<iterator,bool> push_back(BOOST_RV_REF(value_type) x)
+                             {return insert(end(),boost::move(x));}
+  void                     pop_back(){erase(--end());}
+
+  BOOST_MULTI_INDEX_OVERLOADS_TO_VARTEMPL_EXTRA_ARG(
+    emplace_return_type,emplace,emplace_impl,iterator,position)
+
+  std::pair<iterator,bool> insert(iterator position,const value_type& x)
+  {
+    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
+    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
+    BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT;
+    std::pair<final_node_type*,bool> p=this->final_insert_(x);
+    if(p.second&&position.get_node()!=header()){
+      relink(position.get_node(),p.first);
+    }
+    return std::pair<iterator,bool>(make_iterator(p.first),p.second);
+  }
+
+  std::pair<iterator,bool> insert(iterator position,BOOST_RV_REF(value_type) x)
+  {
+    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
+    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
+    BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT;
+    std::pair<final_node_type*,bool> p=this->final_insert_rv_(x);
+    if(p.second&&position.get_node()!=header()){
+      relink(position.get_node(),p.first);
+    }
+    return std::pair<iterator,bool>(make_iterator(p.first),p.second);
+  }
+
+  void insert(iterator position,size_type n,value_param_type x)
+  {
+    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
+    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
+    BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT;
+    for(size_type i=0;i<n;++i)insert(position,x);
+  }
+ 
+  template<typename InputIterator>
+  void insert(iterator position,InputIterator first,InputIterator last)
+  {
+    insert_iter(position,first,last,mpl::not_<is_integral<InputIterator> >());
+  }
+
+#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
+  void insert(iterator position,std::initializer_list<value_type> list)
+  {
+    insert(position,list.begin(),list.end());
+  }
+#endif
+
+  iterator erase(iterator position)
+  {
+    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
+    BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(position);
+    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
+    BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT;
+    this->final_erase_(static_cast<final_node_type*>(position++.get_node()));
+    return position;
+  }
+  
+  iterator erase(iterator first,iterator last)
+  {
+    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(first);
+    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(last);
+    BOOST_MULTI_INDEX_CHECK_IS_OWNER(first,*this);
+    BOOST_MULTI_INDEX_CHECK_IS_OWNER(last,*this);
+    BOOST_MULTI_INDEX_CHECK_VALID_RANGE(first,last);
+    BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT;
+    while(first!=last){
+      first=erase(first);
+    }
+    return first;
+  }
+
+  bool replace(iterator position,const value_type& x)
+  {
+    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
+    BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(position);
+    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
+    BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT;
+    return this->final_replace_(
+      x,static_cast<final_node_type*>(position.get_node()));
+  }
+
+  bool replace(iterator position,BOOST_RV_REF(value_type) x)
+  {
+    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
+    BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(position);
+    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
+    BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT;
+    return this->final_replace_rv_(
+      x,static_cast<final_node_type*>(position.get_node()));
+  }
+
+  template<typename Modifier>
+  bool modify(iterator position,Modifier mod)
+  {
+    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
+    BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(position);
+    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
+    BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT;
+
+#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
+    /* MSVC++ 6.0 optimizer on safe mode code chokes if this
+     * this is not added. Left it for all compilers as it does no
+     * harm.
+     */
+
+    position.detach();
+#endif
+
+    return this->final_modify_(
+      mod,static_cast<final_node_type*>(position.get_node()));
+  }
+
+  template<typename Modifier,typename Rollback>
+  bool modify(iterator position,Modifier mod,Rollback back_)
+  {
+    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
+    BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(position);
+    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
+    BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT;
+
+#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
+    /* MSVC++ 6.0 optimizer on safe mode code chokes if this
+     * this is not added. Left it for all compilers as it does no
+     * harm.
+     */
+
+    position.detach();
+#endif
+
+    return this->final_modify_(
+      mod,back_,static_cast<final_node_type*>(position.get_node()));
+  }
+
+  void swap(sequenced_index<SuperMeta,TagList>& x)
+  {
+    BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT;
+    BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT_OF(x);
+    this->final_swap_(x.final());
+  }
+
+  void clear()BOOST_NOEXCEPT
+  {
+    BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT;
+    this->final_clear_();
+  }
+
+  /* list operations */
+
+  void splice(iterator position,sequenced_index<SuperMeta,TagList>& x)
+  {
+    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
+    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
+    BOOST_MULTI_INDEX_CHECK_DIFFERENT_CONTAINER(*this,x);
+    BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT;
+    iterator first=x.begin(),last=x.end();
+    while(first!=last){
+      if(insert(position,*first).second)first=x.erase(first);
+      else ++first;
+    }
+  }
+
+  void splice(iterator position,sequenced_index<SuperMeta,TagList>& x,iterator i)
+  {
+    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
+    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
+    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(i);
+    BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(i);
+    BOOST_MULTI_INDEX_CHECK_IS_OWNER(i,x);
+    BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT;
+    if(&x==this){
+      if(position!=i)relink(position.get_node(),i.get_node());
+    }
+    else{
+      if(insert(position,*i).second){
+
+#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
+    /* MSVC++ 6.0 optimizer has a hard time with safe mode, and the following
+     * workaround is needed. Left it for all compilers as it does no
+     * harm.
+     */
+        i.detach();
+        x.erase(x.make_iterator(i.get_node()));
+#else
+        x.erase(i);
+#endif
+
+      }
+    }
+  }
+
+  void splice(
+    iterator position,sequenced_index<SuperMeta,TagList>& x,
+    iterator first,iterator last)
+  {
+    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
+    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
+    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(first);
+    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(last);
+    BOOST_MULTI_INDEX_CHECK_IS_OWNER(first,x);
+    BOOST_MULTI_INDEX_CHECK_IS_OWNER(last,x);
+    BOOST_MULTI_INDEX_CHECK_VALID_RANGE(first,last);
+    BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT;
+    if(&x==this){
+      BOOST_MULTI_INDEX_CHECK_OUTSIDE_RANGE(position,first,last);
+      if(position!=last)relink(
+        position.get_node(),first.get_node(),last.get_node());
+    }
+    else{
+      while(first!=last){
+        if(insert(position,*first).second)first=x.erase(first);
+        else ++first;
+      }
+    }
+  }
+
+  void remove(value_param_type value)
+  {
+    sequenced_index_remove(
+      *this,
+      ::boost::bind(std::equal_to<value_type>(),::boost::arg<1>(),value));
+  }
+
+  template<typename Predicate>
+  void remove_if(Predicate pred)
+  {
+    sequenced_index_remove(*this,pred);
+  }
+
+  void unique()
+  {
+    sequenced_index_unique(*this,std::equal_to<value_type>());
+  }
+
+  template <class BinaryPredicate>
+  void unique(BinaryPredicate binary_pred)
+  {
+    sequenced_index_unique(*this,binary_pred);
+  }
+
+  void merge(sequenced_index<SuperMeta,TagList>& x)
+  {
+    sequenced_index_merge(*this,x,std::less<value_type>());
+  }
+
+  template <typename Compare>
+  void merge(sequenced_index<SuperMeta,TagList>& x,Compare comp)
+  {
+    sequenced_index_merge(*this,x,comp);
+  }
+
+  void sort()
+  {
+    BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT;
+    sequenced_index_sort(header(),std::less<value_type>());
+  }
+
+  template <typename Compare>
+  void sort(Compare comp)
+  {
+    BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT;
+    sequenced_index_sort(header(),comp);
+  }
+
+  void reverse()BOOST_NOEXCEPT
+  {
+    BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT;
+    node_impl_type::reverse(header()->impl());
+  }
+
+  /* rearrange operations */
+
+  void relocate(iterator position,iterator i)
+  {
+    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
+    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
+    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(i);
+    BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(i);
+    BOOST_MULTI_INDEX_CHECK_IS_OWNER(i,*this);
+    BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT;
+    if(position!=i)relink(position.get_node(),i.get_node());
+  }
+
+  void relocate(iterator position,iterator first,iterator last)
+  {
+    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
+    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
+    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(first);
+    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(last);
+    BOOST_MULTI_INDEX_CHECK_IS_OWNER(first,*this);
+    BOOST_MULTI_INDEX_CHECK_IS_OWNER(last,*this);
+    BOOST_MULTI_INDEX_CHECK_VALID_RANGE(first,last);
+    BOOST_MULTI_INDEX_CHECK_OUTSIDE_RANGE(position,first,last);
+    BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT;
+    if(position!=last)relink(
+      position.get_node(),first.get_node(),last.get_node());
+  }
+    
+  template<typename InputIterator>
+  void rearrange(InputIterator first)
+  {
+    BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT;
+    node_type* pos=header();
+    for(size_type s=size();s--;){
+      const value_type& v=*first++;
+      relink(pos,node_from_value<node_type>(&v));
+    }
+  }
+
+BOOST_MULTI_INDEX_PROTECTED_IF_MEMBER_TEMPLATE_FRIENDS:
+  sequenced_index(const ctor_args_list& args_list,const allocator_type& al):
+    super(args_list.get_tail(),al)
+  {
+    empty_initialize();
+  }
+
+  sequenced_index(const sequenced_index<SuperMeta,TagList>& x):
+    super(x)
+
+#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
+    ,safe_super()
+#endif
+
+  {
+    /* the actual copying takes place in subsequent call to copy_() */
+  }
+
+  sequenced_index(
+    const sequenced_index<SuperMeta,TagList>& x,do_not_copy_elements_tag):
+    super(x,do_not_copy_elements_tag())
+
+#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
+    ,safe_super()
+#endif
+
+  {
+    empty_initialize();
+  }
+
+  ~sequenced_index()
+  {
+    /* the container is guaranteed to be empty by now */
+  }
+
+#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
+  iterator       make_iterator(node_type* node){return iterator(node,this);}
+  const_iterator make_iterator(node_type* node)const
+    {return const_iterator(node,const_cast<sequenced_index*>(this));}
+#else
+  iterator       make_iterator(node_type* node){return iterator(node);}
+  const_iterator make_iterator(node_type* node)const
+                   {return const_iterator(node);}
+#endif
+
+  void copy_(
+    const sequenced_index<SuperMeta,TagList>& x,const copy_map_type& map)
+  {
+    node_type* org=x.header();
+    node_type* cpy=header();
+    do{
+      node_type* next_org=node_type::from_impl(org->next());
+      node_type* next_cpy=map.find(static_cast<final_node_type*>(next_org));
+      cpy->next()=next_cpy->impl();
+      next_cpy->prior()=cpy->impl();
+      org=next_org;
+      cpy=next_cpy;
+    }while(org!=x.header());
+
+    super::copy_(x,map);
+  }
+
+  template<typename Variant>
+  final_node_type* insert_(
+    value_param_type v,final_node_type*& x,Variant variant)
+  {
+    final_node_type* res=super::insert_(v,x,variant);
+    if(res==x)link(static_cast<node_type*>(x));
+    return res;
+  }
+
+  template<typename Variant>
+  final_node_type* insert_(
+    value_param_type v,node_type* position,final_node_type*& x,Variant variant)
+  {
+    final_node_type* res=super::insert_(v,position,x,variant);
+    if(res==x)link(static_cast<node_type*>(x));
+    return res;
+  }
+
+  void erase_(node_type* x)
+  {
+    unlink(x);
+    super::erase_(x);
+
+#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
+    detach_iterators(x);
+#endif
+  }
+
+  void delete_all_nodes_()
+  {
+    for(node_type* x=node_type::from_impl(header()->next());x!=header();){
+      node_type* y=node_type::from_impl(x->next());
+      this->final_delete_node_(static_cast<final_node_type*>(x));
+      x=y;
+    }
+  }
+
+  void clear_()
+  {
+    super::clear_();
+    empty_initialize();
+
+#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
+    safe_super::detach_dereferenceable_iterators();
+#endif
+  }
+
+  void swap_(sequenced_index<SuperMeta,TagList>& x)
+  {
+#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
+    safe_super::swap(x);
+#endif
+
+    super::swap_(x);
+  }
+
+  void swap_elements_(sequenced_index<SuperMeta,TagList>& x)
+  {
+#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
+    safe_super::swap(x);
+#endif
+
+    super::swap_elements_(x);
+  }
+
+  template<typename Variant>
+  bool replace_(value_param_type v,node_type* x,Variant variant)
+  {
+    return super::replace_(v,x,variant);
+  }
+
+  bool modify_(node_type* x)
+  {
+    BOOST_TRY{
+      if(!super::modify_(x)){
+        unlink(x);
+
+#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
+        detach_iterators(x);
+#endif
+
+        return false;
+      }
+      else return true;
+    }
+    BOOST_CATCH(...){
+      unlink(x);
+
+#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
+      detach_iterators(x);
+#endif
+
+      BOOST_RETHROW;
+    }
+    BOOST_CATCH_END
+  }
+
+  bool modify_rollback_(node_type* x)
+  {
+    return super::modify_rollback_(x);
+  }
+
+#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
+  /* serialization */
+
+  template<typename Archive>
+  void save_(
+    Archive& ar,const unsigned int version,const index_saver_type& sm)const
+  {
+    sm.save(begin(),end(),ar,version);
+    super::save_(ar,version,sm);
+  }
+
+  template<typename Archive>
+  void load_(
+    Archive& ar,const unsigned int version,const index_loader_type& lm)
+  {
+    lm.load(
+      ::boost::bind(
+        &sequenced_index::rearranger,this,::boost::arg<1>(),::boost::arg<2>()),
+      ar,version);
+    super::load_(ar,version,lm);
+  }
+#endif
+
+#if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING)
+  /* invariant stuff */
+
+  bool invariant_()const
+  {
+    if(size()==0||begin()==end()){
+      if(size()!=0||begin()!=end()||
+         header()->next()!=header()->impl()||
+         header()->prior()!=header()->impl())return false;
+    }
+    else{
+      size_type s=0;
+      for(const_iterator it=begin(),it_end=end();it!=it_end;++it,++s){
+        if(it.get_node()->next()->prior()!=it.get_node()->impl())return false;
+        if(it.get_node()->prior()->next()!=it.get_node()->impl())return false;
+      }
+      if(s!=size())return false;
+    }
+
+    return super::invariant_();
+  }
+
+  /* This forwarding function eases things for the boost::mem_fn construct
+   * in BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT. Actually,
+   * final_check_invariant is already an inherited member function of index.
+   */
+  void check_invariant_()const{this->final_check_invariant_();}
+#endif
+
+private:
+  node_type* header()const{return this->final_header();}
+
+  void empty_initialize()
+  {
+    header()->prior()=header()->next()=header()->impl();
+  }
+
+  void link(node_type* x)
+  {
+    node_impl_type::link(x->impl(),header()->impl());
+  };
+
+  static void unlink(node_type* x)
+  {
+    node_impl_type::unlink(x->impl());
+  }
+
+  static void relink(node_type* position,node_type* x)
+  {
+    node_impl_type::relink(position->impl(),x->impl());
+  }
+
+  static void relink(node_type* position,node_type* first,node_type* last)
+  {
+    node_impl_type::relink(
+      position->impl(),first->impl(),last->impl());
+  }
+
+#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
+  void rearranger(node_type* position,node_type *x)
+  {
+    if(!position)position=header();
+    node_type::increment(position);
+    if(position!=x)relink(position,x);
+  }
+#endif
+
+#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
+  void detach_iterators(node_type* x)
+  {
+    iterator it=make_iterator(x);
+    safe_mode::detach_equivalent_iterators(it);
+  }
+#endif
+
+  template <class InputIterator>
+  void assign_iter(InputIterator first,InputIterator last,mpl::true_)
+  {
+    BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT;
+    clear();
+    for(;first!=last;++first)this->final_insert_ref_(*first);
+  }
+
+  void assign_iter(size_type n,value_param_type value,mpl::false_)
+  {
+    BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT;
+    clear();
+    for(size_type i=0;i<n;++i)push_back(value);
+  }
+
+  template<typename InputIterator>
+  void insert_iter(
+    iterator position,InputIterator first,InputIterator last,mpl::true_)
+  {
+    BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT;
+    for(;first!=last;++first){
+      std::pair<final_node_type*,bool> p=
+        this->final_insert_ref_(*first);
+      if(p.second&&position.get_node()!=header()){
+        relink(position.get_node(),p.first);
+      }
+    }
+  }
+
+  void insert_iter(
+    iterator position,size_type n,value_param_type x,mpl::false_)
+  {
+    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
+    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
+    BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT;
+    for(size_type i=0;i<n;++i)insert(position,x);
+  }
+
+  template<BOOST_MULTI_INDEX_TEMPLATE_PARAM_PACK>
+  std::pair<iterator,bool> emplace_front_impl(
+    BOOST_MULTI_INDEX_FUNCTION_PARAM_PACK)
+  {
+    return emplace_impl(begin(),BOOST_MULTI_INDEX_FORWARD_PARAM_PACK);
+  }
+
+  template<BOOST_MULTI_INDEX_TEMPLATE_PARAM_PACK>
+  std::pair<iterator,bool> emplace_back_impl(
+    BOOST_MULTI_INDEX_FUNCTION_PARAM_PACK)
+  {
+    return emplace_impl(end(),BOOST_MULTI_INDEX_FORWARD_PARAM_PACK);
+  }
+
+  template<BOOST_MULTI_INDEX_TEMPLATE_PARAM_PACK>
+  std::pair<iterator,bool> emplace_impl(
+    iterator position,BOOST_MULTI_INDEX_FUNCTION_PARAM_PACK)
+  {
+    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
+    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
+    BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT;
+    std::pair<final_node_type*,bool> p=
+      this->final_emplace_(BOOST_MULTI_INDEX_FORWARD_PARAM_PACK);
+    if(p.second&&position.get_node()!=header()){
+      relink(position.get_node(),p.first);
+    }
+    return std::pair<iterator,bool>(make_iterator(p.first),p.second);
+  }
+
+#if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING)&&\
+    BOOST_WORKAROUND(__MWERKS__,<=0x3003)
+#pragma parse_mfunc_templ reset
+#endif
+};
+
+/* comparison */
+
+template<
+  typename SuperMeta1,typename TagList1,
+  typename SuperMeta2,typename TagList2
+>
+bool operator==(
+  const sequenced_index<SuperMeta1,TagList1>& x,
+  const sequenced_index<SuperMeta2,TagList2>& y)
+{
+  return x.size()==y.size()&&std::equal(x.begin(),x.end(),y.begin());
+}
+
+template<
+  typename SuperMeta1,typename TagList1,
+  typename SuperMeta2,typename TagList2
+>
+bool operator<(
+  const sequenced_index<SuperMeta1,TagList1>& x,
+  const sequenced_index<SuperMeta2,TagList2>& y)
+{
+  return std::lexicographical_compare(x.begin(),x.end(),y.begin(),y.end());
+}
+
+template<
+  typename SuperMeta1,typename TagList1,
+  typename SuperMeta2,typename TagList2
+>
+bool operator!=(
+  const sequenced_index<SuperMeta1,TagList1>& x,
+  const sequenced_index<SuperMeta2,TagList2>& y)
+{
+  return !(x==y);
+}
+
+template<
+  typename SuperMeta1,typename TagList1,
+  typename SuperMeta2,typename TagList2
+>
+bool operator>(
+  const sequenced_index<SuperMeta1,TagList1>& x,
+  const sequenced_index<SuperMeta2,TagList2>& y)
+{
+  return y<x;
+}
+
+template<
+  typename SuperMeta1,typename TagList1,
+  typename SuperMeta2,typename TagList2
+>
+bool operator>=(
+  const sequenced_index<SuperMeta1,TagList1>& x,
+  const sequenced_index<SuperMeta2,TagList2>& y)
+{
+  return !(x<y);
+}
+
+template<
+  typename SuperMeta1,typename TagList1,
+  typename SuperMeta2,typename TagList2
+>
+bool operator<=(
+  const sequenced_index<SuperMeta1,TagList1>& x,
+  const sequenced_index<SuperMeta2,TagList2>& y)
+{
+  return !(x>y);
+}
+
+/*  specialized algorithms */
+
+template<typename SuperMeta,typename TagList>
+void swap(
+  sequenced_index<SuperMeta,TagList>& x,
+  sequenced_index<SuperMeta,TagList>& y)
+{
+  x.swap(y);
+}
+
+} /* namespace multi_index::detail */
+
+/* sequenced index specifier */
+
+template <typename TagList>
+struct sequenced
+{
+  BOOST_STATIC_ASSERT(detail::is_tag<TagList>::value);
+
+  template<typename Super>
+  struct node_class
+  {
+    typedef detail::sequenced_index_node<Super> type;
+  };
+
+  template<typename SuperMeta>
+  struct index_class
+  {
+    typedef detail::sequenced_index<SuperMeta,typename TagList::type> type;
+  };
+};
+
+} /* namespace multi_index */
+
+} /* namespace boost */
+
+/* Boost.Foreach compatibility */
+
+template<typename SuperMeta,typename TagList>
+inline boost::mpl::true_* boost_foreach_is_noncopyable(
+  boost::multi_index::detail::sequenced_index<SuperMeta,TagList>*&,
+  boost_foreach_argument_dependent_lookup_hack)
+{
+  return 0;
+}
+
+#undef BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT
+#undef BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT_OF
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/sequenced_index_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/sequenced_index_fwd.hpp
new file mode 100644
index 00000000000..a019f2a6d2f
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/multi_index/sequenced_index_fwd.hpp
@@ -0,0 +1,91 @@
+/* Copyright 2003-2013 Joaquin M Lopez Munoz.
+ * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
+ */
+
+#ifndef BOOST_MULTI_INDEX_SEQUENCED_INDEX_FWD_HPP
+#define BOOST_MULTI_INDEX_SEQUENCED_INDEX_FWD_HPP
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/multi_index/tag.hpp>
+
+namespace boost{
+
+namespace multi_index{
+
+namespace detail{
+
+template<typename SuperMeta,typename TagList>
+class sequenced_index;
+
+template<
+  typename SuperMeta1,typename TagList1,
+  typename SuperMeta2,typename TagList2
+>
+bool operator==(
+  const sequenced_index<SuperMeta1,TagList1>& x,
+  const sequenced_index<SuperMeta2,TagList2>& y);
+
+template<
+  typename SuperMeta1,typename TagList1,
+  typename SuperMeta2,typename TagList2
+>
+bool operator<(
+  const sequenced_index<SuperMeta1,TagList1>& x,
+  const sequenced_index<SuperMeta2,TagList2>& y);
+
+template<
+  typename SuperMeta1,typename TagList1,
+  typename SuperMeta2,typename TagList2
+>
+bool operator!=(
+  const sequenced_index<SuperMeta1,TagList1>& x,
+  const sequenced_index<SuperMeta2,TagList2>& y);
+
+template<
+  typename SuperMeta1,typename TagList1,
+  typename SuperMeta2,typename TagList2
+>
+bool operator>(
+  const sequenced_index<SuperMeta1,TagList1>& x,
+  const sequenced_index<SuperMeta2,TagList2>& y);
+
+template<
+  typename SuperMeta1,typename TagList1,
+  typename SuperMeta2,typename TagList2
+>
+bool operator>=(
+  const sequenced_index<SuperMeta1,TagList1>& x,
+  const sequenced_index<SuperMeta2,TagList2>& y);
+
+template<
+  typename SuperMeta1,typename TagList1,
+  typename SuperMeta2,typename TagList2
+>
+bool operator<=(
+  const sequenced_index<SuperMeta1,TagList1>& x,
+  const sequenced_index<SuperMeta2,TagList2>& y);
+
+template<typename SuperMeta,typename TagList>
+void swap(
+  sequenced_index<SuperMeta,TagList>& x,
+  sequenced_index<SuperMeta,TagList>& y);
+
+} /* namespace multi_index::detail */
+
+/* index specifiers */
+
+template <typename TagList=tag<> >
+struct sequenced;
+
+} /* namespace multi_index */
+
+} /* namespace boost */
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/tag.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/tag.hpp
new file mode 100644
index 00000000000..ce51f8241ee
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/multi_index/tag.hpp
@@ -0,0 +1,88 @@
+/* Copyright 2003-2013 Joaquin M Lopez Munoz.
+ * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
+ */
+
+#ifndef BOOST_MULTI_INDEX_TAG_HPP
+#define BOOST_MULTI_INDEX_TAG_HPP
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
+#include <boost/multi_index/detail/no_duplicate_tags.hpp>
+#include <boost/mpl/identity.hpp>
+#include <boost/mpl/transform.hpp>
+#include <boost/mpl/vector.hpp>
+#include <boost/preprocessor/facilities/intercept.hpp> 
+#include <boost/preprocessor/repetition/enum_binary_params.hpp> 
+#include <boost/preprocessor/repetition/enum_params.hpp> 
+#include <boost/static_assert.hpp>
+#include <boost/type_traits/is_base_and_derived.hpp>
+
+/* A wrapper of mpl::vector used to hide MPL from the user.
+ * tag contains types used as tag names for indices in get() functions.
+ */
+
+/* This user_definable macro limits the number of elements of a tag;
+ * useful for shortening resulting symbol names (MSVC++ 6.0, for instance,
+ * has problems coping with very long symbol names.)
+ */
+
+#if !defined(BOOST_MULTI_INDEX_LIMIT_TAG_SIZE)
+#define BOOST_MULTI_INDEX_LIMIT_TAG_SIZE BOOST_MPL_LIMIT_VECTOR_SIZE
+#endif
+
+#if BOOST_MULTI_INDEX_LIMIT_TAG_SIZE<BOOST_MPL_LIMIT_VECTOR_SIZE
+#define BOOST_MULTI_INDEX_TAG_SIZE BOOST_MULTI_INDEX_LIMIT_TAG_SIZE
+#else
+#define BOOST_MULTI_INDEX_TAG_SIZE BOOST_MPL_LIMIT_VECTOR_SIZE
+#endif
+
+namespace boost{
+
+namespace multi_index{
+
+namespace detail{
+
+struct tag_marker{};
+
+template<typename T>
+struct is_tag
+{
+  BOOST_STATIC_CONSTANT(bool,value=(is_base_and_derived<tag_marker,T>::value));
+};
+
+} /* namespace multi_index::detail */
+
+template<
+  BOOST_PP_ENUM_BINARY_PARAMS(
+    BOOST_MULTI_INDEX_TAG_SIZE,
+    typename T,
+    =mpl::na BOOST_PP_INTERCEPT) 
+>
+struct tag:private detail::tag_marker
+{
+  /* The mpl::transform pass produces shorter symbols (without
+   * trailing mpl::na's.)
+   */
+
+  typedef typename mpl::transform<
+    mpl::vector<BOOST_PP_ENUM_PARAMS(BOOST_MULTI_INDEX_TAG_SIZE,T)>,
+    mpl::identity<mpl::_1>
+  >::type type;
+
+  BOOST_STATIC_ASSERT(detail::no_duplicate_tags<type>::value);
+};
+
+} /* namespace multi_index */
+
+} /* namespace boost */
+
+#undef BOOST_MULTI_INDEX_TAG_SIZE
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index_container.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index_container.hpp
new file mode 100644
index 00000000000..9993a8dfa10
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/multi_index_container.hpp
@@ -0,0 +1,1362 @@
+/* Multiply indexed container.
+ *
+ * Copyright 2003-2014 Joaquin M Lopez Munoz.
+ * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
+ */
+
+#ifndef BOOST_MULTI_INDEX_HPP
+#define BOOST_MULTI_INDEX_HPP
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
+#include <algorithm>
+#include <boost/detail/allocator_utilities.hpp>
+#include <boost/detail/no_exceptions_support.hpp>
+#include <boost/detail/workaround.hpp>
+#include <boost/move/core.hpp>
+#include <boost/mpl/at.hpp>
+#include <boost/mpl/contains.hpp>
+#include <boost/mpl/find_if.hpp>
+#include <boost/mpl/identity.hpp>
+#include <boost/mpl/int.hpp>
+#include <boost/mpl/size.hpp>
+#include <boost/mpl/deref.hpp>
+#include <boost/multi_index_container_fwd.hpp>
+#include <boost/multi_index/detail/access_specifier.hpp>
+#include <boost/multi_index/detail/adl_swap.hpp>
+#include <boost/multi_index/detail/base_type.hpp>
+#include <boost/multi_index/detail/do_not_copy_elements_tag.hpp>
+#include <boost/multi_index/detail/converter.hpp>
+#include <boost/multi_index/detail/header_holder.hpp>
+#include <boost/multi_index/detail/has_tag.hpp>
+#include <boost/multi_index/detail/no_duplicate_tags.hpp>
+#include <boost/multi_index/detail/safe_mode.hpp>
+#include <boost/multi_index/detail/scope_guard.hpp>
+#include <boost/multi_index/detail/vartempl_support.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/utility/base_from_member.hpp>
+
+#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
+#include <initializer_list>
+#endif
+
+#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
+#include <boost/multi_index/detail/archive_constructed.hpp>
+#include <boost/multi_index/detail/serialization_version.hpp>
+#include <boost/serialization/collection_size_type.hpp>
+#include <boost/serialization/nvp.hpp>
+#include <boost/serialization/split_member.hpp>
+#include <boost/serialization/version.hpp>
+#include <boost/throw_exception.hpp> 
+#endif
+
+#if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING)
+#include <boost/multi_index/detail/invariant_assert.hpp>
+#define BOOST_MULTI_INDEX_CHECK_INVARIANT_OF(x)                              \
+  detail::scope_guard BOOST_JOIN(check_invariant_,__LINE__)=                 \
+    detail::make_obj_guard(x,&multi_index_container::check_invariant_);      \
+  BOOST_JOIN(check_invariant_,__LINE__).touch();
+#define BOOST_MULTI_INDEX_CHECK_INVARIANT                                    \
+  BOOST_MULTI_INDEX_CHECK_INVARIANT_OF(*this)
+#else
+#define BOOST_MULTI_INDEX_CHECK_INVARIANT_OF(x)
+#define BOOST_MULTI_INDEX_CHECK_INVARIANT
+#endif
+
+namespace boost{
+
+namespace multi_index{
+
+#if BOOST_WORKAROUND(BOOST_MSVC,BOOST_TESTED_AT(1500))
+#pragma warning(push)
+#pragma warning(disable:4522) /* spurious warning on multiple operator=()'s */
+#endif
+
+template<typename Value,typename IndexSpecifierList,typename Allocator>
+class multi_index_container:
+  private ::boost::base_from_member<
+    typename boost::detail::allocator::rebind_to<
+      Allocator,
+      typename detail::multi_index_node_type<
+        Value,IndexSpecifierList,Allocator>::type
+    >::type>,
+  BOOST_MULTI_INDEX_PRIVATE_IF_MEMBER_TEMPLATE_FRIENDS detail::header_holder<
+    typename boost::detail::allocator::rebind_to<
+      Allocator,
+      typename detail::multi_index_node_type<
+        Value,IndexSpecifierList,Allocator>::type
+    >::type::pointer,
+    multi_index_container<Value,IndexSpecifierList,Allocator> >,
+  public detail::multi_index_base_type<
+    Value,IndexSpecifierList,Allocator>::type
+{
+#if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING)&&\
+    BOOST_WORKAROUND(__MWERKS__,<=0x3003)
+/* The "ISO C++ Template Parser" option in CW8.3 has a problem with the
+ * lifetime of const references bound to temporaries --precisely what
+ * scopeguards are.
+ */
+
+#pragma parse_mfunc_templ off
+#endif
+
+private:
+  BOOST_COPYABLE_AND_MOVABLE(multi_index_container)
+
+#if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
+  template <typename,typename,typename> friend class  detail::index_base;
+  template <typename,typename>          friend struct detail::header_holder;
+  template <typename,typename>          friend struct detail::converter;
+#endif
+
+  typedef typename detail::multi_index_base_type<
+      Value,IndexSpecifierList,Allocator>::type   super;
+  typedef typename
+  boost::detail::allocator::rebind_to<
+    Allocator,
+    typename super::node_type
+  >::type                                         node_allocator;
+  typedef ::boost::base_from_member<
+    node_allocator>                               bfm_allocator;
+  typedef detail::header_holder<
+    typename node_allocator::pointer,
+    multi_index_container>                        bfm_header;
+
+
+public:
+  /* All types are inherited from super, a few are explicitly
+   * brought forward here to save us some typename's.
+   */
+
+  typedef typename super::ctor_args_list           ctor_args_list;
+  typedef IndexSpecifierList                       index_specifier_type_list;
+ 
+  typedef typename super::index_type_list          index_type_list;
+
+  typedef typename super::iterator_type_list       iterator_type_list;
+  typedef typename super::const_iterator_type_list const_iterator_type_list;
+  typedef typename super::value_type               value_type;
+  typedef typename super::final_allocator_type     allocator_type;
+  typedef typename super::iterator                 iterator;
+  typedef typename super::const_iterator           const_iterator;
+
+  BOOST_STATIC_ASSERT(
+    detail::no_duplicate_tags_in_index_list<index_type_list>::value);
+
+  /* global project() needs to see this publicly */
+
+  typedef typename super::node_type node_type;
+
+  /* construct/copy/destroy */
+
+  explicit multi_index_container(
+
+#if BOOST_WORKAROUND(__IBMCPP__,<=600)
+    /* VisualAge seems to have an ETI issue with the default values
+     * for arguments args_list and al.
+     */
+
+    const ctor_args_list& args_list=
+      typename mpl::identity<multi_index_container>::type::
+        ctor_args_list(),
+    const allocator_type& al=
+      typename mpl::identity<multi_index_container>::type::
+        allocator_type()):
+#else
+    const ctor_args_list& args_list=ctor_args_list(),
+    const allocator_type& al=allocator_type()):
+#endif
+
+    bfm_allocator(al),
+    super(args_list,bfm_allocator::member),
+    node_count(0)
+  {
+    BOOST_MULTI_INDEX_CHECK_INVARIANT;
+  }
+
+  explicit multi_index_container(const allocator_type& al):
+    bfm_allocator(al),
+    super(ctor_args_list(),bfm_allocator::member),
+    node_count(0)
+  {
+    BOOST_MULTI_INDEX_CHECK_INVARIANT;
+  }
+  
+  template<typename InputIterator>
+  multi_index_container(
+    InputIterator first,InputIterator last,
+
+#if BOOST_WORKAROUND(__IBMCPP__,<=600)
+    /* VisualAge seems to have an ETI issue with the default values
+     * for arguments args_list and al.
+     */
+
+    const ctor_args_list& args_list=
+      typename mpl::identity<multi_index_container>::type::
+        ctor_args_list(),
+    const allocator_type& al=
+      typename mpl::identity<multi_index_container>::type::
+        allocator_type()):
+#else
+    const ctor_args_list& args_list=ctor_args_list(),
+    const allocator_type& al=allocator_type()):
+#endif
+
+    bfm_allocator(al),
+    super(args_list,bfm_allocator::member),
+    node_count(0)
+  {
+    BOOST_MULTI_INDEX_CHECK_INVARIANT;
+    BOOST_TRY{
+      iterator hint=super::end();
+      for(;first!=last;++first){
+        hint=super::make_iterator(
+          insert_ref_(*first,hint.get_node()).first);
+        ++hint;
+      }
+    }
+    BOOST_CATCH(...){
+      clear_();
+      BOOST_RETHROW;
+    }
+    BOOST_CATCH_END
+  }
+
+#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
+  multi_index_container(
+    std::initializer_list<Value> list,
+    const ctor_args_list& args_list=ctor_args_list(),
+    const allocator_type& al=allocator_type()):
+    bfm_allocator(al),
+    super(args_list,bfm_allocator::member),
+    node_count(0)
+  {
+    BOOST_MULTI_INDEX_CHECK_INVARIANT;
+    BOOST_TRY{
+      typedef const Value* init_iterator;
+
+      iterator hint=super::end();
+      for(init_iterator first=list.begin(),last=list.end();
+          first!=last;++first){
+        hint=super::make_iterator(insert_(*first,hint.get_node()).first);
+        ++hint;
+      }
+    }
+    BOOST_CATCH(...){
+      clear_();
+      BOOST_RETHROW;
+    }
+    BOOST_CATCH_END
+  }
+#endif
+
+  multi_index_container(
+    const multi_index_container<Value,IndexSpecifierList,Allocator>& x):
+    bfm_allocator(x.bfm_allocator::member),
+    bfm_header(),
+    super(x),
+    node_count(0)
+  {
+    copy_map_type map(bfm_allocator::member,x.size(),x.header(),header());
+    for(const_iterator it=x.begin(),it_end=x.end();it!=it_end;++it){
+      map.clone(it.get_node());
+    }
+    super::copy_(x,map);
+    map.release();
+    node_count=x.size();
+
+    /* Not until this point are the indices required to be consistent,
+     * hence the position of the invariant checker.
+     */
+
+    BOOST_MULTI_INDEX_CHECK_INVARIANT;
+  }
+
+  multi_index_container(BOOST_RV_REF(multi_index_container) x):
+    bfm_allocator(x.bfm_allocator::member),
+    bfm_header(),
+    super(x,detail::do_not_copy_elements_tag()),
+    node_count(0)
+  {
+    BOOST_MULTI_INDEX_CHECK_INVARIANT;
+    BOOST_MULTI_INDEX_CHECK_INVARIANT_OF(x);
+    swap_elements_(x);
+  }
+
+  ~multi_index_container()
+  {
+    delete_all_nodes_();
+  }
+
+#if defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+  /* As per http://www.boost.org/doc/html/move/emulation_limitations.html
+   * #move.emulation_limitations.assignment_operator
+   */
+
+  multi_index_container<Value,IndexSpecifierList,Allocator>& operator=(
+    const multi_index_container<Value,IndexSpecifierList,Allocator>& x)
+  {
+    multi_index_container y(x);
+    this->swap(y);
+    return *this;
+  }
+#endif
+
+  multi_index_container<Value,IndexSpecifierList,Allocator>& operator=(
+    BOOST_COPY_ASSIGN_REF(multi_index_container) x)
+  {
+    multi_index_container y(x);
+    this->swap(y);
+    return *this;
+  }
+
+  multi_index_container<Value,IndexSpecifierList,Allocator>& operator=(
+    BOOST_RV_REF(multi_index_container) x)
+  {
+    this->swap(x);
+    return *this;
+  }
+
+#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
+  multi_index_container<Value,IndexSpecifierList,Allocator>& operator=(
+    std::initializer_list<Value> list)
+  {
+    BOOST_MULTI_INDEX_CHECK_INVARIANT;
+    typedef const Value* init_iterator;
+
+    multi_index_container x(*this,detail::do_not_copy_elements_tag());    
+    iterator hint=x.end();
+    for(init_iterator first=list.begin(),last=list.end();
+        first!=last;++first){
+      hint=x.make_iterator(x.insert_(*first,hint.get_node()).first);
+      ++hint;
+    }
+    x.swap_elements_(*this);
+    return*this;
+  }
+#endif
+
+  allocator_type get_allocator()const BOOST_NOEXCEPT
+  {
+    return allocator_type(bfm_allocator::member);
+  }
+
+  /* retrieval of indices by number */
+
+#if !defined(BOOST_NO_MEMBER_TEMPLATES)
+  template<int N>
+  struct nth_index
+  {
+    BOOST_STATIC_ASSERT(N>=0&&N<mpl::size<index_type_list>::type::value);
+    typedef typename mpl::at_c<index_type_list,N>::type type;
+  };
+
+  template<int N>
+  typename nth_index<N>::type& get()BOOST_NOEXCEPT
+  {
+    BOOST_STATIC_ASSERT(N>=0&&N<mpl::size<index_type_list>::type::value);
+    return *this;
+  }
+
+  template<int N>
+  const typename nth_index<N>::type& get()const BOOST_NOEXCEPT
+  {
+    BOOST_STATIC_ASSERT(N>=0&&N<mpl::size<index_type_list>::type::value);
+    return *this;
+  }
+#endif
+
+  /* retrieval of indices by tag */
+
+#if !defined(BOOST_NO_MEMBER_TEMPLATES)
+  template<typename Tag>
+  struct index
+  {
+    typedef typename mpl::find_if<
+      index_type_list,
+      detail::has_tag<Tag>
+    >::type                                    iter;
+
+    BOOST_STATIC_CONSTANT(
+      bool,index_found=!(is_same<iter,typename mpl::end<index_type_list>::type >::value));
+    BOOST_STATIC_ASSERT(index_found);
+
+    typedef typename mpl::deref<iter>::type    type;
+  };
+
+  template<typename Tag>
+  typename index<Tag>::type& get()BOOST_NOEXCEPT
+  {
+    return *this;
+  }
+
+  template<typename Tag>
+  const typename index<Tag>::type& get()const BOOST_NOEXCEPT
+  {
+    return *this;
+  }
+#endif
+
+  /* projection of iterators by number */
+
+#if !defined(BOOST_NO_MEMBER_TEMPLATES)
+  template<int N>
+  struct nth_index_iterator
+  {
+    typedef typename nth_index<N>::type::iterator type;
+  };
+
+  template<int N>
+  struct nth_index_const_iterator
+  {
+    typedef typename nth_index<N>::type::const_iterator type;
+  };
+
+  template<int N,typename IteratorType>
+  typename nth_index_iterator<N>::type project(IteratorType it)
+  {
+    typedef typename nth_index<N>::type index_type;
+
+#if !defined(__SUNPRO_CC)||!(__SUNPRO_CC<0x580) /* fails in Sun C++ 5.7 */
+    BOOST_STATIC_ASSERT(
+      (mpl::contains<iterator_type_list,IteratorType>::value));
+#endif
+
+    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(it);
+    BOOST_MULTI_INDEX_CHECK_IS_OWNER(
+      it,static_cast<typename IteratorType::container_type&>(*this));
+
+    return index_type::make_iterator(static_cast<node_type*>(it.get_node()));
+  }
+
+  template<int N,typename IteratorType>
+  typename nth_index_const_iterator<N>::type project(IteratorType it)const
+  {
+    typedef typename nth_index<N>::type index_type;
+
+#if !defined(__SUNPRO_CC)||!(__SUNPRO_CC<0x580) /* fails in Sun C++ 5.7 */
+    BOOST_STATIC_ASSERT((
+      mpl::contains<iterator_type_list,IteratorType>::value||
+      mpl::contains<const_iterator_type_list,IteratorType>::value));
+#endif
+
+    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(it);
+    BOOST_MULTI_INDEX_CHECK_IS_OWNER(
+      it,static_cast<const typename IteratorType::container_type&>(*this));
+    return index_type::make_iterator(static_cast<node_type*>(it.get_node()));
+  }
+#endif
+
+  /* projection of iterators by tag */
+
+#if !defined(BOOST_NO_MEMBER_TEMPLATES)
+  template<typename Tag>
+  struct index_iterator
+  {
+    typedef typename index<Tag>::type::iterator type;
+  };
+
+  template<typename Tag>
+  struct index_const_iterator
+  {
+    typedef typename index<Tag>::type::const_iterator type;
+  };
+
+  template<typename Tag,typename IteratorType>
+  typename index_iterator<Tag>::type project(IteratorType it)
+  {
+    typedef typename index<Tag>::type index_type;
+
+#if !defined(__SUNPRO_CC)||!(__SUNPRO_CC<0x580) /* fails in Sun C++ 5.7 */
+    BOOST_STATIC_ASSERT(
+      (mpl::contains<iterator_type_list,IteratorType>::value));
+#endif
+
+    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(it);
+    BOOST_MULTI_INDEX_CHECK_IS_OWNER(
+      it,static_cast<typename IteratorType::container_type&>(*this));
+    return index_type::make_iterator(static_cast<node_type*>(it.get_node()));
+  }
+
+  template<typename Tag,typename IteratorType>
+  typename index_const_iterator<Tag>::type project(IteratorType it)const
+  {
+    typedef typename index<Tag>::type index_type;
+
+#if !defined(__SUNPRO_CC)||!(__SUNPRO_CC<0x580) /* fails in Sun C++ 5.7 */
+    BOOST_STATIC_ASSERT((
+      mpl::contains<iterator_type_list,IteratorType>::value||
+      mpl::contains<const_iterator_type_list,IteratorType>::value));
+#endif
+
+    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(it);
+    BOOST_MULTI_INDEX_CHECK_IS_OWNER(
+      it,static_cast<const typename IteratorType::container_type&>(*this));
+    return index_type::make_iterator(static_cast<node_type*>(it.get_node()));
+  }
+#endif
+
+BOOST_MULTI_INDEX_PROTECTED_IF_MEMBER_TEMPLATE_FRIENDS:
+  typedef typename super::copy_map_type copy_map_type;
+
+#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
+  multi_index_container(
+    const multi_index_container<Value,IndexSpecifierList,Allocator>& x,
+    detail::do_not_copy_elements_tag):
+    bfm_allocator(x.bfm_allocator::member),
+    bfm_header(),
+    super(x,detail::do_not_copy_elements_tag()),
+    node_count(0)
+  {
+    BOOST_MULTI_INDEX_CHECK_INVARIANT;
+  }
+#endif
+
+  node_type* header()const
+  {
+    return &*bfm_header::member;
+  }
+
+  node_type* allocate_node()
+  {
+    return &*bfm_allocator::member.allocate(1);
+  }
+
+  void deallocate_node(node_type* x)
+  {
+    typedef typename node_allocator::pointer node_pointer;
+    bfm_allocator::member.deallocate(static_cast<node_pointer>(x),1);
+  }
+
+  bool empty_()const
+  {
+    return node_count==0;
+  }
+
+  std::size_t size_()const
+  {
+    return node_count;
+  }
+
+  std::size_t max_size_()const
+  {
+    return static_cast<std::size_t >(-1);
+  }
+
+  template<typename Variant>
+  std::pair<node_type*,bool> insert_(const Value& v,Variant variant)
+  {
+    node_type* x=0;
+    node_type* res=super::insert_(v,x,variant);
+    if(res==x){
+      ++node_count;
+      return std::pair<node_type*,bool>(res,true);
+    }
+    else{
+      return std::pair<node_type*,bool>(res,false);
+    }
+  }
+
+  std::pair<node_type*,bool> insert_(const Value& v)
+  {
+    return insert_(v,detail::lvalue_tag());
+  }
+
+  std::pair<node_type*,bool> insert_rv_(const Value& v)
+  {
+    return insert_(v,detail::rvalue_tag());
+  }
+
+  template<typename T>
+  std::pair<node_type*,bool> insert_ref_(T& t)
+  {
+    node_type* x=allocate_node();
+    BOOST_TRY{
+      new(&x->value()) value_type(t);
+      BOOST_TRY{
+        node_type* res=super::insert_(x->value(),x,detail::emplaced_tag());
+        if(res==x){
+          ++node_count;
+          return std::pair<node_type*,bool>(res,true);
+        }
+        else{
+          boost::detail::allocator::destroy(&x->value());
+          deallocate_node(x);
+          return std::pair<node_type*,bool>(res,false);
+        }
+      }
+      BOOST_CATCH(...){
+        boost::detail::allocator::destroy(&x->value());
+        BOOST_RETHROW;
+      }
+      BOOST_CATCH_END
+    }
+    BOOST_CATCH(...){
+      deallocate_node(x);
+      BOOST_RETHROW;
+    }
+    BOOST_CATCH_END
+  }
+
+  std::pair<node_type*,bool> insert_ref_(const value_type& x)
+  {
+    return insert_(x);
+  }
+
+  std::pair<node_type*,bool> insert_ref_(value_type& x)
+  {
+    return insert_(x);
+  }
+
+  template<BOOST_MULTI_INDEX_TEMPLATE_PARAM_PACK>
+  std::pair<node_type*,bool> emplace_(
+    BOOST_MULTI_INDEX_FUNCTION_PARAM_PACK)
+  {
+    node_type* x=allocate_node();
+    BOOST_TRY{
+      detail::vartempl_placement_new(
+        &x->value(),BOOST_MULTI_INDEX_FORWARD_PARAM_PACK);
+      BOOST_TRY{
+        node_type* res=super::insert_(x->value(),x,detail::emplaced_tag());
+        if(res==x){
+          ++node_count;
+          return std::pair<node_type*,bool>(res,true);
+        }
+        else{
+          boost::detail::allocator::destroy(&x->value());
+          deallocate_node(x);
+          return std::pair<node_type*,bool>(res,false);
+        }
+      }
+      BOOST_CATCH(...){
+        boost::detail::allocator::destroy(&x->value());
+        BOOST_RETHROW;
+      }
+      BOOST_CATCH_END
+    }
+    BOOST_CATCH(...){
+      deallocate_node(x);
+      BOOST_RETHROW;
+    }
+    BOOST_CATCH_END
+  }
+
+  template<typename Variant>
+  std::pair<node_type*,bool> insert_(
+    const Value& v,node_type* position,Variant variant)
+  {
+    node_type* x=0;
+    node_type* res=super::insert_(v,position,x,variant);
+    if(res==x){
+      ++node_count;
+      return std::pair<node_type*,bool>(res,true);
+    }
+    else{
+      return std::pair<node_type*,bool>(res,false);
+    }
+  }
+
+  std::pair<node_type*,bool> insert_(const Value& v,node_type* position)
+  {
+    return insert_(v,position,detail::lvalue_tag());
+  }
+
+  std::pair<node_type*,bool> insert_rv_(const Value& v,node_type* position)
+  {
+    return insert_(v,position,detail::rvalue_tag());
+  }
+
+  template<typename T>
+  std::pair<node_type*,bool> insert_ref_(
+    T& t,node_type* position)
+  {
+    node_type* x=allocate_node();
+    BOOST_TRY{
+      new(&x->value()) value_type(t);
+      BOOST_TRY{
+        node_type* res=super::insert_(
+          x->value(),position,x,detail::emplaced_tag());
+        if(res==x){
+          ++node_count;
+          return std::pair<node_type*,bool>(res,true);
+        }
+        else{
+          boost::detail::allocator::destroy(&x->value());
+          deallocate_node(x);
+          return std::pair<node_type*,bool>(res,false);
+        }
+      }
+      BOOST_CATCH(...){
+        boost::detail::allocator::destroy(&x->value());
+        BOOST_RETHROW;
+      }
+      BOOST_CATCH_END
+    }
+    BOOST_CATCH(...){
+      deallocate_node(x);
+      BOOST_RETHROW;
+    }
+    BOOST_CATCH_END
+  }
+
+  std::pair<node_type*,bool> insert_ref_(
+    const value_type& x,node_type* position)
+  {
+    return insert_(x,position);
+  }
+
+  std::pair<node_type*,bool> insert_ref_(
+    value_type& x,node_type* position)
+  {
+    return insert_(x,position);
+  }
+
+  template<BOOST_MULTI_INDEX_TEMPLATE_PARAM_PACK>
+  std::pair<node_type*,bool> emplace_hint_(
+    node_type* position,
+    BOOST_MULTI_INDEX_FUNCTION_PARAM_PACK)
+  {
+    node_type* x=allocate_node();
+    BOOST_TRY{
+      detail::vartempl_placement_new(
+        &x->value(),BOOST_MULTI_INDEX_FORWARD_PARAM_PACK);
+      BOOST_TRY{
+        node_type* res=super::insert_(
+          x->value(),position,x,detail::emplaced_tag());
+        if(res==x){
+          ++node_count;
+          return std::pair<node_type*,bool>(res,true);
+        }
+        else{
+          boost::detail::allocator::destroy(&x->value());
+          deallocate_node(x);
+          return std::pair<node_type*,bool>(res,false);
+        }
+      }
+      BOOST_CATCH(...){
+        boost::detail::allocator::destroy(&x->value());
+        BOOST_RETHROW;
+      }
+      BOOST_CATCH_END
+    }
+    BOOST_CATCH(...){
+      deallocate_node(x);
+      BOOST_RETHROW;
+    }
+    BOOST_CATCH_END
+  }
+
+  void erase_(node_type* x)
+  {
+    --node_count;
+    super::erase_(x);
+    deallocate_node(x);
+  }
+
+  void delete_node_(node_type* x)
+  {
+    super::delete_node_(x);
+    deallocate_node(x);
+  }
+
+  void delete_all_nodes_()
+  {
+    super::delete_all_nodes_();
+  }
+
+  void clear_()
+  {
+    delete_all_nodes_();
+    super::clear_();
+    node_count=0;
+  }
+
+  void swap_(multi_index_container<Value,IndexSpecifierList,Allocator>& x)
+  {
+    if(bfm_allocator::member!=x.bfm_allocator::member){
+      detail::adl_swap(bfm_allocator::member,x.bfm_allocator::member);
+    }
+    std::swap(bfm_header::member,x.bfm_header::member);
+    super::swap_(x);
+    std::swap(node_count,x.node_count);
+  }
+
+  void swap_elements_(
+    multi_index_container<Value,IndexSpecifierList,Allocator>& x)
+  {
+    std::swap(bfm_header::member,x.bfm_header::member);
+    super::swap_elements_(x);
+    std::swap(node_count,x.node_count);
+  }
+
+  bool replace_(const Value& k,node_type* x)
+  {
+    return super::replace_(k,x,detail::lvalue_tag());
+  }
+
+  bool replace_rv_(const Value& k,node_type* x)
+  {
+    return super::replace_(k,x,detail::rvalue_tag());
+  }
+
+  template<typename Modifier>
+  bool modify_(Modifier& mod,node_type* x)
+  {
+    mod(const_cast<value_type&>(x->value()));
+
+    BOOST_TRY{
+      if(!super::modify_(x)){
+        deallocate_node(x);
+        --node_count;
+        return false;
+      }
+      else return true;
+    }
+    BOOST_CATCH(...){
+      deallocate_node(x);
+      --node_count;
+      BOOST_RETHROW;
+    }
+    BOOST_CATCH_END
+  }
+
+  template<typename Modifier,typename Rollback>
+  bool modify_(Modifier& mod,Rollback& back_,node_type* x)
+  {
+    mod(const_cast<value_type&>(x->value()));
+
+    bool b;
+    BOOST_TRY{
+      b=super::modify_rollback_(x);
+    }
+    BOOST_CATCH(...){
+      BOOST_TRY{
+        back_(const_cast<value_type&>(x->value()));
+        BOOST_RETHROW;
+      }
+      BOOST_CATCH(...){
+        this->erase_(x);
+        BOOST_RETHROW;
+      }
+      BOOST_CATCH_END
+    }
+    BOOST_CATCH_END
+
+    BOOST_TRY{
+      if(!b){
+        back_(const_cast<value_type&>(x->value()));
+        return false;
+      }
+      else return true;
+    }
+    BOOST_CATCH(...){
+      this->erase_(x);
+      BOOST_RETHROW;
+    }
+    BOOST_CATCH_END
+  }
+
+#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
+  /* serialization */
+
+  friend class boost::serialization::access;
+
+  BOOST_SERIALIZATION_SPLIT_MEMBER()
+
+  typedef typename super::index_saver_type        index_saver_type;
+  typedef typename super::index_loader_type       index_loader_type;
+
+  template<class Archive>
+  void save(Archive& ar,const unsigned int version)const
+  {
+    const serialization::collection_size_type       s(size_());
+    const detail::serialization_version<value_type> value_version;
+    ar<<serialization::make_nvp("count",s);
+    ar<<serialization::make_nvp("value_version",value_version);
+
+    index_saver_type sm(bfm_allocator::member,s);
+
+    for(iterator it=super::begin(),it_end=super::end();it!=it_end;++it){
+      serialization::save_construct_data_adl(ar,&*it,value_version);
+      ar<<serialization::make_nvp("item",*it);
+      sm.add(it.get_node(),ar,version);
+    }
+    sm.add_track(header(),ar,version);
+
+    super::save_(ar,version,sm);
+  }
+
+  template<class Archive>
+  void load(Archive& ar,const unsigned int version)
+  {
+    BOOST_MULTI_INDEX_CHECK_INVARIANT;
+
+    clear_(); 
+    serialization::collection_size_type       s;
+    detail::serialization_version<value_type> value_version;
+    if(version<1){
+      std::size_t sz;
+      ar>>serialization::make_nvp("count",sz);
+      s=static_cast<serialization::collection_size_type>(sz);
+    }
+    else{
+      ar>>serialization::make_nvp("count",s);
+    }
+    if(version<2){
+      value_version=0;
+    }
+    else{
+      ar>>serialization::make_nvp("value_version",value_version);
+    }
+
+    index_loader_type lm(bfm_allocator::member,s);
+
+    for(std::size_t n=0;n<s;++n){
+      detail::archive_constructed<Value> value("item",ar,value_version);
+      std::pair<node_type*,bool> p=insert_(
+        value.get(),super::end().get_node());
+      if(!p.second)throw_exception(
+        archive::archive_exception(
+          archive::archive_exception::other_exception));
+      ar.reset_object_address(&p.first->value(),&value.get());
+      lm.add(p.first,ar,version);
+    }
+    lm.add_track(header(),ar,version);
+
+    super::load_(ar,version,lm);
+  }
+#endif
+
+#if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING)
+  /* invariant stuff */
+
+  bool invariant_()const
+  {
+    return super::invariant_();
+  }
+
+  void check_invariant_()const
+  {
+    BOOST_MULTI_INDEX_INVARIANT_ASSERT(invariant_());
+  }
+#endif
+
+private:
+  std::size_t node_count;
+
+#if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING)&&\
+    BOOST_WORKAROUND(__MWERKS__,<=0x3003)
+#pragma parse_mfunc_templ reset
+#endif
+};
+
+#if BOOST_WORKAROUND(BOOST_MSVC,BOOST_TESTED_AT(1500))
+#pragma warning(pop) /* C4522 */
+#endif
+
+/* retrieval of indices by number */
+
+template<typename MultiIndexContainer,int N>
+struct nth_index
+{
+  BOOST_STATIC_CONSTANT(
+    int,
+    M=mpl::size<typename MultiIndexContainer::index_type_list>::type::value);
+  BOOST_STATIC_ASSERT(N>=0&&N<M);
+  typedef typename mpl::at_c<
+    typename MultiIndexContainer::index_type_list,N>::type type;
+};
+
+template<int N,typename Value,typename IndexSpecifierList,typename Allocator>
+typename nth_index<
+  multi_index_container<Value,IndexSpecifierList,Allocator>,N>::type&
+get(
+  multi_index_container<Value,IndexSpecifierList,Allocator>& m)BOOST_NOEXCEPT
+{
+  typedef multi_index_container<
+    Value,IndexSpecifierList,Allocator>    multi_index_type;
+  typedef typename nth_index<
+    multi_index_container<
+      Value,IndexSpecifierList,Allocator>,
+    N
+  >::type                                  index_type;
+
+  BOOST_STATIC_ASSERT(N>=0&&
+    N<
+    mpl::size<
+      BOOST_DEDUCED_TYPENAME multi_index_type::index_type_list
+    >::type::value);
+
+  return detail::converter<multi_index_type,index_type>::index(m);
+}
+
+template<int N,typename Value,typename IndexSpecifierList,typename Allocator>
+const typename nth_index<
+  multi_index_container<Value,IndexSpecifierList,Allocator>,N>::type&
+get(
+  const multi_index_container<Value,IndexSpecifierList,Allocator>& m
+)BOOST_NOEXCEPT
+{
+  typedef multi_index_container<
+    Value,IndexSpecifierList,Allocator>    multi_index_type;
+  typedef typename nth_index<
+    multi_index_container<
+      Value,IndexSpecifierList,Allocator>,
+    N
+  >::type                                  index_type;
+
+  BOOST_STATIC_ASSERT(N>=0&&
+    N<
+    mpl::size<
+      BOOST_DEDUCED_TYPENAME multi_index_type::index_type_list
+    >::type::value);
+
+  return detail::converter<multi_index_type,index_type>::index(m);
+}
+
+/* retrieval of indices by tag */
+
+template<typename MultiIndexContainer,typename Tag>
+struct index
+{
+  typedef typename MultiIndexContainer::index_type_list index_type_list;
+
+  typedef typename mpl::find_if<
+    index_type_list,
+    detail::has_tag<Tag>
+  >::type                                      iter;
+
+  BOOST_STATIC_CONSTANT(
+    bool,index_found=!(is_same<iter,typename mpl::end<index_type_list>::type >::value));
+  BOOST_STATIC_ASSERT(index_found);
+
+  typedef typename mpl::deref<iter>::type       type;
+};
+
+template<
+  typename Tag,typename Value,typename IndexSpecifierList,typename Allocator
+>
+typename ::boost::multi_index::index<
+  multi_index_container<Value,IndexSpecifierList,Allocator>,Tag>::type&
+get(
+  multi_index_container<Value,IndexSpecifierList,Allocator>& m)BOOST_NOEXCEPT
+{
+  typedef multi_index_container<
+    Value,IndexSpecifierList,Allocator>         multi_index_type;
+  typedef typename ::boost::multi_index::index<
+    multi_index_container<
+      Value,IndexSpecifierList,Allocator>,
+    Tag
+  >::type                                       index_type;
+
+  return detail::converter<multi_index_type,index_type>::index(m);
+}
+
+template<
+  typename Tag,typename Value,typename IndexSpecifierList,typename Allocator
+>
+const typename ::boost::multi_index::index<
+  multi_index_container<Value,IndexSpecifierList,Allocator>,Tag>::type&
+get(
+  const multi_index_container<Value,IndexSpecifierList,Allocator>& m
+)BOOST_NOEXCEPT
+{
+  typedef multi_index_container<
+    Value,IndexSpecifierList,Allocator>         multi_index_type;
+  typedef typename ::boost::multi_index::index<
+    multi_index_container<
+      Value,IndexSpecifierList,Allocator>,
+    Tag
+  >::type                                       index_type;
+
+  return detail::converter<multi_index_type,index_type>::index(m);
+}
+
+/* projection of iterators by number */
+
+template<typename MultiIndexContainer,int N>
+struct nth_index_iterator
+{
+  typedef typename nth_index<MultiIndexContainer,N>::type::iterator type;
+};
+
+template<typename MultiIndexContainer,int N>
+struct nth_index_const_iterator
+{
+  typedef typename nth_index<MultiIndexContainer,N>::type::const_iterator type;
+};
+
+template<
+  int N,typename IteratorType,
+  typename Value,typename IndexSpecifierList,typename Allocator>
+typename nth_index_iterator<
+  multi_index_container<Value,IndexSpecifierList,Allocator>,N>::type
+project(
+  multi_index_container<Value,IndexSpecifierList,Allocator>& m,
+  IteratorType it)
+{
+  typedef multi_index_container<
+    Value,IndexSpecifierList,Allocator>                multi_index_type;
+  typedef typename nth_index<multi_index_type,N>::type index_type;
+
+#if !defined(__SUNPRO_CC)||!(__SUNPRO_CC<0x580) /* Sun C++ 5.7 fails */
+  BOOST_STATIC_ASSERT((
+    mpl::contains<
+      BOOST_DEDUCED_TYPENAME multi_index_type::iterator_type_list,
+      IteratorType>::value));
+#endif
+
+  BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(it);
+
+#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
+  typedef detail::converter<
+    multi_index_type,
+    BOOST_DEDUCED_TYPENAME IteratorType::container_type> converter;
+  BOOST_MULTI_INDEX_CHECK_IS_OWNER(it,converter::index(m));
+#endif
+
+  return detail::converter<multi_index_type,index_type>::iterator(
+    m,static_cast<typename multi_index_type::node_type*>(it.get_node()));
+}
+
+template<
+  int N,typename IteratorType,
+  typename Value,typename IndexSpecifierList,typename Allocator>
+typename nth_index_const_iterator<
+  multi_index_container<Value,IndexSpecifierList,Allocator>,N>::type
+project(
+  const multi_index_container<Value,IndexSpecifierList,Allocator>& m,
+  IteratorType it)
+{
+  typedef multi_index_container<
+    Value,IndexSpecifierList,Allocator>                multi_index_type;
+  typedef typename nth_index<multi_index_type,N>::type index_type;
+
+#if !defined(__SUNPRO_CC)||!(__SUNPRO_CC<0x580) /* Sun C++ 5.7 fails */
+  BOOST_STATIC_ASSERT((
+    mpl::contains<
+      BOOST_DEDUCED_TYPENAME multi_index_type::iterator_type_list,
+      IteratorType>::value||
+    mpl::contains<
+      BOOST_DEDUCED_TYPENAME multi_index_type::const_iterator_type_list,
+      IteratorType>::value));
+#endif
+
+  BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(it);
+
+#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
+  typedef detail::converter<
+    multi_index_type,
+    BOOST_DEDUCED_TYPENAME IteratorType::container_type> converter;
+  BOOST_MULTI_INDEX_CHECK_IS_OWNER(it,converter::index(m));
+#endif
+
+  return detail::converter<multi_index_type,index_type>::const_iterator(
+    m,static_cast<typename multi_index_type::node_type*>(it.get_node()));
+}
+
+/* projection of iterators by tag */
+
+template<typename MultiIndexContainer,typename Tag>
+struct index_iterator
+{
+  typedef typename ::boost::multi_index::index<
+    MultiIndexContainer,Tag>::type::iterator    type;
+};
+
+template<typename MultiIndexContainer,typename Tag>
+struct index_const_iterator
+{
+  typedef typename ::boost::multi_index::index<
+    MultiIndexContainer,Tag>::type::const_iterator type;
+};
+
+template<
+  typename Tag,typename IteratorType,
+  typename Value,typename IndexSpecifierList,typename Allocator>
+typename index_iterator<
+  multi_index_container<Value,IndexSpecifierList,Allocator>,Tag>::type
+project(
+  multi_index_container<Value,IndexSpecifierList,Allocator>& m,
+  IteratorType it)
+{
+  typedef multi_index_container<
+    Value,IndexSpecifierList,Allocator>         multi_index_type;
+  typedef typename ::boost::multi_index::index<
+    multi_index_type,Tag>::type                 index_type;
+
+#if !defined(__SUNPRO_CC)||!(__SUNPRO_CC<0x580) /* Sun C++ 5.7 fails */
+  BOOST_STATIC_ASSERT((
+    mpl::contains<
+      BOOST_DEDUCED_TYPENAME multi_index_type::iterator_type_list,
+      IteratorType>::value));
+#endif
+
+  BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(it);
+
+#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
+  typedef detail::converter<
+    multi_index_type,
+    BOOST_DEDUCED_TYPENAME IteratorType::container_type> converter;
+  BOOST_MULTI_INDEX_CHECK_IS_OWNER(it,converter::index(m));
+#endif
+
+  return detail::converter<multi_index_type,index_type>::iterator(
+    m,static_cast<typename multi_index_type::node_type*>(it.get_node()));
+}
+
+template<
+  typename Tag,typename IteratorType,
+  typename Value,typename IndexSpecifierList,typename Allocator>
+typename index_const_iterator<
+  multi_index_container<Value,IndexSpecifierList,Allocator>,Tag>::type
+project(
+  const multi_index_container<Value,IndexSpecifierList,Allocator>& m,
+  IteratorType it)
+{
+  typedef multi_index_container<
+    Value,IndexSpecifierList,Allocator>         multi_index_type;
+  typedef typename ::boost::multi_index::index<
+    multi_index_type,Tag>::type                 index_type;
+
+#if !defined(__SUNPRO_CC)||!(__SUNPRO_CC<0x580) /* Sun C++ 5.7 fails */
+  BOOST_STATIC_ASSERT((
+    mpl::contains<
+      BOOST_DEDUCED_TYPENAME multi_index_type::iterator_type_list,
+      IteratorType>::value||
+    mpl::contains<
+      BOOST_DEDUCED_TYPENAME multi_index_type::const_iterator_type_list,
+      IteratorType>::value));
+#endif
+
+  BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(it);
+
+#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
+  typedef detail::converter<
+    multi_index_type,
+    BOOST_DEDUCED_TYPENAME IteratorType::container_type> converter;
+  BOOST_MULTI_INDEX_CHECK_IS_OWNER(it,converter::index(m));
+#endif
+
+  return detail::converter<multi_index_type,index_type>::const_iterator(
+    m,static_cast<typename multi_index_type::node_type*>(it.get_node()));
+}
+
+/* Comparison. Simple forward to first index. */
+
+template<
+  typename Value1,typename IndexSpecifierList1,typename Allocator1,
+  typename Value2,typename IndexSpecifierList2,typename Allocator2
+>
+bool operator==(
+  const multi_index_container<Value1,IndexSpecifierList1,Allocator1>& x,
+  const multi_index_container<Value2,IndexSpecifierList2,Allocator2>& y)
+{
+  return get<0>(x)==get<0>(y);
+}
+
+template<
+  typename Value1,typename IndexSpecifierList1,typename Allocator1,
+  typename Value2,typename IndexSpecifierList2,typename Allocator2
+>
+bool operator<(
+  const multi_index_container<Value1,IndexSpecifierList1,Allocator1>& x,
+  const multi_index_container<Value2,IndexSpecifierList2,Allocator2>& y)
+{
+  return get<0>(x)<get<0>(y);
+}
+
+template<
+  typename Value1,typename IndexSpecifierList1,typename Allocator1,
+  typename Value2,typename IndexSpecifierList2,typename Allocator2
+>
+bool operator!=(
+  const multi_index_container<Value1,IndexSpecifierList1,Allocator1>& x,
+  const multi_index_container<Value2,IndexSpecifierList2,Allocator2>& y)
+{
+  return get<0>(x)!=get<0>(y);
+}
+
+template<
+  typename Value1,typename IndexSpecifierList1,typename Allocator1,
+  typename Value2,typename IndexSpecifierList2,typename Allocator2
+>
+bool operator>(
+  const multi_index_container<Value1,IndexSpecifierList1,Allocator1>& x,
+  const multi_index_container<Value2,IndexSpecifierList2,Allocator2>& y)
+{
+  return get<0>(x)>get<0>(y);
+}
+
+template<
+  typename Value1,typename IndexSpecifierList1,typename Allocator1,
+  typename Value2,typename IndexSpecifierList2,typename Allocator2
+>
+bool operator>=(
+  const multi_index_container<Value1,IndexSpecifierList1,Allocator1>& x,
+  const multi_index_container<Value2,IndexSpecifierList2,Allocator2>& y)
+{
+  return get<0>(x)>=get<0>(y);
+}
+
+template<
+  typename Value1,typename IndexSpecifierList1,typename Allocator1,
+  typename Value2,typename IndexSpecifierList2,typename Allocator2
+>
+bool operator<=(
+  const multi_index_container<Value1,IndexSpecifierList1,Allocator1>& x,
+  const multi_index_container<Value2,IndexSpecifierList2,Allocator2>& y)
+{
+  return get<0>(x)<=get<0>(y);
+}
+
+/*  specialized algorithms */
+
+template<typename Value,typename IndexSpecifierList,typename Allocator>
+void swap(
+  multi_index_container<Value,IndexSpecifierList,Allocator>& x,
+  multi_index_container<Value,IndexSpecifierList,Allocator>& y)
+{
+  x.swap(y);
+}
+
+} /* namespace multi_index */
+
+#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
+/* class version = 1 : we now serialize the size through
+ * boost::serialization::collection_size_type.
+ * class version = 2 : proper use of {save|load}_construct_data.
+ */
+
+namespace serialization {
+template<typename Value,typename IndexSpecifierList,typename Allocator>
+struct version<
+  boost::multi_index_container<Value,IndexSpecifierList,Allocator>
+>
+{
+  BOOST_STATIC_CONSTANT(int,value=2);
+};
+} /* namespace serialization */
+#endif
+
+/* Associated global functions are promoted to namespace boost, except
+ * comparison operators and swap, which are meant to be Koenig looked-up.
+ */
+
+using multi_index::get;
+using multi_index::project;
+
+} /* namespace boost */
+
+#undef BOOST_MULTI_INDEX_CHECK_INVARIANT
+#undef BOOST_MULTI_INDEX_CHECK_INVARIANT_OF
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index_container_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index_container_fwd.hpp
new file mode 100644
index 00000000000..b35acad407a
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/multi_index_container_fwd.hpp
@@ -0,0 +1,121 @@
+/* Copyright 2003-2013 Joaquin M Lopez Munoz.
+ * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
+ */
+
+#ifndef BOOST_MULTI_INDEX_FWD_HPP
+#define BOOST_MULTI_INDEX_FWD_HPP
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
+#include <boost/multi_index/identity.hpp>
+#include <boost/multi_index/indexed_by.hpp>
+#include <boost/multi_index/ordered_index_fwd.hpp>
+#include <memory>
+
+namespace boost{
+
+namespace multi_index{
+
+/* Default value for IndexSpecifierList specifies a container
+ * equivalent to std::set<Value>.
+ */
+
+template<
+  typename Value,
+  typename IndexSpecifierList=indexed_by<ordered_unique<identity<Value> > >,
+  typename Allocator=std::allocator<Value> >
+class multi_index_container;
+
+template<typename MultiIndexContainer,int N>
+struct nth_index;
+
+template<typename MultiIndexContainer,typename Tag>
+struct index;
+
+template<typename MultiIndexContainer,int N>
+struct nth_index_iterator;
+
+template<typename MultiIndexContainer,int N>
+struct nth_index_const_iterator;
+
+template<typename MultiIndexContainer,typename Tag>
+struct index_iterator;
+
+template<typename MultiIndexContainer,typename Tag>
+struct index_const_iterator;
+
+/* get and project functions not fwd declared due to problems
+ * with dependent typenames
+ */
+
+template<
+  typename Value1,typename IndexSpecifierList1,typename Allocator1,
+  typename Value2,typename IndexSpecifierList2,typename Allocator2
+>
+bool operator==(
+  const multi_index_container<Value1,IndexSpecifierList1,Allocator1>& x,
+  const multi_index_container<Value2,IndexSpecifierList2,Allocator2>& y);
+
+template<
+  typename Value1,typename IndexSpecifierList1,typename Allocator1,
+  typename Value2,typename IndexSpecifierList2,typename Allocator2
+>
+bool operator<(
+  const multi_index_container<Value1,IndexSpecifierList1,Allocator1>& x,
+  const multi_index_container<Value2,IndexSpecifierList2,Allocator2>& y);
+
+template<
+  typename Value1,typename IndexSpecifierList1,typename Allocator1,
+  typename Value2,typename IndexSpecifierList2,typename Allocator2
+>
+bool operator!=(
+  const multi_index_container<Value1,IndexSpecifierList1,Allocator1>& x,
+  const multi_index_container<Value2,IndexSpecifierList2,Allocator2>& y);
+
+template<
+  typename Value1,typename IndexSpecifierList1,typename Allocator1,
+  typename Value2,typename IndexSpecifierList2,typename Allocator2
+>
+bool operator>(
+  const multi_index_container<Value1,IndexSpecifierList1,Allocator1>& x,
+  const multi_index_container<Value2,IndexSpecifierList2,Allocator2>& y);
+
+template<
+  typename Value1,typename IndexSpecifierList1,typename Allocator1,
+  typename Value2,typename IndexSpecifierList2,typename Allocator2
+>
+bool operator>=(
+  const multi_index_container<Value1,IndexSpecifierList1,Allocator1>& x,
+  const multi_index_container<Value2,IndexSpecifierList2,Allocator2>& y);
+
+template<
+  typename Value1,typename IndexSpecifierList1,typename Allocator1,
+  typename Value2,typename IndexSpecifierList2,typename Allocator2
+>
+bool operator<=(
+  const multi_index_container<Value1,IndexSpecifierList1,Allocator1>& x,
+  const multi_index_container<Value2,IndexSpecifierList2,Allocator2>& y);
+
+template<typename Value,typename IndexSpecifierList,typename Allocator>
+void swap(
+  multi_index_container<Value,IndexSpecifierList,Allocator>& x,
+  multi_index_container<Value,IndexSpecifierList,Allocator>& y);
+
+} /* namespace multi_index */
+
+/* multi_index_container, being the main type of this library, is promoted to
+ * namespace boost.
+ */
+
+using multi_index::multi_index_container;
+
+} /* namespace boost */
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/access.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/access.hpp
new file mode 100644
index 00000000000..f6581accc91
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/serialization/access.hpp
@@ -0,0 +1,145 @@
+#ifndef BOOST_SERIALIZATION_ACCESS_HPP
+#define BOOST_SERIALIZATION_ACCESS_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// access.hpp: interface for serialization system.
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+#include <boost/config.hpp>
+
+namespace boost {
+
+namespace archive {
+namespace detail {
+    template<class Archive, class T>
+    class iserializer;
+    template<class Archive, class T>
+    class oserializer;
+} // namespace detail
+} // namespace archive
+
+namespace serialization {
+
+// forward declarations
+template<class Archive, class T>
+inline void serialize_adl(Archive &, T &, const unsigned int);
+namespace detail {
+    template<class Archive, class T>
+    struct member_saver;
+    template<class Archive, class T>
+    struct member_loader;
+} // namespace detail
+
+// use an "accessor class so that we can use: 
+// "friend class boost::serialization::access;" 
+// in any serialized class to permit clean, safe access to private class members
+// by the serialization system
+
+class access {
+public:
+    // grant access to "real" serialization defaults
+#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
+public:
+#else
+    template<class Archive, class T>
+    friend struct detail::member_saver;
+    template<class Archive, class T>
+    friend struct detail::member_loader;
+    template<class Archive, class T>
+    friend class archive::detail::iserializer;
+    template<class Archive, class T>
+    friend class archive::detail::oserializer;
+    template<class Archive, class T>
+    friend inline void serialize(
+        Archive & ar, 
+        T & t, 
+        const unsigned int file_version
+    );
+    template<class Archive, class T>
+    friend inline void save_construct_data(
+        Archive & ar, 
+        const T * t, 
+        const unsigned int file_version
+    );
+    template<class Archive, class T>
+    friend inline void load_construct_data(
+        Archive & ar, 
+        T * t, 
+        const unsigned int file_version
+    );
+#endif
+
+    // pass calls to users's class implementation
+    template<class Archive, class T>
+    static void member_save(
+        Archive & ar, 
+        //const T & t,
+        T & t,
+        const unsigned int file_version
+    ){
+        t.save(ar, file_version);
+    }
+    template<class Archive, class T>
+    static void member_load(
+        Archive & ar, 
+        T & t,
+        const unsigned int file_version
+    ){
+        t.load(ar, file_version);
+    }
+    template<class Archive, class T>
+    static void serialize(
+        Archive & ar, 
+        T & t, 
+        const unsigned int file_version
+    ){
+        // note: if you get a compile time error here with a
+        // message something like:
+        // cannot convert parameter 1 from <file type 1> to <file type 2 &>
+        // a likely possible cause is that the class T contains a 
+        // serialize function - but that serialize function isn't 
+        // a template and corresponds to a file type different than
+        // the class Archive.  To resolve this, don't include an
+        // archive type other than that for which the serialization
+        // function is defined!!!
+        t.serialize(ar, file_version);
+    }
+    template<class T>
+    static void destroy( const T * t) // const appropriate here?
+    {
+        // the const business is an MSVC 6.0 hack that should be
+        // benign on everything else
+        delete const_cast<T *>(t);
+    }
+    template<class T>
+    static void construct(T * t){
+        // default is inplace invocation of default constructor
+        // Note the :: before the placement new. Required if the
+        // class doesn't have a class-specific placement new defined.
+        ::new(t)T;
+    }
+    template<class T, class U>
+    static T & cast_reference(U & u){
+        return static_cast<T &>(u);
+    }
+    template<class T, class U>
+    static T * cast_pointer(U * u){
+        return static_cast<T *>(u);
+    }
+};
+
+} // namespace serialization
+} // namespace boost
+
+#endif // BOOST_SERIALIZATION_ACCESS_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/archive_input_unordered_map.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/archive_input_unordered_map.hpp
new file mode 100644
index 00000000000..ccf806b1813
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/serialization/archive_input_unordered_map.hpp
@@ -0,0 +1,85 @@
+#ifndef  BOOST_SERIALIZATION_ARCHIVE_INPUT_UNORDERED_MAP_HPP
+#define BOOST_SERIALIZATION_ARCHIVE_INPUT_UNORDERED_MAP_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// serialization/unordered_map.hpp:
+// serialization for stl unordered_map templates
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// (C) Copyright 2014 Jim Bell
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+#include <boost/config.hpp>
+#include <boost/serialization/nvp.hpp>
+#include <boost/serialization/detail/stack_constructor.hpp>
+#include <boost/serialization/utility.hpp>
+#include <boost/move/utility_core.hpp>
+
+namespace boost { 
+namespace serialization {
+namespace stl {
+
+// map input
+template<class Archive, class Container>
+struct archive_input_unordered_map
+{
+    inline void operator()(
+        Archive &ar, 
+        Container &s, 
+        const unsigned int v
+    ){
+        typedef typename Container::value_type type;
+        detail::stack_construct<Archive, type> t(ar, v);
+        ar >> boost::serialization::make_nvp("item", t.reference());
+        std::pair<typename Container::const_iterator, bool> result = 
+            s.insert(boost::move(t.reference()));
+        // note: the following presumes that the map::value_type was NOT tracked
+        // in the archive.  This is the usual case, but here there is no way
+        // to determine that.  
+        if(result.second){
+            ar.reset_object_address(
+                & (result.first->second),
+                & t.reference().second
+            );
+        }
+    }
+};
+
+// multimap input
+template<class Archive, class Container>
+struct archive_input_unordered_multimap
+{
+    inline void operator()(
+        Archive &ar, 
+        Container &s, 
+        const unsigned int v
+    ){
+        typedef typename Container::value_type type;
+        detail::stack_construct<Archive, type> t(ar, v);
+        ar >> boost::serialization::make_nvp("item", t.reference());
+        typename Container::const_iterator result =
+            s.insert(t.reference());
+        // note: the following presumes that the map::value_type was NOT tracked
+        // in the archive.  This is the usual case, but here there is no way
+        // to determine that.  
+        ar.reset_object_address(
+            & result->second,
+            & t.reference()
+        );
+    }
+};
+
+} // stl
+} // namespace serialization
+} // namespace boost
+
+#endif // BOOST_SERIALIZATION_ARCHIVE_INPUT_UNORDERED_MAP_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/archive_input_unordered_set.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/archive_input_unordered_set.hpp
new file mode 100644
index 00000000000..7f0003cc6a4
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/serialization/archive_input_unordered_set.hpp
@@ -0,0 +1,72 @@
+#ifndef  BOOST_SERIALIZATION_ARCHIVE_INPUT_UNORDERED_SET_HPP
+#define BOOST_SERIALIZATION_ARCHIVE_INPUT_UNORDERED_SET_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// archive_input_unordered_set.hpp
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// (C) Copyright 2014 Jim Bell
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+#include <utility>
+#include <boost/serialization/nvp.hpp>
+#include <boost/serialization/detail/stack_constructor.hpp>
+#include <boost/move/utility_core.hpp>
+
+namespace boost {
+namespace serialization {
+
+namespace stl {
+
+// unordered_set input
+template<class Archive, class Container>
+struct archive_input_unordered_set
+{
+    inline void operator()(
+        Archive &ar, 
+        Container &s, 
+        const unsigned int v
+    ){
+        typedef typename Container::value_type type;
+        detail::stack_construct<Archive, type> t(ar, v);
+        // borland fails silently w/o full namespace
+        ar >> boost::serialization::make_nvp("item", t.reference());
+        std::pair<typename Container::const_iterator, bool> result = 
+            s.insert(boost::move(t.reference()));
+        if(result.second)
+            ar.reset_object_address(& (* result.first), & t.reference());
+    }
+};
+
+// unordered_multiset input
+template<class Archive, class Container>
+struct archive_input_unordered_multiset
+{
+    inline void operator()(
+        Archive &ar, 
+        Container &s, 
+        const unsigned int v
+    ){
+        typedef typename Container::value_type type;
+        detail::stack_construct<Archive, type> t(ar, v);
+        ar >> boost::serialization::make_nvp("item", t.reference());
+        typename Container::const_iterator result =
+            s.insert(boost::move(t.reference()));
+        ar.reset_object_address(& (* result), & t.reference());
+    }
+};
+
+} // stl
+} // serialization
+} // boost
+
+#endif // BOOST_SERIALIZATION_ARCHIVE_INPUT_UNORDERED_SET_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/array.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/array.hpp
new file mode 100644
index 00000000000..612d1a61985
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/serialization/array.hpp
@@ -0,0 +1,48 @@
+#ifndef BOOST_SERIALIZATION_ARRAY_HPP
+#define BOOST_SERIALIZATION_ARRAY_HPP
+
+// (C) Copyright 2005 Matthias Troyer and Dave Abrahams
+// Use, modification and distribution is subject to the 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 serialization of <array>. If <array> not supported by the standard
+// library - this file becomes empty.  This is to avoid breaking backward
+// compatibiliy for applications which used this header to support
+// serialization of native arrays.  Code to serialize native arrays is
+// now always include by default.  RR
+
+#include <boost/config.hpp> // msvc 6.0 needs this for warning suppression
+
+#if defined(BOOST_NO_STDC_NAMESPACE)
+
+#include <iostream>
+#include <cstddef> // std::size_t
+namespace std{ 
+    using ::size_t; 
+} // namespace std
+#endif
+
+#include <boost/serialization/array_wrapper.hpp>
+
+#ifndef BOOST_NO_CXX11_HDR_ARRAY
+
+#include <array>
+#include <boost/serialization/nvp.hpp>
+
+namespace boost { namespace serialization {
+
+template <class Archive, class T, std::size_t N>
+void serialize(Archive& ar, std::array<T,N>& a, const unsigned int /* version */)
+{
+    ar & boost::serialization::make_nvp(
+        "elems",
+        *static_cast<T (*)[N]>(static_cast<void *>(a.data()))
+    );
+    
+}
+} } // end namespace boost::serialization
+
+#endif // BOOST_NO_CXX11_HDR_ARRAY
+
+#endif //BOOST_SERIALIZATION_ARRAY_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/array_optimization.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/array_optimization.hpp
new file mode 100644
index 00000000000..40dffba871a
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/serialization/array_optimization.hpp
@@ -0,0 +1,37 @@
+#ifndef BOOST_SERIALIZATION_ARRAY_OPTIMIZATON_HPP
+#define BOOST_SERIALIZATION_ARRAY_OPTIMIZATON_HPP
+
+// (C) Copyright 2005 Matthias Troyer and Dave Abrahams
+// Use, modification and distribution is subject to the 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> // msvc 6.0 needs this for warning suppression
+
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{ 
+    using ::size_t; 
+} // namespace std
+#endif
+
+#include <boost/mpl/always.hpp>
+#include <boost/mpl/apply.hpp>
+#include <boost/type_traits/remove_const.hpp>
+
+namespace boost { namespace serialization {
+
+template <class Archive>
+struct use_array_optimization : boost::mpl::always<boost::mpl::false_> {};
+
+} } // end namespace boost::serialization
+
+#define BOOST_SERIALIZATION_USE_ARRAY_OPTIMIZATION(Archive)           \
+namespace boost { namespace serialization {                           \
+template <> struct use_array_optimization<Archive> {                  \
+  template <class ValueType>                                          \
+  struct apply : boost::mpl::apply1<Archive::use_array_optimization   \
+      , typename boost::remove_const<ValueType>::type                 \
+    >::type {};                                                       \
+}; }}
+
+#endif //BOOST_SERIALIZATION_ARRAY_OPTIMIZATON_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/array_wrapper.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/array_wrapper.hpp
new file mode 100644
index 00000000000..adf436e15b4
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/serialization/array_wrapper.hpp
@@ -0,0 +1,121 @@
+#ifndef BOOST_SERIALIZATION_ARRAY_WRAPPER_HPP
+#define BOOST_SERIALIZATION_ARRAY_WRAPPER_HPP
+
+// (C) Copyright 2005 Matthias Troyer and Dave Abrahams
+// Use, modification and distribution is subject to the 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 <iostream>
+
+#include <boost/config.hpp> // msvc 6.0 needs this for warning suppression
+
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{ 
+    using ::size_t; 
+} // namespace std
+#endif
+
+#include <boost/serialization/nvp.hpp>
+#include <boost/serialization/split_member.hpp>
+#include <boost/serialization/wrapper.hpp>
+#include <boost/serialization/collection_size_type.hpp>
+#include <boost/serialization/array_optimization.hpp>
+#include <boost/mpl/always.hpp>
+#include <boost/mpl/apply.hpp>
+#include <boost/mpl/bool_fwd.hpp>
+#include <boost/type_traits/remove_const.hpp>
+
+namespace boost { namespace serialization {
+
+template<class T>
+class array_wrapper :
+    public wrapper_traits<const array_wrapper< T > >
+{
+private:
+    array_wrapper & operator=(const array_wrapper & rhs);
+    // note: I would like to make the copy constructor private but this breaks
+    // make_array.  So I make make_array a friend
+    template<class Tx, class S>
+    friend const boost::serialization::array_wrapper<Tx> make_array(Tx * t, S s);
+public:
+
+    array_wrapper(const array_wrapper & rhs) :
+        m_t(rhs.m_t),
+        m_element_count(rhs.m_element_count)
+    {}
+public:
+    array_wrapper(T * t, std::size_t s) :
+        m_t(t),
+        m_element_count(s)
+    {}
+
+    // default implementation
+    template<class Archive>
+    void serialize_optimized(Archive &ar, const unsigned int, mpl::false_ ) const
+    {
+      // default implemention does the loop
+      std::size_t c = count();
+      T * t = address();
+      while(0 < c--)
+            ar & boost::serialization::make_nvp("item", *t++);
+    }
+
+    // optimized implementation
+    template<class Archive>
+    void serialize_optimized(Archive &ar, const unsigned int version, mpl::true_ )
+    {
+      boost::serialization::split_member(ar, *this, version);
+    }
+
+    // default implementation
+    template<class Archive>
+    void save(Archive &ar, const unsigned int version) const
+    {
+      ar.save_array(*this,version);
+    }
+
+    // default implementation
+    template<class Archive>
+    void load(Archive &ar, const unsigned int version)
+    {
+      ar.load_array(*this,version);
+    }
+    
+    // default implementation
+    template<class Archive>
+    void serialize(Archive &ar, const unsigned int version)
+    {
+      typedef typename 
+          boost::serialization::use_array_optimization<Archive>::template apply<
+                    typename remove_const< T >::type 
+                >::type use_optimized;
+      serialize_optimized(ar,version,use_optimized());
+    }
+    
+    T * address() const
+    {
+      return m_t;
+    }
+
+    std::size_t count() const
+    {
+      return m_element_count;
+    }
+
+private:
+    T * const m_t;
+    const std::size_t m_element_count;
+};
+
+template<class T, class S>
+inline
+const array_wrapper< T > make_array(T* t, S s){
+    const array_wrapper< T > a(t, s);
+    return a;
+}
+
+} } // end namespace boost::serialization
+
+
+#endif //BOOST_SERIALIZATION_ARRAY_WRAPPER_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/assume_abstract.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/assume_abstract.hpp
new file mode 100644
index 00000000000..632f9312f5f
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/serialization/assume_abstract.hpp
@@ -0,0 +1,60 @@
+#ifndef BOOST_SERIALIZATION_ASSUME_ABSTRACT_HPP
+#define BOOST_SERIALIZATION_ASSUME_ABSTRACT_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// assume_abstract_class.hpp:
+
+// (C) Copyright 2008 Robert Ramey
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+// this is useful for compilers which don't support the boost::is_abstract
+
+#include <boost/type_traits/is_abstract.hpp>
+#include <boost/mpl/bool_fwd.hpp>
+
+#ifndef BOOST_NO_IS_ABSTRACT
+
+// if there is an intrinsic is_abstract defined, we don't have to do anything
+#define BOOST_SERIALIZATION_ASSUME_ABSTRACT(T)
+
+// but forward to the "official" is_abstract
+namespace boost {
+namespace serialization {
+    template<class T>
+    struct is_abstract : boost::is_abstract< T > {} ;
+} // namespace serialization
+} // namespace boost
+
+#else
+// we have to "make" one
+
+namespace boost {
+namespace serialization {
+    template<class T>
+    struct is_abstract : boost::false_type {};
+} // namespace serialization
+} // namespace boost
+
+// define a macro to make explicit designation of this more transparent
+#define BOOST_SERIALIZATION_ASSUME_ABSTRACT(T)        \
+namespace boost {                                     \
+namespace serialization {                             \
+template<>                                            \
+struct is_abstract< T > : boost::true_type {};        \
+template<>                                            \
+struct is_abstract< const T > : boost::true_type {};  \
+}}                                                    \
+/**/
+
+#endif // BOOST_NO_IS_ABSTRACT
+
+#endif //BOOST_SERIALIZATION_ASSUME_ABSTRACT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/base_object.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/base_object.hpp
new file mode 100644
index 00000000000..1a82cecd4b5
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/serialization/base_object.hpp
@@ -0,0 +1,100 @@
+#ifndef BOOST_SERIALIZATION_BASE_OBJECT_HPP
+#define BOOST_SERIALIZATION_BASE_OBJECT_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// base_object.hpp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+// if no archive headers have been included this is a no op
+// this is to permit BOOST_EXPORT etc to be included in a 
+// file declaration header
+
+#include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
+
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/int.hpp>
+#include <boost/mpl/identity.hpp>
+
+#include <boost/type_traits/is_base_and_derived.hpp>
+#include <boost/type_traits/is_pointer.hpp>
+#include <boost/type_traits/is_const.hpp>
+#include <boost/type_traits/is_polymorphic.hpp>
+
+#include <boost/static_assert.hpp>
+#include <boost/serialization/access.hpp>
+#include <boost/serialization/force_include.hpp>
+#include <boost/serialization/void_cast_fwd.hpp>
+
+namespace boost {
+namespace serialization {
+
+namespace detail
+{
+    // get the base type for a given derived type
+    // preserving the const-ness
+    template<class B, class D>
+    struct base_cast
+    {
+        typedef typename
+        mpl::if_<
+            is_const<D>,
+            const B,
+            B
+        >::type type;
+        BOOST_STATIC_ASSERT(is_const<type>::value == is_const<D>::value);
+    };
+
+    // only register void casts if the types are polymorphic
+    template<class Base, class Derived>
+    struct base_register
+    {
+        struct polymorphic {
+            static void const * invoke(){
+                Base const * const b = 0;
+                Derived const * const d = 0;
+                return & void_cast_register(d, b);
+            }
+        };
+        struct non_polymorphic {
+            static void const * invoke(){
+                return 0;
+            }
+        };
+        static void const * invoke(){
+            typedef typename mpl::eval_if<
+                is_polymorphic<Base>,
+                mpl::identity<polymorphic>,
+                mpl::identity<non_polymorphic>
+            >::type type;
+            return type::invoke();
+        }
+    };
+
+} // namespace detail
+template<class Base, class Derived>
+typename detail::base_cast<Base, Derived>::type & 
+base_object(Derived &d)
+{
+    BOOST_STATIC_ASSERT(( is_base_and_derived<Base,Derived>::value));
+    BOOST_STATIC_ASSERT(! is_pointer<Derived>::value);
+    typedef typename detail::base_cast<Base, Derived>::type type;
+    detail::base_register<type, Derived>::invoke();
+    return access::cast_reference<type, Derived>(d);
+}
+
+} // namespace serialization
+} // namespace boost
+
+#endif // BOOST_SERIALIZATION_BASE_OBJECT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/binary_object.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/binary_object.hpp
new file mode 100644
index 00000000000..5c9038e5a9f
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/serialization/binary_object.hpp
@@ -0,0 +1,79 @@
+#ifndef BOOST_SERIALIZATION_BINARY_OBJECT_HPP
+#define BOOST_SERIALIZATION_BINARY_OBJECT_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// nvp.hpp: interface for serialization system.
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+#include <boost/assert.hpp>
+
+#include <cstddef> // std::size_t
+#include <boost/config.hpp>
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{ 
+    using ::size_t; 
+} // namespace std
+#endif
+
+#include <boost/preprocessor/stringize.hpp>
+#include <boost/serialization/tracking.hpp>
+#include <boost/serialization/level.hpp>
+#include <boost/serialization/split_member.hpp>
+#include <boost/serialization/nvp.hpp>
+#include <boost/serialization/wrapper.hpp>
+
+namespace boost {
+namespace serialization {
+
+struct binary_object :
+    public wrapper_traits<nvp<const binary_object> >
+{
+    void const * m_t;
+    std::size_t m_size;
+    template<class Archive>
+    void save(Archive & ar, const unsigned int /* file_version */) const {
+        ar.save_binary(m_t, m_size);
+    }
+    template<class Archive>
+    void load(Archive & ar, const unsigned int /* file_version */) const {
+        ar.load_binary(const_cast<void *>(m_t), m_size);
+    }
+    BOOST_SERIALIZATION_SPLIT_MEMBER()
+    binary_object & operator=(const binary_object & rhs) {
+        m_t = rhs.m_t;
+        m_size = rhs.m_size;
+        return *this;
+    }
+    binary_object(const void * const t, std::size_t size) :
+        m_t(t),
+        m_size(size)
+    {}
+    binary_object(const binary_object & rhs) :
+        m_t(rhs.m_t),
+        m_size(rhs.m_size)
+    {}
+};
+
+// just a little helper to support the convention that all serialization
+// wrappers follow the naming convention make_xxxxx
+inline 
+const binary_object
+make_binary_object(const void * t, std::size_t size){
+    return binary_object(t, size);
+}
+
+} // namespace serialization
+} // boost
+
+#endif // BOOST_SERIALIZATION_BINARY_OBJECT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/bitset.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/bitset.hpp
new file mode 100644
index 00000000000..78f9bd74336
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/serialization/bitset.hpp
@@ -0,0 +1,75 @@
+/*!
+ * \file      bitset.hpp
+ * \brief     Provides Boost.Serialization support for std::bitset
+ * \author    Brian Ravnsgaard Riis
+ * \author    Kenneth Riddile
+ * \date      16.09.2004, updated 04.03.2009
+ * \copyright 2004 Brian Ravnsgaard Riis
+ * \license   Boost Software License 1.0
+ */
+#ifndef BOOST_SERIALIZATION_BITSET_HPP
+#define BOOST_SERIALIZATION_BITSET_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+#include <bitset>
+#include <cstddef> // size_t
+
+#include <boost/config.hpp>
+#include <boost/serialization/split_free.hpp>
+#include <boost/serialization/string.hpp>
+#include <boost/serialization/nvp.hpp>
+
+namespace boost{
+namespace serialization{
+
+template <class Archive, std::size_t size>
+inline void save(
+    Archive & ar,
+    std::bitset<size> const & t,
+    const unsigned int /* version */
+){
+    const std::string bits = t.template to_string<
+        std::string::value_type,
+        std::string::traits_type,
+        std::string::allocator_type
+    >();
+    ar << BOOST_SERIALIZATION_NVP( bits );
+}
+
+template <class Archive, std::size_t size>
+inline void load(
+    Archive & ar,
+    std::bitset<size> & t,
+    const unsigned int /* version */
+){
+    std::string bits;
+    ar >> BOOST_SERIALIZATION_NVP( bits );
+    t = std::bitset<size>(bits);
+}
+
+template <class Archive, std::size_t size>
+inline void serialize(
+    Archive & ar,
+    std::bitset<size> & t,
+    const unsigned int version
+){
+    boost::serialization::split_free( ar, t, version );
+}
+
+// don't track bitsets since that would trigger tracking
+// all over the program - which probably would be a surprise.
+// also, tracking would be hard to implement since, we're
+// serialization a representation of the data rather than
+// the data itself.
+template <std::size_t size>
+struct tracking_level<std::bitset<size> >
+    : mpl::int_<track_never> {} ;
+
+} //serialization
+} //boost
+
+#endif // BOOST_SERIALIZATION_BITSET_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/boost_array.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/boost_array.hpp
new file mode 100644
index 00000000000..d564ff15de0
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/serialization/boost_array.hpp
@@ -0,0 +1,33 @@
+#ifndef BOOST_SERIALIZATION_ARRAY_HPP
+#define BOOST_SERIALIZATION_ARRAY_HPP
+
+// (C) Copyright 2005 Matthias Troyer and Dave Abrahams
+// Use, modification and distribution is subject to the 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 <iostream>
+
+#include <boost/config.hpp> // msvc 6.0 needs this for warning suppression
+
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{ 
+    using ::size_t; 
+} // namespace std
+#endif
+
+#include <boost/serialization/nvp.hpp>
+#include <boost/array.hpp>
+
+namespace boost { namespace serialization {
+// implement serialization for boost::array
+template <class Archive, class T, std::size_t N>
+void serialize(Archive& ar, boost::array<T,N>& a, const unsigned int /* version */)
+{
+    ar & boost::serialization::make_nvp("elems", a.elems);
+}
+
+} } // end namespace boost::serialization
+
+
+#endif //BOOST_SERIALIZATION_ARRAY_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/boost_unordered_map.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/boost_unordered_map.hpp
new file mode 100644
index 00000000000..8913b31f9e6
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/serialization/boost_unordered_map.hpp
@@ -0,0 +1,154 @@
+#ifndef  BOOST_SERIALIZATION_UNORDERED_MAP_HPP
+#define BOOST_SERIALIZATION_UNORDERED_MAP_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// serialization/unordered_map.hpp:
+// serialization for stl unordered_map templates
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// (C) Copyright 2014 Jim Bell
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+#include <boost/config.hpp>
+
+#include <boost/unordered_map.hpp>
+
+#include <boost/serialization/utility.hpp>
+#include <boost/serialization/unordered_collections_save_imp.hpp>
+#include <boost/serialization/unordered_collections_load_imp.hpp>
+#include <boost/serialization/archive_input_unordered_map.hpp>
+#include <boost/serialization/split_free.hpp>
+
+namespace boost { 
+namespace serialization {
+
+template<
+    class Archive, 
+    class Key, 
+    class HashFcn, 
+    class EqualKey,
+    class Allocator
+>
+inline void save(
+    Archive & ar,
+    const boost::unordered_map<Key, HashFcn, EqualKey, Allocator> &t,
+    const unsigned int /*file_version*/
+){
+    boost::serialization::stl::save_unordered_collection<
+        Archive, 
+        boost::unordered_map<Key, HashFcn, EqualKey, Allocator>
+    >(ar, t);
+}
+
+template<
+    class Archive, 
+    class Key, 
+    class HashFcn, 
+    class EqualKey,
+    class Allocator
+>
+inline void load(
+    Archive & ar,
+    boost::unordered_map<Key, HashFcn, EqualKey, Allocator> &t,
+    const unsigned int /*file_version*/
+){
+    boost::serialization::stl::load_unordered_collection<
+        Archive,
+        boost::unordered_map<Key, HashFcn, EqualKey, Allocator>,
+        boost::serialization::stl::archive_input_unordered_map<
+            Archive, 
+            boost::unordered_map<Key, HashFcn, EqualKey, Allocator>
+        >
+    >(ar, t);
+}
+
+// split non-intrusive serialization function member into separate
+// non intrusive save/load member functions
+template<
+    class Archive, 
+    class Key, 
+    class HashFcn, 
+    class EqualKey,
+    class Allocator
+>
+inline void serialize(
+    Archive & ar,
+    boost::unordered_map<Key, HashFcn, EqualKey, Allocator> &t,
+    const unsigned int file_version
+){
+    boost::serialization::split_free(ar, t, file_version);
+}
+
+// unordered_multimap
+template<
+    class Archive, 
+    class Key, 
+    class HashFcn, 
+    class EqualKey,
+    class Allocator
+>
+inline void save(
+    Archive & ar,
+    const boost::unordered_multimap<Key, HashFcn, EqualKey, Allocator> &t,
+    const unsigned int /*file_version*/
+){
+    boost::serialization::stl::save_unordered_collection<
+        Archive, 
+        boost::unordered_multimap<Key, HashFcn, EqualKey, Allocator>
+    >(ar, t);
+}
+
+template<
+    class Archive, 
+    class Key, 
+    class HashFcn, 
+    class EqualKey,
+    class Allocator
+>
+inline void load(
+    Archive & ar,
+    boost::unordered_multimap<
+        Key, HashFcn, EqualKey, Allocator
+    > &t,
+    const unsigned int /*file_version*/
+){
+    boost::serialization::stl::load_unordered_collection<
+        Archive,
+        boost::unordered_multimap<Key, HashFcn, EqualKey, Allocator>,
+        boost::serialization::stl::archive_input_unordered_multimap<
+            Archive, 
+            boost::unordered_multimap<Key, HashFcn, EqualKey, Allocator>
+        >
+    >(ar, t);
+}
+
+// split non-intrusive serialization function member into separate
+// non intrusive save/load member functions
+template<
+    class Archive, 
+    class Key, 
+    class HashFcn, 
+    class EqualKey,
+    class Allocator
+>
+inline void serialize(
+    Archive & ar,
+    boost::unordered_multimap<Key, HashFcn, EqualKey, Allocator> &t,
+    const unsigned int file_version
+){
+    boost::serialization::split_free(ar, t, file_version);
+}
+
+} // namespace serialization
+} // namespace boost
+
+#endif // BOOST_SERIALIZATION_UNORDERED_MAP_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/boost_unordered_set.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/boost_unordered_set.hpp
new file mode 100644
index 00000000000..307c7819cbd
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/serialization/boost_unordered_set.hpp
@@ -0,0 +1,150 @@
+#ifndef  BOOST_SERIALIZATION_BOOST_UNORDERED_SET_HPP
+#define BOOST_SERIALIZATION_BOOST_UNORDERED_SET_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// unordered_set.hpp: serialization for boost unordered_set templates
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// (C) Copyright 2014 Jim Bell
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+#include <boost/config.hpp>
+
+#include <boost/unordered_set.hpp>
+
+#include <boost/serialization/unordered_collections_save_imp.hpp>
+#include <boost/serialization/unordered_collections_load_imp.hpp>
+#include <boost/serialization/archive_input_unordered_set.hpp>
+#include <boost/serialization/split_free.hpp>
+
+namespace boost { 
+namespace serialization {
+
+template<
+    class Archive, 
+    class Key, 
+    class HashFcn, 
+    class EqualKey,
+    class Allocator
+>
+inline void save(
+    Archive & ar,
+    const boost::unordered_set<Key, HashFcn, EqualKey, Allocator> &t,
+    const unsigned int /*file_version*/
+){
+    boost::serialization::stl::save_unordered_collection<
+        Archive, 
+        boost::unordered_set<Key, HashFcn, EqualKey, Allocator>
+    >(ar, t);
+}
+
+template<
+    class Archive, 
+    class Key, 
+    class HashFcn, 
+    class EqualKey,
+    class Allocator
+>
+inline void load(
+    Archive & ar,
+    boost::unordered_set<Key, HashFcn, EqualKey, Allocator> &t,
+    const unsigned int /*file_version*/
+){
+    boost::serialization::stl::load_unordered_collection<
+        Archive,
+        boost::unordered_set<Key, HashFcn, EqualKey, Allocator>,
+        boost::serialization::stl::archive_input_unordered_set<
+            Archive, 
+            boost::unordered_set<Key, HashFcn, EqualKey, Allocator>
+        >
+    >(ar, t);
+}
+
+// split non-intrusive serialization function member into separate
+// non intrusive save/load member functions
+template<
+    class Archive, 
+    class Key, 
+    class HashFcn, 
+    class EqualKey,
+    class Allocator
+>
+inline void serialize(
+    Archive & ar,
+    boost::unordered_set<Key, HashFcn, EqualKey, Allocator> &t,
+    const unsigned int file_version
+){
+    boost::serialization::split_free(ar, t, file_version);
+}
+
+// unordered_multiset
+template<
+    class Archive, 
+    class Key, 
+    class HashFcn, 
+    class EqualKey,
+    class Allocator
+>
+inline void save(
+    Archive & ar,
+    const boost::unordered_multiset<Key, HashFcn, EqualKey, Allocator> &t,
+    const unsigned int /*file_version*/
+){
+    boost::serialization::stl::save_unordered_collection<
+        Archive, 
+        boost::unordered_multiset<Key, HashFcn, EqualKey, Allocator>
+    >(ar, t);
+}
+
+template<
+    class Archive, 
+    class Key, 
+    class HashFcn, 
+    class EqualKey,
+    class Allocator
+>
+inline void load(
+    Archive & ar,
+    boost::unordered_multiset<Key, HashFcn, EqualKey, Allocator> &t,
+    const unsigned int /*file_version*/
+){
+    boost::serialization::stl::load_unordered_collection<
+        Archive,
+        boost::unordered_multiset<Key, HashFcn, EqualKey, Allocator>,
+        boost::serialization::stl::archive_input_unordered_multiset<
+            Archive,
+            boost::unordered_multiset<Key, HashFcn, EqualKey, Allocator>
+        >
+    >(ar, t);
+}
+
+// split non-intrusive serialization function member into separate
+// non intrusive save/load member functions
+template<
+    class Archive, 
+    class Key, 
+    class HashFcn, 
+    class EqualKey,
+    class Allocator
+>
+inline void serialize(
+    Archive & ar,
+    boost::unordered_multiset<Key, HashFcn, EqualKey, Allocator> &t,
+    const unsigned int file_version
+){
+    boost::serialization::split_free(ar, t, file_version);
+}
+
+} // namespace serialization
+} // namespace boost
+
+#endif // BOOST_SERIALIZATION_BOOST_UNORDERED_SET_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/collection_size_type.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/collection_size_type.hpp
new file mode 100644
index 00000000000..2dd8fa72584
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/serialization/collection_size_type.hpp
@@ -0,0 +1,62 @@
+#ifndef BOOST_SERIALIZATION_COLLECTION_SIZE_TYPE_HPP
+#define BOOST_SERIALIZATION_COLLECTION_SIZE_TYPE_HPP
+
+// (C) Copyright 2005 Matthias Troyer
+// Use, modification and distribution is subject to the 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 <cstddef> // size_t
+#include <boost/serialization/strong_typedef.hpp>
+#include <boost/serialization/level.hpp>
+#include <boost/serialization/split_free.hpp>
+#include <boost/serialization/is_bitwise_serializable.hpp>
+
+namespace boost { 
+namespace serialization {
+
+//BOOST_STRONG_TYPEDEF(std::size_t, collection_size_type)
+
+class collection_size_type {
+private:
+    typedef std::size_t base_type;
+    base_type t;
+public:
+    collection_size_type(): t(0) {};
+    explicit collection_size_type(const std::size_t & t_) : 
+        t(t_)
+    {}
+    collection_size_type(const collection_size_type & t_) : 
+        t(t_.t)
+    {}
+    collection_size_type & operator=(const collection_size_type & rhs){
+        t = rhs.t; 
+        return *this;
+    }
+    collection_size_type & operator=(const unsigned int & rhs){
+        t = rhs; 
+        return *this;
+    }
+    // used for text output
+    operator base_type () const {
+        return t;
+    }                
+    // used for text input
+    operator base_type & () {
+        return t;
+    }                
+    bool operator==(const collection_size_type & rhs) const {
+        return t == rhs.t;
+    } 
+    bool operator<(const collection_size_type & rhs) const {
+        return t < rhs.t;
+    }   
+};
+
+
+} } // end namespace boost::serialization
+
+BOOST_CLASS_IMPLEMENTATION(collection_size_type, primitive_type)
+BOOST_IS_BITWISE_SERIALIZABLE(collection_size_type)
+
+#endif //BOOST_SERIALIZATION_COLLECTION_SIZE_TYPE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/collection_traits.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/collection_traits.hpp
new file mode 100644
index 00000000000..3ec9401eff0
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/serialization/collection_traits.hpp
@@ -0,0 +1,79 @@
+#ifndef BOOST_SERIALIZATION_COLLECTION_TRAITS_HPP
+#define BOOST_SERIALIZATION_COLLECTION_TRAITS_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// collection_traits.hpp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+// This header assigns a level implemenation trait to a collection type
+// for all primitives.  It is needed so that archives which are meant to be
+// portable don't write class information in the archive.  Since, not all
+// compiles recognize the same set of primitive types, the possibility
+// exists for archives to be non-portable if class information for primitive
+// types is included.  This is addressed by the following macros.
+#include <boost/config.hpp>
+//#include <boost/mpl/integral_c.hpp>
+#include <boost/mpl/integral_c_tag.hpp>
+
+#include <boost/cstdint.hpp>
+#include <boost/integer_traits.hpp>
+#include <climits> // ULONG_MAX
+#include <boost/serialization/level.hpp>
+
+#define BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(T, C)          \
+template<>                                                          \
+struct implementation_level< C < T > > {                            \
+    typedef mpl::integral_c_tag tag;                                \
+    typedef mpl::int_<object_serializable> type;                    \
+    BOOST_STATIC_CONSTANT(int, value = object_serializable);        \
+};                                                                  \
+/**/
+
+#if defined(BOOST_NO_CWCHAR) || defined(BOOST_NO_INTRINSIC_WCHAR_T)
+    #define BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER_WCHAR(C)
+#else
+    #define BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER_WCHAR(C)   \
+    BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(wchar_t, C)        \
+    /**/
+#endif
+
+#if defined(BOOST_HAS_LONG_LONG)
+    #define BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER_INT64(C)    \
+    BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(boost::long_long_type, C)  \
+    BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(boost::ulong_long_type, C) \
+    /**/
+#else
+    #define BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER_INT64(C)
+#endif
+
+#define BOOST_SERIALIZATION_COLLECTION_TRAITS(C)                     \
+    namespace boost { namespace serialization {                      \
+    BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(bool, C)            \
+    BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(char, C)            \
+    BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(signed char, C)     \
+    BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(unsigned char, C)   \
+    BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(signed int, C)      \
+    BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(unsigned int, C)    \
+    BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(signed long, C)     \
+    BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(unsigned long, C)   \
+    BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(float, C)           \
+    BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(double, C)          \
+    BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(unsigned short, C)  \
+    BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(signed short, C)    \
+    BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER_INT64(C)            \
+    BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER_WCHAR(C)            \
+    } }                                                              \
+    /**/
+
+#endif // BOOST_SERIALIZATION_COLLECTION_TRAITS
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/collections_load_imp.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/collections_load_imp.hpp
new file mode 100644
index 00000000000..e042c0c130d
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/serialization/collections_load_imp.hpp
@@ -0,0 +1,106 @@
+#ifndef  BOOST_SERIALIZATION_COLLECTIONS_LOAD_IMP_HPP
+#define BOOST_SERIALIZATION_COLLECTIONS_LOAD_IMP_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+#if defined(_MSC_VER) && (_MSC_VER <= 1020)
+#  pragma warning (disable : 4786) // too long name, harmless warning
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// collections_load_imp.hpp: serialization for loading stl collections
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+// helper function templates for serialization of collections
+
+#include <boost/assert.hpp>
+#include <cstddef> // size_t
+#include <boost/config.hpp> // msvc 6.0 needs this for warning suppression
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{ 
+    using ::size_t; 
+} // namespace std
+#endif
+#include <boost/detail/workaround.hpp>
+
+#include <boost/archive/detail/basic_iarchive.hpp>
+#include <boost/serialization/access.hpp>
+#include <boost/serialization/nvp.hpp>
+#include <boost/serialization/detail/stack_constructor.hpp>
+#include <boost/serialization/collection_size_type.hpp>
+#include <boost/serialization/item_version_type.hpp>
+#include <boost/serialization/detail/is_default_constructible.hpp>
+#include <boost/utility/enable_if.hpp>
+#include <boost/move/utility_core.hpp>
+
+namespace boost{
+namespace serialization {
+namespace stl {
+
+//////////////////////////////////////////////////////////////////////
+// implementation of serialization for STL containers
+//
+
+template<
+    class Archive,
+    class T
+>
+typename boost::enable_if<
+    typename detail::is_default_constructible<
+        typename T::value_type
+    >,
+    void
+>::type
+collection_load_impl(
+    Archive & ar,
+    T & t,
+    collection_size_type count,
+    item_version_type /*item_version*/
+){
+    t.resize(count);
+    typename T::iterator hint;
+    hint = t.begin();
+    while(count-- > 0){
+        ar >> boost::serialization::make_nvp("item", *hint++);
+    }
+}
+
+template<
+    class Archive,
+    class T
+>
+typename boost::disable_if<
+    typename detail::is_default_constructible<
+        typename T::value_type
+    >,
+    void
+>::type
+collection_load_impl(
+    Archive & ar,
+    T & t,
+    collection_size_type count,
+    item_version_type item_version
+){
+    t.clear();
+    while(count-- > 0){
+        detail::stack_construct<Archive, typename T::value_type> u(ar, item_version);
+        ar >> boost::serialization::make_nvp("item", u.reference());
+        t.push_back(boost::move(u.reference()));
+        ar.reset_object_address(& t.back() , & u.reference());
+     }
+}
+
+} // namespace stl 
+} // namespace serialization
+} // namespace boost
+
+#endif //BOOST_SERIALIZATION_COLLECTIONS_LOAD_IMP_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/collections_save_imp.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/collections_save_imp.hpp
new file mode 100644
index 00000000000..f3cabfcf3f5
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/serialization/collections_save_imp.hpp
@@ -0,0 +1,82 @@
+#ifndef BOOST_SERIALIZATION_COLLECTIONS_SAVE_IMP_HPP
+#define BOOST_SERIALIZATION_COLLECTIONS_SAVE_IMP_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// collections_save_imp.hpp: serialization for stl collections
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+// helper function templates for serialization of collections
+
+#include <boost/config.hpp>
+#include <boost/serialization/nvp.hpp>
+#include <boost/serialization/serialization.hpp>
+#include <boost/serialization/version.hpp>
+#include <boost/serialization/collection_size_type.hpp>
+#include <boost/serialization/item_version_type.hpp>
+
+namespace boost{
+namespace serialization {
+namespace stl {
+
+//////////////////////////////////////////////////////////////////////
+// implementation of serialization for STL containers
+//
+
+template<class Archive, class Container>
+inline void save_collection(
+    Archive & ar,
+    const Container &s,
+    collection_size_type count)
+{
+    ar << BOOST_SERIALIZATION_NVP(count);
+    // record number of elements
+    const item_version_type item_version(
+        version<typename Container::value_type>::value
+    );
+    #if 0
+        boost::archive::library_version_type library_version(
+            ar.get_library_version()
+        );
+        if(boost::archive::library_version_type(3) < library_version){
+            ar << BOOST_SERIALIZATION_NVP(item_version);
+        }
+    #else
+        ar << BOOST_SERIALIZATION_NVP(item_version);
+    #endif
+
+    typename Container::const_iterator it = s.begin();
+    while(count-- > 0){
+        // note borland emits a no-op without the explicit namespace
+        boost::serialization::save_construct_data_adl(
+            ar, 
+            &(*it), 
+            item_version
+        );
+        ar << boost::serialization::make_nvp("item", *it++);
+    }
+}
+
+template<class Archive, class Container>
+inline void save_collection(Archive & ar, const Container &s)
+{
+    // record number of elements
+    collection_size_type count(s.size());
+    save_collection(ar, s, count);
+}
+
+} // namespace stl 
+} // namespace serialization
+} // namespace boost
+
+#endif //BOOST_SERIALIZATION_COLLECTIONS_SAVE_IMP_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/complex.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/complex.hpp
new file mode 100644
index 00000000000..b4ef44cf973
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/serialization/complex.hpp
@@ -0,0 +1,81 @@
+#ifndef  BOOST_SERIALIZATION_COMPLEX_HPP
+#define BOOST_SERIALIZATION_COMPLEX_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// serialization/utility.hpp:
+// serialization for stl utility templates
+
+// (C) Copyright 2007 Matthias Troyer . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+#include <complex>
+#include <boost/config.hpp>
+
+#include <boost/serialization/nvp.hpp>
+#include <boost/serialization/is_bitwise_serializable.hpp>
+#include <boost/serialization/split_free.hpp>
+
+namespace boost { 
+namespace serialization {
+
+template<class Archive, class T>
+inline void serialize(
+    Archive & ar,
+    std::complex< T > & t,
+    const unsigned int file_version 
+){
+    boost::serialization::split_free(ar, t, file_version);
+}
+
+template<class Archive, class T>
+inline void save(
+    Archive & ar,
+    std::complex< T > const & t,
+    const unsigned int /* file_version */
+){
+    const T re = t.real();
+    const T im = t.imag();
+    ar << boost::serialization::make_nvp("real", re);
+    ar << boost::serialization::make_nvp("imag", im);
+}
+
+template<class Archive, class T>
+inline void load(
+    Archive & ar,
+    std::complex< T >& t,
+    const unsigned int /* file_version */ 
+){
+    T re;
+    T im;
+    ar >> boost::serialization::make_nvp("real", re);
+    ar >> boost::serialization::make_nvp("imag", im);
+    t = std::complex< T >(re,im);
+}
+
+// specialization of serialization traits for complex
+template <class T>
+struct is_bitwise_serializable<std::complex< T > >
+    : public is_bitwise_serializable< T > {};
+
+template <class T>
+struct implementation_level<std::complex< T > >
+    : mpl::int_<object_serializable> {} ;
+
+// treat complex just like builtin arithmetic types for tracking
+template <class T>
+struct tracking_level<std::complex< T > >
+    : mpl::int_<track_never> {} ;
+
+} // serialization
+} // namespace boost
+
+#endif // BOOST_SERIALIZATION_COMPLEX_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/config.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/config.hpp
new file mode 100644
index 00000000000..ea8cb9239ed
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/serialization/config.hpp
@@ -0,0 +1,74 @@
+#ifndef BOOST_SERIALIZATION_CONFIG_HPP
+#define BOOST_SERIALIZATION_CONFIG_HPP
+
+//  config.hpp  ---------------------------------------------//
+
+//  (c) Copyright Robert Ramey 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)
+
+//  See library home page at http://www.boost.org/libs/serialization
+
+//----------------------------------------------------------------------------// 
+
+// This header implements separate compilation features as described in
+// http://www.boost.org/more/separate_compilation.html
+
+#include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
+
+// note: this version incorporates the related code into the the 
+// the same library as BOOST_ARCHIVE.  This could change some day in the
+// future
+
+// if BOOST_SERIALIZATION_DECL is defined undefine it now:
+#ifdef BOOST_SERIALIZATION_DECL
+    #undef BOOST_SERIALIZATION_DECL
+#endif
+
+// we need to import/export our code only if the user has specifically
+// asked for it by defining either BOOST_ALL_DYN_LINK if they want all boost
+// libraries to be dynamically linked, or BOOST_SERIALIZATION_DYN_LINK
+// if they want just this one to be dynamically liked:
+#if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_SERIALIZATION_DYN_LINK)
+    #if !defined(BOOST_DYN_LINK)
+        #define BOOST_DYN_LINK
+    #endif
+    // export if this is our own source, otherwise import:
+    #if defined(BOOST_SERIALIZATION_SOURCE)
+        #define BOOST_SERIALIZATION_DECL BOOST_SYMBOL_EXPORT
+    #else
+        #define BOOST_SERIALIZATION_DECL BOOST_SYMBOL_IMPORT
+    #endif // defined(BOOST_SERIALIZATION_SOURCE)
+#endif // defined(BOOST_ALL_DYN_LINK) || defined(BOOST_SERIALIZATION_DYN_LINK)
+
+// if BOOST_SERIALIZATION_DECL isn't defined yet define it now:
+#ifndef BOOST_SERIALIZATION_DECL
+    #define BOOST_SERIALIZATION_DECL
+#endif
+
+//  enable automatic library variant selection  ------------------------------// 
+
+#if !defined(BOOST_ALL_NO_LIB) && !defined(BOOST_SERIALIZATION_NO_LIB) \
+&&  !defined(BOOST_ARCHIVE_SOURCE) && !defined(BOOST_WARCHIVE_SOURCE)  \
+&&  !defined(BOOST_SERIALIZATION_SOURCE)
+    //
+    // Set the name of our library, this will get undef'ed by auto_link.hpp
+    // once it's done with it:
+    //
+    #define BOOST_LIB_NAME boost_serialization
+    //
+    // If we're importing code from a dll, then tell auto_link.hpp about it:
+    //
+    #if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_SERIALIZATION_DYN_LINK)
+    #  define BOOST_DYN_LINK
+    #endif
+    //
+    // And include the header that does the work:
+    //
+    #include <boost/config/auto_link.hpp>
+
+#endif  
+
+#endif // BOOST_SERIALIZATION_CONFIG_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/deque.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/deque.hpp
new file mode 100644
index 00000000000..bba81364ce2
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/serialization/deque.hpp
@@ -0,0 +1,80 @@
+#ifndef  BOOST_SERIALIZATION_DEQUE_HPP
+#define BOOST_SERIALIZATION_DEQUE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// deque.hpp
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+#include <deque>
+
+#include <boost/config.hpp>
+
+#include <boost/archive/basic_archive.hpp>
+
+#include <boost/serialization/collections_save_imp.hpp>
+#include <boost/serialization/collections_load_imp.hpp>
+#include <boost/serialization/split_free.hpp>
+
+namespace boost { 
+namespace serialization {
+
+template<class Archive, class U, class Allocator>
+inline void save(
+    Archive & ar,
+    const std::deque<U, Allocator> &t,
+    const unsigned int /* file_version */
+){
+    boost::serialization::stl::save_collection<
+        Archive, std::deque<U, Allocator> 
+    >(ar, t);
+}
+
+template<class Archive, class U, class Allocator>
+inline void load(
+    Archive & ar,
+    std::deque<U, Allocator> &t,
+    const unsigned int /* file_version */
+){
+    const boost::archive::library_version_type library_version(
+        ar.get_library_version()
+    );
+    // retrieve number of elements
+    item_version_type item_version(0);
+    collection_size_type count;
+    ar >> BOOST_SERIALIZATION_NVP(count);
+    if(boost::archive::library_version_type(3) < library_version){
+        ar >> BOOST_SERIALIZATION_NVP(item_version);
+    }
+    stl::collection_load_impl(ar, t, count, item_version);
+}
+
+// split non-intrusive serialization function member into separate
+// non intrusive save/load member functions
+template<class Archive, class U, class Allocator>
+inline void serialize(
+    Archive & ar,
+    std::deque<U, Allocator> &t,
+    const unsigned int file_version
+){
+    boost::serialization::split_free(ar, t, file_version);
+}
+
+} // namespace serialization
+} // namespace boost
+
+#include <boost/serialization/collection_traits.hpp>
+
+BOOST_SERIALIZATION_COLLECTION_TRAITS(std::deque)
+
+#endif // BOOST_SERIALIZATION_DEQUE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/detail/is_default_constructible.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/detail/is_default_constructible.hpp
new file mode 100644
index 00000000000..4d20b13bf3e
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/serialization/detail/is_default_constructible.hpp
@@ -0,0 +1,54 @@
+#ifndef  BOOST_SERIALIZATION_DETAIL_IS_DEFAULT_CONSTRUCTIBLE_HPP
+#define BOOST_SERIALIZATION_DETAIL_IS_DEFAULT_CONSTRUCTIBLE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// is_default_constructible.hpp: serialization for loading stl collections
+//
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+#include <boost/config.hpp>
+
+#if ! defined(BOOST_NO_CXX11_HDR_TYPE_TRAITS)
+    #include <type_traits>
+    namespace boost{
+    namespace serialization {
+    namespace detail {
+
+    template<typename T>
+    struct is_default_constructible : public std::is_default_constructible<T> {};
+
+    } // detail
+    } // serializaition
+    } // boost
+#else
+    // we don't have standard library support for is_default_constructible
+    // so we fake it by using boost::has_trivial_construtor.  But this is not
+    // actually correct because it's possible that a default constructor
+    // to be non trivial. So when using this, make sure you're not using your
+    // own definition of of T() but are using the actual default one!
+    #include <boost/type_traits/has_trivial_constructor.hpp>
+    namespace boost{
+    namespace serialization {
+    namespace detail {
+
+    template<typename T>
+    struct is_default_constructible : public boost::has_trivial_constructor<T> {};
+
+    } // detail
+    } // serializaition
+    } // boost
+
+#endif
+
+
+#endif //  BOOST_SERIALIZATION_DETAIL_IS_DEFAULT_CONSTRUCTIBLE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/detail/shared_count_132.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/detail/shared_count_132.hpp
new file mode 100644
index 00000000000..a5872557cf2
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/serialization/detail/shared_count_132.hpp
@@ -0,0 +1,551 @@
+#ifndef BOOST_DETAIL_SHARED_COUNT_132_HPP_INCLUDED
+#define BOOST_DETAIL_SHARED_COUNT_132_HPP_INCLUDED
+
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+//
+//  detail/shared_count.hpp
+//
+//  Copyright (c) 2001, 2002, 2003 Peter Dimov and Multi Media Ltd.
+//
+// Distributed under the 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_SP_USE_STD_ALLOCATOR) && defined(BOOST_SP_USE_QUICK_ALLOCATOR)
+# error BOOST_SP_USE_STD_ALLOCATOR and BOOST_SP_USE_QUICK_ALLOCATOR are incompatible.
+#endif
+
+#include <boost/checked_delete.hpp>
+#include <boost/serialization/throw_exception.hpp>
+#include <boost/detail/lightweight_mutex.hpp>
+
+#if defined(BOOST_SP_USE_QUICK_ALLOCATOR)
+#include <boost/detail/quick_allocator.hpp>
+#endif
+
+#include <memory>           // std::auto_ptr, std::allocator
+#include <functional>       // std::less
+#include <exception>        // std::exception
+#include <new>              // std::bad_alloc
+#include <typeinfo>         // std::type_info in get_deleter
+#include <cstddef>          // std::size_t
+
+#include <boost/config.hpp> // msvc 6.0 needs this for warning suppression
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{ 
+    using ::size_t; 
+} // namespace std
+#endif
+
+namespace boost_132 {
+
+// Debug hooks
+
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+
+void sp_scalar_constructor_hook(void * px, std::size_t size, void * pn);
+void sp_array_constructor_hook(void * px);
+void sp_scalar_destructor_hook(void * px, std::size_t size, void * pn);
+void sp_array_destructor_hook(void * px);
+
+#endif
+
+
+// The standard library that comes with Borland C++ 5.5.1
+// defines std::exception and its members as having C calling
+// convention (-pc). When the definition of bad_weak_ptr
+// is compiled with -ps, the compiler issues an error.
+// Hence, the temporary #pragma option -pc below. The version
+// check is deliberately conservative.
+
+class bad_weak_ptr: public std::exception
+{
+public:
+
+    virtual char const * what() const throw()
+    {
+        return "boost::bad_weak_ptr";
+    }
+};
+
+namespace detail{
+
+class sp_counted_base
+{
+//private:
+
+    typedef boost::detail::lightweight_mutex mutex_type;
+
+public:
+
+    sp_counted_base(): use_count_(1), weak_count_(1)
+    {
+    }
+
+    virtual ~sp_counted_base() // nothrow
+    {
+    }
+
+    // dispose() is called when use_count_ drops to zero, to release
+    // the resources managed by *this.
+
+    virtual void dispose() = 0; // nothrow
+
+    // destruct() is called when weak_count_ drops to zero.
+
+    virtual void destruct() // nothrow
+    {
+        delete this;
+    }
+
+    virtual void * get_deleter(std::type_info const & ti) = 0;
+
+    void add_ref_copy()
+    {
+#if defined(BOOST_HAS_THREADS)
+        mutex_type::scoped_lock lock(mtx_);
+#endif
+        ++use_count_;
+    }
+
+    void add_ref_lock()
+    {
+#if defined(BOOST_HAS_THREADS)
+        mutex_type::scoped_lock lock(mtx_);
+#endif
+        if(use_count_ == 0) boost::serialization::throw_exception(bad_weak_ptr());
+        ++use_count_;
+    }
+
+    void release() // nothrow
+    {
+        {
+#if defined(BOOST_HAS_THREADS)
+            mutex_type::scoped_lock lock(mtx_);
+#endif
+            long new_use_count = --use_count_;
+
+            if(new_use_count != 0) return;
+        }
+
+        dispose();
+        weak_release();
+    }
+
+    void weak_add_ref() // nothrow
+    {
+#if defined(BOOST_HAS_THREADS)
+        mutex_type::scoped_lock lock(mtx_);
+#endif
+        ++weak_count_;
+    }
+
+    void weak_release() // nothrow
+    {
+        long new_weak_count;
+
+        {
+#if defined(BOOST_HAS_THREADS)
+            mutex_type::scoped_lock lock(mtx_);
+#endif
+            new_weak_count = --weak_count_;
+        }
+
+        if(new_weak_count == 0)
+        {
+            destruct();
+        }
+    }
+
+    long use_count() const // nothrow
+    {
+#if defined(BOOST_HAS_THREADS)
+        mutex_type::scoped_lock lock(mtx_);
+#endif
+        return use_count_;
+    }
+
+//private:
+public:
+    sp_counted_base(sp_counted_base const &);
+    sp_counted_base & operator= (sp_counted_base const &);
+
+    long use_count_;        // #shared
+    long weak_count_;       // #weak + (#shared != 0)
+
+#if defined(BOOST_HAS_THREADS) || defined(BOOST_LWM_WIN32)
+    mutable mutex_type mtx_;
+#endif
+};
+
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+
+template<class T> void cbi_call_constructor_hook(sp_counted_base * pn, T * px, boost::checked_deleter< T > const &)
+{
+    boost::sp_scalar_constructor_hook(px, sizeof(T), pn);
+}
+
+template<class T> void cbi_call_constructor_hook(sp_counted_base *, T * px, boost::checked_array_deleter< T > const &)
+{
+    boost::sp_array_constructor_hook(px);
+}
+
+template<class P, class D> void cbi_call_constructor_hook(sp_counted_base *, P const &, D const &, long)
+{
+}
+
+template<class T> void cbi_call_destructor_hook(sp_counted_base * pn, T * px, boost::checked_deleter< T > const &)
+{
+    boost::sp_scalar_destructor_hook(px, sizeof(T), pn);
+}
+
+template<class T> void cbi_call_destructor_hook(sp_counted_base *, T * px, boost::checked_array_deleter< T > const &)
+{
+    boost::sp_array_destructor_hook(px);
+}
+
+template<class P, class D> void cbi_call_destructor_hook(sp_counted_base *, P const &, D const &, long)
+{
+}
+
+#endif
+
+//
+// Borland's Codeguard trips up over the -Vx- option here:
+//
+#ifdef __CODEGUARD__
+# pragma option push -Vx-
+#endif
+
+template<class P, class D> class sp_counted_base_impl: public sp_counted_base
+{
+//private:
+public:
+    P ptr; // copy constructor must not throw
+    D del; // copy constructor must not throw
+
+    sp_counted_base_impl(sp_counted_base_impl const &);
+    sp_counted_base_impl & operator= (sp_counted_base_impl const &);
+
+    typedef sp_counted_base_impl<P, D> this_type;
+
+public:
+
+    // pre: initial_use_count <= initial_weak_count, d(p) must not throw
+
+    sp_counted_base_impl(P p, D d): ptr(p), del(d)
+    {
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+        detail::cbi_call_constructor_hook(this, p, d, 0);
+#endif
+    }
+
+    virtual void dispose() // nothrow
+    {
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+        detail::cbi_call_destructor_hook(this, ptr, del, 0);
+#endif
+        del(ptr);
+    }
+
+    virtual void * get_deleter(std::type_info const & ti)
+    {
+        return ti == typeid(D)? &del: 0;
+    }
+
+#if defined(BOOST_SP_USE_STD_ALLOCATOR)
+
+    void * operator new(std::size_t)
+    {
+        return std::allocator<this_type>().allocate(1, static_cast<this_type *>(0));
+    }
+
+    void operator delete(void * p)
+    {
+        std::allocator<this_type>().deallocate(static_cast<this_type *>(p), 1);
+    }
+
+#endif
+
+#if defined(BOOST_SP_USE_QUICK_ALLOCATOR)
+
+    void * operator new(std::size_t)
+    {
+        return boost::detail::quick_allocator<this_type>::alloc();
+    }
+
+    void operator delete(void * p)
+    {
+        boost::detail::quick_allocator<this_type>::dealloc(p);
+    }
+
+#endif
+};
+
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+
+int const shared_count_id = 0x2C35F101;
+int const   weak_count_id = 0x298C38A4;
+
+#endif
+
+class weak_count;
+
+class shared_count
+{
+//private:
+public:
+    sp_counted_base * pi_;
+
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+    int id_;
+#endif
+
+    friend class weak_count;
+
+public:
+
+    shared_count(): pi_(0) // nothrow
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+        , id_(shared_count_id)
+#endif
+    {
+    }
+
+    template<class P, class D> shared_count(P p, D d): pi_(0)
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+        , id_(shared_count_id)
+#endif
+    {
+#ifndef BOOST_NO_EXCEPTIONS
+
+        try
+        {
+            pi_ = new sp_counted_base_impl<P, D>(p, d);
+        }
+        catch(...)
+        {
+            d(p); // delete p
+            throw;
+        }
+
+#else
+
+        pi_ = new sp_counted_base_impl<P, D>(p, d);
+
+        if(pi_ == 0)
+        {
+            d(p); // delete p
+            boost::serialization::throw_exception(std::bad_alloc());
+        }
+
+#endif
+    }
+
+#ifndef BOOST_NO_AUTO_PTR
+
+    // auto_ptr<Y> is special cased to provide the strong guarantee
+
+    template<class Y>
+    explicit shared_count(std::auto_ptr<Y> & r): pi_(
+        new sp_counted_base_impl<
+            Y *, 
+            boost::checked_deleter<Y>
+        >(r.get(), boost::checked_deleter<Y>()))
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+        , id_(shared_count_id)
+#endif
+    {
+        r.release();
+    }
+
+#endif 
+
+    ~shared_count() // nothrow
+    {
+        if(pi_ != 0) pi_->release();
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+        id_ = 0;
+#endif
+    }
+
+    shared_count(shared_count const & r): pi_(r.pi_) // nothrow
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+        , id_(shared_count_id)
+#endif
+    {
+        if(pi_ != 0) pi_->add_ref_copy();
+    }
+
+    explicit shared_count(weak_count const & r); // throws bad_weak_ptr when r.use_count() == 0
+
+    shared_count & operator= (shared_count const & r) // nothrow
+    {
+        sp_counted_base * tmp = r.pi_;
+
+        if(tmp != pi_)
+        {
+            if(tmp != 0) tmp->add_ref_copy();
+            if(pi_ != 0) pi_->release();
+            pi_ = tmp;
+        }
+
+        return *this;
+    }
+
+    void swap(shared_count & r) // nothrow
+    {
+        sp_counted_base * tmp = r.pi_;
+        r.pi_ = pi_;
+        pi_ = tmp;
+    }
+
+    long use_count() const // nothrow
+    {
+        return pi_ != 0? pi_->use_count(): 0;
+    }
+
+    bool unique() const // nothrow
+    {
+        return use_count() == 1;
+    }
+
+    friend inline bool operator==(shared_count const & a, shared_count const & b)
+    {
+        return a.pi_ == b.pi_;
+    }
+
+    friend inline bool operator<(shared_count const & a, shared_count const & b)
+    {
+        return std::less<sp_counted_base *>()(a.pi_, b.pi_);
+    }
+
+    void * get_deleter(std::type_info const & ti) const
+    {
+        return pi_? pi_->get_deleter(ti): 0;
+    }
+};
+
+#ifdef __CODEGUARD__
+# pragma option pop
+#endif
+
+
+class weak_count
+{
+private:
+
+    sp_counted_base * pi_;
+
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+    int id_;
+#endif
+
+    friend class shared_count;
+
+public:
+
+    weak_count(): pi_(0) // nothrow
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+        , id_(weak_count_id)
+#endif
+    {
+    }
+
+    weak_count(shared_count const & r): pi_(r.pi_) // nothrow
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+        , id_(shared_count_id)
+#endif
+    {
+        if(pi_ != 0) pi_->weak_add_ref();
+    }
+
+    weak_count(weak_count const & r): pi_(r.pi_) // nothrow
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+        , id_(shared_count_id)
+#endif
+    {
+        if(pi_ != 0) pi_->weak_add_ref();
+    }
+
+    ~weak_count() // nothrow
+    {
+        if(pi_ != 0) pi_->weak_release();
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+        id_ = 0;
+#endif
+    }
+
+    weak_count & operator= (shared_count const & r) // nothrow
+    {
+        sp_counted_base * tmp = r.pi_;
+        if(tmp != 0) tmp->weak_add_ref();
+        if(pi_ != 0) pi_->weak_release();
+        pi_ = tmp;
+
+        return *this;
+    }
+
+    weak_count & operator= (weak_count const & r) // nothrow
+    {
+        sp_counted_base * tmp = r.pi_;
+        if(tmp != 0) tmp->weak_add_ref();
+        if(pi_ != 0) pi_->weak_release();
+        pi_ = tmp;
+
+        return *this;
+    }
+
+    void swap(weak_count & r) // nothrow
+    {
+        sp_counted_base * tmp = r.pi_;
+        r.pi_ = pi_;
+        pi_ = tmp;
+    }
+
+    long use_count() const // nothrow
+    {
+        return pi_ != 0? pi_->use_count(): 0;
+    }
+
+    friend inline bool operator==(weak_count const & a, weak_count const & b)
+    {
+        return a.pi_ == b.pi_;
+    }
+
+    friend inline bool operator<(weak_count const & a, weak_count const & b)
+    {
+        return std::less<sp_counted_base *>()(a.pi_, b.pi_);
+    }
+};
+
+inline shared_count::shared_count(weak_count const & r): pi_(r.pi_)
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+        , id_(shared_count_id)
+#endif
+{
+    if(pi_ != 0)
+    {
+        pi_->add_ref_lock();
+    }
+    else
+    {
+        boost::serialization::throw_exception(bad_weak_ptr());
+    }
+}
+
+} // namespace detail
+
+} // namespace boost
+
+BOOST_SERIALIZATION_ASSUME_ABSTRACT(boost_132::detail::sp_counted_base)
+
+#endif  // #ifndef BOOST_DETAIL_SHARED_COUNT_HPP_INCLUDED
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/detail/shared_ptr_132.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/detail/shared_ptr_132.hpp
new file mode 100644
index 00000000000..ee98b7b9449
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/serialization/detail/shared_ptr_132.hpp
@@ -0,0 +1,443 @@
+#ifndef BOOST_SHARED_PTR_132_HPP_INCLUDED
+#define BOOST_SHARED_PTR_132_HPP_INCLUDED
+
+//
+//  shared_ptr.hpp
+//
+//  (C) Copyright Greg Colvin and Beman Dawes 1998, 1999.
+//  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)
+//
+//  See http://www.boost.org/libs/smart_ptr/shared_ptr.htm for documentation.
+//
+
+#include <boost/config.hpp>   // for broken compiler workarounds
+
+#if defined(BOOST_NO_MEMBER_TEMPLATES) && !defined(BOOST_MSVC6_MEMBER_TEMPLATES)
+#include <boost/serialization/detail/shared_ptr_nmt_132.hpp>
+#else
+
+#include <boost/assert.hpp>
+#include <boost/checked_delete.hpp>
+#include <boost/serialization/throw_exception.hpp>
+#include <boost/detail/workaround.hpp>
+
+#include <boost/serialization/access.hpp>
+#include <boost/serialization/detail/shared_count_132.hpp>
+
+#include <memory>               // for std::auto_ptr
+#include <algorithm>            // for std::swap
+#include <functional>           // for std::less
+#include <typeinfo>             // for std::bad_cast
+#include <iosfwd>               // for std::basic_ostream
+
+#ifdef BOOST_MSVC  // moved here to work around VC++ compiler crash
+# pragma warning(push)
+# pragma warning(disable:4284) // odd return type for operator->
+#endif
+
+namespace boost_132 {
+
+template<class T> class weak_ptr;
+template<class T> class enable_shared_from_this;
+
+namespace detail
+{
+
+struct static_cast_tag {};
+struct const_cast_tag {};
+struct dynamic_cast_tag {};
+struct polymorphic_cast_tag {};
+
+template<class T> struct shared_ptr_traits
+{
+    typedef T & reference;
+};
+
+template<> struct shared_ptr_traits<void>
+{
+    typedef void reference;
+};
+
+#if !defined(BOOST_NO_CV_VOID_SPECIALIZATIONS)
+
+template<> struct shared_ptr_traits<void const>
+{
+    typedef void reference;
+};
+
+template<> struct shared_ptr_traits<void volatile>
+{
+    typedef void reference;
+};
+
+template<> struct shared_ptr_traits<void const volatile>
+{
+    typedef void reference;
+};
+
+#endif
+
+// enable_shared_from_this support
+
+template<class T, class Y> void sp_enable_shared_from_this( shared_count const & pn, enable_shared_from_this< T > const * pe, Y const * px )
+{
+    if(pe != 0) pe->_internal_weak_this._internal_assign(const_cast<Y*>(px), pn);
+}
+
+inline void sp_enable_shared_from_this( shared_count const & /*pn*/, ... )
+{
+}
+
+} // namespace detail
+
+
+//
+//  shared_ptr
+//
+//  An enhanced relative of scoped_ptr with reference counted copy semantics.
+//  The object pointed to is deleted when the last shared_ptr pointing to it
+//  is destroyed or reset.
+//
+
+template<class T> class shared_ptr
+{
+private:
+    // Borland 5.5.1 specific workaround
+    typedef shared_ptr< T > this_type;
+
+public:
+
+    typedef T element_type;
+    typedef T value_type;
+    typedef T * pointer;
+    typedef typename detail::shared_ptr_traits< T >::reference reference;
+
+    shared_ptr(): px(0), pn() // never throws in 1.30+
+    {
+    }
+
+    template<class Y>
+    explicit shared_ptr(Y * p): px(p), pn(p, boost::checked_deleter<Y>()) // Y must be complete
+    {
+        detail::sp_enable_shared_from_this( pn, p, p );
+    }
+
+    //
+    // Requirements: D's copy constructor must not throw
+    //
+    // shared_ptr will release p by calling d(p)
+    //
+
+    template<class Y, class D> shared_ptr(Y * p, D d): px(p), pn(p, d)
+    {
+        detail::sp_enable_shared_from_this( pn, p, p );
+    }
+
+//  generated copy constructor, assignment, destructor are fine...
+
+//  except that Borland C++ has a bug, and g++ with -Wsynth warns
+#if defined(__GNUC__)
+    shared_ptr & operator=(shared_ptr const & r) // never throws
+    {
+        px = r.px;
+        pn = r.pn; // shared_count::op= doesn't throw
+        return *this;
+    }
+#endif
+
+    template<class Y>
+    explicit shared_ptr(weak_ptr<Y> const & r): pn(r.pn) // may throw
+    {
+        // it is now safe to copy r.px, as pn(r.pn) did not throw
+        px = r.px;
+    }
+
+    template<class Y>
+    shared_ptr(shared_ptr<Y> const & r): px(r.px), pn(r.pn) // never throws
+    {
+    }
+
+    template<class Y>
+    shared_ptr(shared_ptr<Y> const & r, detail::static_cast_tag): px(static_cast<element_type *>(r.px)), pn(r.pn)
+    {
+    }
+
+    template<class Y>
+    shared_ptr(shared_ptr<Y> const & r, detail::const_cast_tag): px(const_cast<element_type *>(r.px)), pn(r.pn)
+    {
+    }
+
+    template<class Y>
+    shared_ptr(shared_ptr<Y> const & r, detail::dynamic_cast_tag): px(dynamic_cast<element_type *>(r.px)), pn(r.pn)
+    {
+        if(px == 0) // need to allocate new counter -- the cast failed
+        {
+            pn = detail::shared_count();
+        }
+    }
+
+    template<class Y>
+    shared_ptr(shared_ptr<Y> const & r, detail::polymorphic_cast_tag): px(dynamic_cast<element_type *>(r.px)), pn(r.pn)
+    {
+        if(px == 0)
+        {
+            boost::serialization::throw_exception(std::bad_cast());
+        }
+    }
+
+#ifndef BOOST_NO_AUTO_PTR
+
+    template<class Y>
+    explicit shared_ptr(std::auto_ptr<Y> & r): px(r.get()), pn()
+    {
+        Y * tmp = r.get();
+        pn = detail::shared_count(r);
+        detail::sp_enable_shared_from_this( pn, tmp, tmp );
+    }
+
+#endif
+
+#if !defined(BOOST_MSVC) || (BOOST_MSVC > 1200)
+
+    template<class Y>
+    shared_ptr & operator=(shared_ptr<Y> const & r) // never throws
+    {
+        px = r.px;
+        pn = r.pn; // shared_count::op= doesn't throw
+        return *this;
+    }
+
+#endif
+
+#ifndef BOOST_NO_AUTO_PTR
+
+    template<class Y>
+    shared_ptr & operator=(std::auto_ptr<Y> & r)
+    {
+        this_type(r).swap(*this);
+        return *this;
+    }
+
+#endif
+
+    void reset() // never throws in 1.30+
+    {
+        this_type().swap(*this);
+    }
+
+    template<class Y> void reset(Y * p) // Y must be complete
+    {
+        BOOST_ASSERT(p == 0 || p != px); // catch self-reset errors
+        this_type(p).swap(*this);
+    }
+
+    template<class Y, class D> void reset(Y * p, D d)
+    {
+        this_type(p, d).swap(*this);
+    }
+
+    reference operator* () const // never throws
+    {
+        BOOST_ASSERT(px != 0);
+        return *px;
+    }
+
+    T * operator-> () const // never throws
+    {
+        BOOST_ASSERT(px != 0);
+        return px;
+    }
+    
+    T * get() const // never throws
+    {
+        return px;
+    }
+
+    // implicit conversion to "bool"
+
+#if defined(__SUNPRO_CC) && BOOST_WORKAROUND(__SUNPRO_CC, <= 0x530)
+
+    operator bool () const
+    {
+        return px != 0;
+    }
+
+#elif defined(__MWERKS__) && BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3003))
+    typedef T * (this_type::*unspecified_bool_type)() const;
+    
+    operator unspecified_bool_type() const // never throws
+    {
+        return px == 0? 0: &this_type::get;
+    }
+
+#else 
+
+    typedef T * this_type::*unspecified_bool_type;
+
+    operator unspecified_bool_type() const // never throws
+    {
+        return px == 0? 0: &this_type::px;
+    }
+
+#endif
+
+    // operator! is redundant, but some compilers need it
+
+    bool operator! () const // never throws
+    {
+        return px == 0;
+    }
+
+    bool unique() const // never throws
+    {
+        return pn.unique();
+    }
+
+    long use_count() const // never throws
+    {
+        return pn.use_count();
+    }
+
+    void swap(shared_ptr< T > & other) // never throws
+    {
+        std::swap(px, other.px);
+        pn.swap(other.pn);
+    }
+
+    template<class Y> bool _internal_less(shared_ptr<Y> const & rhs) const
+    {
+        return pn < rhs.pn;
+    }
+
+    void * _internal_get_deleter(std::type_info const & ti) const
+    {
+        return pn.get_deleter(ti);
+    }
+
+// Tasteless as this may seem, making all members public allows member templates
+// to work in the absence of member template friends. (Matthew Langston)
+
+#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
+
+private:
+
+    template<class Y> friend class shared_ptr;
+    template<class Y> friend class weak_ptr;
+
+
+#endif
+public: // for serialization
+    T * px;                     // contained pointer
+    detail::shared_count pn;    // reference counter
+
+};  // shared_ptr
+
+template<class T, class U> inline bool operator==(shared_ptr< T > const & a, shared_ptr<U> const & b)
+{
+    return a.get() == b.get();
+}
+
+template<class T, class U> inline bool operator!=(shared_ptr< T > const & a, shared_ptr<U> const & b)
+{
+    return a.get() != b.get();
+}
+
+template<class T, class U> inline bool operator<(shared_ptr< T > const & a, shared_ptr<U> const & b)
+{
+    return a._internal_less(b);
+}
+
+template<class T> inline void swap(shared_ptr< T > & a, shared_ptr< T > & b)
+{
+    a.swap(b);
+}
+
+template<class T, class U> shared_ptr< T > static_pointer_cast(shared_ptr<U> const & r)
+{
+    return shared_ptr< T >(r, detail::static_cast_tag());
+}
+
+template<class T, class U> shared_ptr< T > const_pointer_cast(shared_ptr<U> const & r)
+{
+    return shared_ptr< T >(r, detail::const_cast_tag());
+}
+
+template<class T, class U> shared_ptr< T > dynamic_pointer_cast(shared_ptr<U> const & r)
+{
+    return shared_ptr< T >(r, detail::dynamic_cast_tag());
+}
+
+// shared_*_cast names are deprecated. Use *_pointer_cast instead.
+
+template<class T, class U> shared_ptr< T > shared_static_cast(shared_ptr<U> const & r)
+{
+    return shared_ptr< T >(r, detail::static_cast_tag());
+}
+
+template<class T, class U> shared_ptr< T > shared_dynamic_cast(shared_ptr<U> const & r)
+{
+    return shared_ptr< T >(r, detail::dynamic_cast_tag());
+}
+
+template<class T, class U> shared_ptr< T > shared_polymorphic_cast(shared_ptr<U> const & r)
+{
+    return shared_ptr< T >(r, detail::polymorphic_cast_tag());
+}
+
+template<class T, class U> shared_ptr< T > shared_polymorphic_downcast(shared_ptr<U> const & r)
+{
+    BOOST_ASSERT(dynamic_cast<T *>(r.get()) == r.get());
+    return shared_static_cast< T >(r);
+}
+
+// get_pointer() enables boost::mem_fn to recognize shared_ptr
+
+template<class T> inline T * get_pointer(shared_ptr< T > const & p)
+{
+    return p.get();
+}
+
+// operator<<
+
+
+template<class E, class T, class Y> std::basic_ostream<E, T> & operator<< (std::basic_ostream<E, T> & os, shared_ptr<Y> const & p)
+{
+    os << p.get();
+    return os;
+}
+
+// get_deleter (experimental)
+
+#if defined(__EDG_VERSION__) && (__EDG_VERSION__ <= 238)
+
+// g++ 2.9x doesn't allow static_cast<X const *>(void *)
+// apparently EDG 2.38 also doesn't accept it
+
+template<class D, class T> D * get_deleter(shared_ptr< T > const & p)
+{
+    void const * q = p._internal_get_deleter(typeid(D));
+    return const_cast<D *>(static_cast<D const *>(q));
+}
+
+#else
+
+template<class D, class T> D * get_deleter(shared_ptr< T > const & p)
+{
+    return static_cast<D *>(p._internal_get_deleter(typeid(D)));
+}
+
+#endif
+
+} // namespace boost
+
+#ifdef BOOST_MSVC
+# pragma warning(pop)
+#endif    
+
+#endif  // #if defined(BOOST_NO_MEMBER_TEMPLATES) && !defined(BOOST_MSVC6_MEMBER_TEMPLATES)
+
+#endif  // #ifndef BOOST_SHARED_PTR_132_HPP_INCLUDED
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/detail/shared_ptr_nmt_132.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/detail/shared_ptr_nmt_132.hpp
new file mode 100644
index 00000000000..490e7ddd3d0
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/serialization/detail/shared_ptr_nmt_132.hpp
@@ -0,0 +1,182 @@
+#ifndef BOOST_DETAIL_SHARED_PTR_NMT_132_HPP_INCLUDED
+#define BOOST_DETAIL_SHARED_PTR_NMT_132_HPP_INCLUDED
+
+//
+//  detail/shared_ptr_nmt.hpp - shared_ptr.hpp without member templates
+//
+//  (C) Copyright Greg Colvin and Beman Dawes 1998, 1999.
+//  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)
+//
+//  See http://www.boost.org/libs/smart_ptr/shared_ptr.htm for documentation.
+//
+
+#include <boost/assert.hpp>
+#include <boost/checked_delete.hpp>
+#include <boost/serialization/throw_exception.hpp>
+#include <boost/detail/atomic_count.hpp>
+
+#ifndef BOOST_NO_AUTO_PTR
+# include <memory>          // for std::auto_ptr
+#endif
+
+#include <algorithm>        // for std::swap
+#include <functional>       // for std::less
+#include <new>              // for std::bad_alloc
+
+namespace boost
+{
+
+template<class T> class shared_ptr
+{
+private:
+
+    typedef detail::atomic_count count_type;
+
+public:
+
+    typedef T element_type;
+    typedef T value_type;
+
+    explicit shared_ptr(T * p = 0): px(p)
+    {
+#ifndef BOOST_NO_EXCEPTIONS
+
+        try  // prevent leak if new throws
+        {
+            pn = new count_type(1);
+        }
+        catch(...)
+        {
+            boost::checked_delete(p);
+            throw;
+        }
+
+#else
+
+        pn = new count_type(1);
+
+        if(pn == 0)
+        {
+            boost::checked_delete(p);
+            boost::serialization::throw_exception(std::bad_alloc());
+        }
+
+#endif
+    }
+
+    ~shared_ptr()
+    {
+        if(--*pn == 0)
+        {
+            boost::checked_delete(px);
+            delete pn;
+        }
+    }
+
+    shared_ptr(shared_ptr const & r): px(r.px)  // never throws
+    {
+        pn = r.pn;
+        ++*pn;
+    }
+
+    shared_ptr & operator=(shared_ptr const & r)
+    {
+        shared_ptr(r).swap(*this);
+        return *this;
+    }
+
+#ifndef BOOST_NO_AUTO_PTR
+
+    explicit shared_ptr(std::auto_ptr< T > & r)
+    { 
+        pn = new count_type(1); // may throw
+        px = r.release(); // fix: moved here to stop leak if new throws
+    } 
+
+    shared_ptr & operator=(std::auto_ptr< T > & r)
+    {
+        shared_ptr(r).swap(*this);
+        return *this;
+    }
+
+#endif
+
+    void reset(T * p = 0)
+    {
+        BOOST_ASSERT(p == 0 || p != px);
+        shared_ptr(p).swap(*this);
+    }
+
+    T & operator*() const  // never throws
+    {
+        BOOST_ASSERT(px != 0);
+        return *px;
+    }
+
+    T * operator->() const  // never throws
+    {
+        BOOST_ASSERT(px != 0);
+        return px;
+    }
+
+    T * get() const  // never throws
+    {
+        return px;
+    }
+
+    long use_count() const  // never throws
+    {
+        return *pn;
+    }
+
+    bool unique() const  // never throws
+    {
+        return *pn == 1;
+    }
+    
+    void swap(shared_ptr< T > & other)  // never throws
+    {
+        std::swap(px, other.px);
+        std::swap(pn, other.pn);
+    }
+
+private:
+
+    T * px;            // contained pointer
+    count_type * pn;   // ptr to reference counter
+};
+
+template<class T, class U> inline bool operator==(shared_ptr< T > const & a, shared_ptr<U> const & b)
+{
+    return a.get() == b.get();
+}
+
+template<class T, class U> inline bool operator!=(shared_ptr< T > const & a, shared_ptr<U> const & b)
+{
+    return a.get() != b.get();
+}
+
+template<class T> inline bool operator<(shared_ptr< T > const & a, shared_ptr< T > const & b)
+{
+    return std::less<T*>()(a.get(), b.get());
+}
+
+template<class T> void swap(shared_ptr< T > & a, shared_ptr< T > & b)
+{
+    a.swap(b);
+}
+
+// get_pointer() enables boost::mem_fn to recognize shared_ptr
+
+template<class T> inline T * get_pointer(shared_ptr< T > const & p)
+{
+    return p.get();
+}
+
+} // namespace boost
+
+#endif  // #ifndef BOOST_DETAIL_SHARED_PTR_NMT_132_HPP_INCLUDED
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/detail/stack_constructor.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/detail/stack_constructor.hpp
new file mode 100644
index 00000000000..ae14832c6db
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/serialization/detail/stack_constructor.hpp
@@ -0,0 +1,66 @@
+#ifndef  BOOST_SERIALIZATION_DETAIL_STACK_CONSTRUCTOR_HPP
+#define BOOST_SERIALIZATION_DETAIL_STACK_CONSTRUCTOR_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// stack_constructor.hpp: serialization for loading stl collections
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+#include <boost/aligned_storage.hpp>
+#include <boost/serialization/serialization.hpp>
+
+namespace boost{
+namespace serialization {
+namespace detail {
+
+// reserve space on stack for an object of type T without actually
+// construction such an object
+template<typename T > 
+struct stack_allocate
+{
+    T * address() {
+        return static_cast<T*>(storage_.address()); 
+    }
+    T & reference() {
+        return * address();
+    }
+private:
+    typedef typename boost::aligned_storage<
+        sizeof(T), 
+        boost::alignment_of<T>::value
+    > type;
+    type storage_;
+};
+
+// construct element on the stack
+template<class Archive, class T>
+struct stack_construct : public stack_allocate<T>
+{
+    stack_construct(Archive & ar, const unsigned int version){
+        // note borland emits a no-op without the explicit namespace
+        boost::serialization::load_construct_data_adl(
+            ar, 
+            this->address(), 
+            version
+        );
+    }
+    ~stack_construct(){
+        this->address()->~T(); // undo load_construct_data above
+    }
+};
+
+} // detail
+} // serializaition
+} // boost
+
+#endif //  BOOST_SERIALIZATION_DETAIL_STACH_CONSTRUCTOR_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/ephemeral.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/ephemeral.hpp
new file mode 100644
index 00000000000..3a422c30a35
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/serialization/ephemeral.hpp
@@ -0,0 +1,72 @@
+#ifndef BOOST_SERIALIZATION_EPHEMERAL_HPP
+#define BOOST_SERIALIZATION_EPHEMERAL_HPP
+
+// MS compatible compilers support 
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// ephemeral_object.hpp: interface for serialization system.
+
+// (C) Copyright 2007 Matthias Troyer. 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+#include <utility>
+
+#include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
+
+#include <boost/mpl/integral_c.hpp>
+#include <boost/mpl/integral_c_tag.hpp>
+
+#include <boost/serialization/level.hpp>
+#include <boost/serialization/tracking.hpp>
+#include <boost/serialization/split_member.hpp>
+#include <boost/serialization/base_object.hpp>
+#include <boost/serialization/traits.hpp>
+#include <boost/serialization/wrapper.hpp>
+
+namespace boost {
+namespace serialization {
+
+template<class T>
+struct ephemeral_object : 
+    public wrapper_traits<ephemeral_object<T> >
+{
+    explicit ephemeral_object(T& t) :
+        val(t)
+    {}
+
+    T & value() const {
+        return val;
+    }
+
+    const T & const_value() const {
+        return val;
+    }
+
+    template<class Archive>
+    void serialize(Archive &ar, const unsigned int) const
+    {
+       ar & val;
+    }
+
+private:
+    T & val;
+};
+
+template<class T>
+inline
+const ephemeral_object<T> ephemeral(const char * name, T & t){
+    return ephemeral_object<T>(name, t);
+}
+
+} // seralization
+} // boost
+
+#endif // BOOST_SERIALIZATION_EPHEMERAL_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/export.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/export.hpp
new file mode 100644
index 00000000000..9eef440df42
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/serialization/export.hpp
@@ -0,0 +1,225 @@
+#ifndef BOOST_SERIALIZATION_EXPORT_HPP
+#define BOOST_SERIALIZATION_EXPORT_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// export.hpp: set traits of classes to be serialized
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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 2006 David Abrahams - http://www.boost.org.
+// implementation of class export functionality.  This is an alternative to
+// "forward declaration" method to provoke instantiation of derived classes
+// that are to be serialized through pointers.
+
+#include <utility>
+#include <cstddef> // NULL
+
+#include <boost/config.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/preprocessor/stringize.hpp>
+#include <boost/type_traits/is_polymorphic.hpp>
+
+#include <boost/mpl/assert.hpp>
+#include <boost/mpl/and.hpp>
+#include <boost/mpl/not.hpp>
+#include <boost/mpl/bool_fwd.hpp>
+
+#include <boost/serialization/extended_type_info.hpp> // for guid_defined only
+#include <boost/serialization/static_warning.hpp>
+#include <boost/serialization/assume_abstract.hpp>
+#include <boost/serialization/force_include.hpp>
+#include <boost/serialization/singleton.hpp>
+
+#include <boost/archive/detail/register_archive.hpp>
+
+#include <iostream>
+
+namespace boost {
+namespace archive {
+namespace detail {
+
+class basic_pointer_iserializer;
+class basic_pointer_oserializer;
+
+template<class Archive, class T>
+class pointer_iserializer;
+template<class Archive, class T>
+class pointer_oserializer;
+
+template <class Archive, class Serializable>
+struct export_impl
+{
+    static const basic_pointer_iserializer &
+    enable_load(mpl::true_){
+        return boost::serialization::singleton<
+            pointer_iserializer<Archive, Serializable> 
+        >::get_const_instance();
+    }
+
+    static const basic_pointer_oserializer &
+    enable_save(mpl::true_){
+        return boost::serialization::singleton<
+            pointer_oserializer<Archive, Serializable> 
+        >::get_const_instance();
+    }
+    inline static void enable_load(mpl::false_) {}
+    inline static void enable_save(mpl::false_) {}
+};
+
+// On many platforms, naming a specialization of this template is
+// enough to cause its argument to be instantiated.
+template <void(*)()>
+struct instantiate_function {};
+
+template <class Archive, class Serializable>
+struct ptr_serialization_support
+{
+# if defined(BOOST_MSVC) || defined(__SUNPRO_CC)
+    virtual BOOST_DLLEXPORT void instantiate() BOOST_USED;
+# else
+    static BOOST_DLLEXPORT void instantiate() BOOST_USED;
+    typedef instantiate_function<
+        &ptr_serialization_support::instantiate
+    > x;
+# endif
+};
+
+template <class Archive, class Serializable>
+BOOST_DLLEXPORT void 
+ptr_serialization_support<Archive,Serializable>::instantiate()
+{
+    export_impl<Archive,Serializable>::enable_save(
+        typename Archive::is_saving()
+    );
+
+    export_impl<Archive,Serializable>::enable_load(
+        typename Archive::is_loading()
+    );
+}
+
+// Note INTENTIONAL usage of anonymous namespace in header.
+// This was made this way so that export.hpp could be included
+// in other headers.  This is still under study.
+
+namespace extra_detail {
+
+template<class T>
+struct guid_initializer
+{
+    void export_guid(mpl::false_) const {
+        // generates the statically-initialized objects whose constructors
+        // register the information allowing serialization of T objects
+        // through pointers to their base classes.
+        instantiate_ptr_serialization((T*)0, 0, adl_tag());
+    }
+    void export_guid(mpl::true_) const {
+    }
+    guid_initializer const & export_guid() const {
+        BOOST_STATIC_WARNING(boost::is_polymorphic< T >::value);
+        // note: exporting an abstract base class will have no effect
+        // and cannot be used to instantitiate serialization code
+        // (one might be using this in a DLL to instantiate code)
+        //BOOST_STATIC_WARNING(! boost::serialization::is_abstract< T >::value);
+        export_guid(boost::serialization::is_abstract< T >());
+        return *this;
+    }
+};
+
+template<typename T>
+struct init_guid;
+
+} // anonymous
+} // namespace detail
+} // namespace archive
+} // namespace boost
+
+#define BOOST_CLASS_EXPORT_IMPLEMENT(T)                      \
+    namespace boost {                                        \
+    namespace archive {                                      \
+    namespace detail {                                       \
+    namespace extra_detail {                                 \
+    template<>                                               \
+    struct init_guid< T > {                                  \
+        static guid_initializer< T > const & g;              \
+    };                                                       \
+    guid_initializer< T > const & init_guid< T >::g =        \
+        ::boost::serialization::singleton<                   \
+            guid_initializer< T >                            \
+        >::get_mutable_instance().export_guid();             \
+    }}}}                                                     \
+/**/
+
+#define BOOST_CLASS_EXPORT_KEY2(T, K)          \
+namespace boost {                              \
+namespace serialization {                      \
+template<>                                     \
+struct guid_defined< T > : boost::mpl::true_ {}; \
+template<>                                     \
+inline const char * guid< T >(){                 \
+    return K;                                  \
+}                                              \
+} /* serialization */                          \
+} /* boost */                                  \
+/**/
+
+#define BOOST_CLASS_EXPORT_KEY(T)                                      \
+    BOOST_CLASS_EXPORT_KEY2(T, BOOST_PP_STRINGIZE(T))                                                                  \
+/**/
+
+#define BOOST_CLASS_EXPORT_GUID(T, K)                                  \
+BOOST_CLASS_EXPORT_KEY2(T, K)                                          \
+BOOST_CLASS_EXPORT_IMPLEMENT(T)                                        \
+/**/
+
+#if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3205))
+
+// CodeWarrior fails to construct static members of class templates
+// when they are instantiated from within templates, so on that
+// compiler we ask users to specifically register base/derived class
+// relationships for exported classes.  On all other compilers, use of
+// this macro is entirely optional.
+# define BOOST_SERIALIZATION_MWERKS_BASE_AND_DERIVED(Base,Derived)             \
+namespace {                                                                    \
+  static int BOOST_PP_CAT(boost_serialization_mwerks_init_, __LINE__) =        \
+  (::boost::archive::detail::instantiate_ptr_serialization((Derived*)0,0), 3); \
+  static int BOOST_PP_CAT(boost_serialization_mwerks_init2_, __LINE__) = (     \
+      ::boost::serialization::void_cast_register((Derived*)0,(Base*)0)         \
+    , 3);                                                                      \
+}
+
+#else
+
+# define BOOST_SERIALIZATION_MWERKS_BASE_AND_DERIVED(Base,Derived)
+
+#endif 
+
+// check for unnecessary export.  T isn't polymorphic so there is no
+// need to export it.
+#define BOOST_CLASS_EXPORT_CHECK(T)                              \
+    BOOST_STATIC_WARNING(                                        \
+        boost::is_polymorphic<U>::value                          \
+    );                                                           \
+    /**/
+
+// the default exportable class identifier is the class name
+// the default list of archives types for which code id generated
+// are the originally included with this serialization system
+#define BOOST_CLASS_EXPORT(T)                   \
+    BOOST_CLASS_EXPORT_GUID(                    \
+        T,                                      \
+        BOOST_PP_STRINGIZE(T)                   \
+    )                                           \
+    /**/
+
+#endif // BOOST_SERIALIZATION_EXPORT_HPP
+
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/extended_type_info.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/extended_type_info.hpp
new file mode 100644
index 00000000000..bb2a190d465
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/serialization/extended_type_info.hpp
@@ -0,0 +1,116 @@
+#ifndef BOOST_SERIALIZATION_EXTENDED_TYPE_INFO_HPP
+#define BOOST_SERIALIZATION_EXTENDED_TYPE_INFO_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// extended_type_info.hpp: interface for portable version of type_info
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+// for now, extended type info is part of the serialization libraries
+// this could change in the future.
+#include <cstdarg>
+#include <boost/assert.hpp>
+#include <cstddef> // NULL
+#include <boost/config.hpp>
+#include <boost/noncopyable.hpp>
+#include <boost/mpl/bool.hpp>
+
+#include <boost/serialization/config.hpp>
+#include <boost/config/abi_prefix.hpp> // must be the last header
+#ifdef BOOST_MSVC
+#  pragma warning(push)
+#  pragma warning(disable : 4251 4231 4660 4275)
+#endif
+
+#define BOOST_SERIALIZATION_MAX_KEY_SIZE 128
+
+namespace boost { 
+namespace serialization {
+
+namespace void_cast_detail{
+    class void_caster;
+}
+
+class BOOST_SYMBOL_VISIBLE extended_type_info :
+    private boost::noncopyable
+{
+private:
+    friend class boost::serialization::void_cast_detail::void_caster;
+
+    // used to uniquely identify the type of class derived from this one
+    // so that different derivations of this class can be simultaneously
+    // included in implementation of sets and maps.
+    const unsigned int m_type_info_key;
+    virtual bool is_less_than(const extended_type_info & /*rhs*/) const = 0;
+    virtual bool is_equal(const extended_type_info & /*rhs*/) const = 0;
+    const char * m_key;
+
+protected:
+    BOOST_SERIALIZATION_DECL void key_unregister() const;
+    BOOST_SERIALIZATION_DECL void key_register() const;
+    // this class can't be used as is. It's just the 
+    // common functionality for all type_info replacement
+    // systems.  Hence, make these protected
+    BOOST_SERIALIZATION_DECL extended_type_info(
+        const unsigned int type_info_key,
+        const char * key
+    );
+    virtual BOOST_SERIALIZATION_DECL ~extended_type_info();
+public:
+    const char * get_key() const {
+        return m_key;
+    }
+    virtual const char * get_debug_info() const = 0;
+    BOOST_SERIALIZATION_DECL bool operator<(const extended_type_info &rhs) const;
+    BOOST_SERIALIZATION_DECL bool operator==(const extended_type_info &rhs) const;
+    bool operator!=(const extended_type_info &rhs) const {
+        return !(operator==(rhs));
+    }
+    // note explicit "export" of static function to work around
+    // gcc 4.5 mingw error
+    static BOOST_SERIALIZATION_DECL const extended_type_info *
+    find(const char *key);
+    // for plugins
+    virtual void * construct(unsigned int /*count*/ = 0, ...) const = 0;
+    virtual void destroy(void const * const /*p*/) const = 0;
+};
+
+template<class T>
+struct guid_defined : boost::mpl::false_ {};
+
+namespace ext {
+    template <typename T>
+    struct guid_impl
+    {
+        static inline const char * call()
+        {
+            return NULL;
+        }
+    };
+}
+
+template<class T>
+inline const char * guid(){
+    return ext::guid_impl<T>::call();
+}
+
+} // namespace serialization 
+} // namespace boost
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+#include <boost/config/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#endif // BOOST_SERIALIZATION_EXTENDED_TYPE_INFO_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/extended_type_info_no_rtti.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/extended_type_info_no_rtti.hpp
new file mode 100644
index 00000000000..aaa8b44459b
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/serialization/extended_type_info_no_rtti.hpp
@@ -0,0 +1,182 @@
+#ifndef BOOST_EXTENDED_TYPE_INFO_NO_RTTI_HPP
+#define BOOST_EXTENDED_TYPE_INFO_NO_RTTI_HPP
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+// extended_type_info_no_rtti.hpp: implementation for version that depends
+// on runtime typing (rtti - typeid) but uses a user specified string
+// as the portable class identifier.
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+#include <boost/assert.hpp>
+
+#include <boost/config.hpp>
+#include <boost/static_assert.hpp>
+
+#include <boost/mpl/if.hpp>
+#include <boost/type_traits/is_polymorphic.hpp>
+#include <boost/type_traits/remove_const.hpp>
+
+#include <boost/serialization/static_warning.hpp>
+#include <boost/serialization/singleton.hpp>
+#include <boost/serialization/extended_type_info.hpp>
+#include <boost/serialization/factory.hpp>
+#include <boost/serialization/throw_exception.hpp>
+
+#include <boost/serialization/config.hpp>
+// hijack serialization access
+#include <boost/serialization/access.hpp>
+
+#include <boost/config/abi_prefix.hpp> // must be the last header
+#ifdef BOOST_MSVC
+#  pragma warning(push)
+#  pragma warning(disable : 4251 4231 4660 4275 4511 4512)
+#endif
+
+namespace boost {
+namespace serialization {
+///////////////////////////////////////////////////////////////////////
+// define a special type_info that doesn't depend on rtti which is not
+// available in all situations.
+
+namespace no_rtti_system {
+
+// common base class to share type_info_key.  This is used to 
+// identify the method used to keep track of the extended type
+class BOOST_SYMBOL_VISIBLE extended_type_info_no_rtti_0 :
+    public extended_type_info
+{
+protected:
+    BOOST_SERIALIZATION_DECL extended_type_info_no_rtti_0(const char * key);
+    BOOST_SERIALIZATION_DECL ~extended_type_info_no_rtti_0();
+public:
+    virtual BOOST_SERIALIZATION_DECL bool
+    is_less_than(const boost::serialization::extended_type_info &rhs) const ;
+    virtual BOOST_SERIALIZATION_DECL bool
+    is_equal(const boost::serialization::extended_type_info &rhs) const ;
+};
+
+} // no_rtti_system
+
+template<class T>
+class extended_type_info_no_rtti : 
+    public no_rtti_system::extended_type_info_no_rtti_0,
+    public singleton<extended_type_info_no_rtti< T > >
+{
+    template<bool tf>
+    struct action {
+        struct defined {
+            static const char * invoke(){
+                return guid< T >();
+            }
+        };
+        struct undefined {
+            // if your program traps here - you failed to 
+            // export a guid for this type.  the no_rtti
+            // system requires export for types serialized
+            // as pointers.
+            BOOST_STATIC_ASSERT(0 == sizeof(T));
+            static const char * invoke();
+        };
+        static const char * invoke(){
+            typedef 
+                typename boost::mpl::if_c<
+                    tf,
+                    defined,
+                    undefined
+                >::type type;
+            return type::invoke();
+        }
+    };
+public:
+    extended_type_info_no_rtti() :
+        no_rtti_system::extended_type_info_no_rtti_0(get_key())
+    {
+        key_register();
+    }
+    ~extended_type_info_no_rtti(){
+        key_unregister();
+    }
+    const extended_type_info *
+    get_derived_extended_type_info(const T & t) const {
+        // find the type that corresponds to the most derived type.
+        // this implementation doesn't depend on typeid() but assumes
+        // that the specified type has a function of the following signature.
+        // A common implemention of such a function is to define as a virtual
+        // function. So if the is not a polymporphic type it's likely an error
+        BOOST_STATIC_WARNING(boost::is_polymorphic< T >::value);
+        const char * derived_key = t.get_key();
+        BOOST_ASSERT(NULL != derived_key);
+        return boost::serialization::extended_type_info::find(derived_key);
+    }
+    const char * get_key() const{
+        return action<guid_defined< T >::value >::invoke();
+    }
+    virtual const char * get_debug_info() const{
+        return action<guid_defined< T >::value >::invoke();
+    }
+    virtual void * construct(unsigned int count, ...) const{
+        // count up the arguments
+        std::va_list ap;
+        va_start(ap, count);
+        switch(count){
+        case 0:
+            return factory<typename boost::remove_const< T >::type, 0>(ap);
+        case 1:
+            return factory<typename boost::remove_const< T >::type, 1>(ap);
+        case 2:
+            return factory<typename boost::remove_const< T >::type, 2>(ap);
+        case 3:
+            return factory<typename boost::remove_const< T >::type, 3>(ap);
+        case 4:
+            return factory<typename boost::remove_const< T >::type, 4>(ap);
+        default:
+            BOOST_ASSERT(false); // too many arguments
+            // throw exception here?
+            return NULL;
+        }
+    }
+    virtual void destroy(void const * const p) const{
+        boost::serialization::access::destroy(
+            static_cast<T const *>(p)
+        );
+        //delete static_cast<T const * const>(p) ;
+    }
+};
+
+} // namespace serialization
+} // namespace boost
+
+///////////////////////////////////////////////////////////////////////////////
+// If no other implementation has been designated as default, 
+// use this one.  To use this implementation as the default, specify it
+// before any of the other headers.
+
+#ifndef BOOST_SERIALIZATION_DEFAULT_TYPE_INFO
+    #define BOOST_SERIALIZATION_DEFAULT_TYPE_INFO
+    namespace boost {
+    namespace serialization {
+    template<class T>
+    struct extended_type_info_impl {
+        typedef typename 
+            boost::serialization::extended_type_info_no_rtti< T > type;
+    };
+    } // namespace serialization
+    } // namespace boost
+#endif
+
+#ifdef BOOST_MSVC
+#  pragma warning(pop)
+#endif
+#include <boost/config/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#endif // BOOST_EXTENDED_TYPE_INFO_NO_RTTI_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/extended_type_info_typeid.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/extended_type_info_typeid.hpp
new file mode 100644
index 00000000000..8ee591b3169
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/serialization/extended_type_info_typeid.hpp
@@ -0,0 +1,167 @@
+#ifndef BOOST_SERIALIZATION_EXTENDED_TYPE_INFO_TYPEID_HPP
+#define BOOST_SERIALIZATION_EXTENDED_TYPE_INFO_TYPEID_HPP
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+// extended_type_info_typeid.hpp: implementation for version that depends
+// on runtime typing (rtti - typeid) but uses a user specified string
+// as the portable class identifier.
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+#include <typeinfo>
+#include <cstdarg>
+#include <boost/assert.hpp>
+#include <boost/config.hpp>
+
+#include <boost/static_assert.hpp>
+#include <boost/serialization/static_warning.hpp>
+#include <boost/type_traits/is_polymorphic.hpp>
+#include <boost/type_traits/remove_const.hpp>
+
+#include <boost/serialization/config.hpp>
+#include <boost/serialization/singleton.hpp>
+#include <boost/serialization/extended_type_info.hpp>
+#include <boost/serialization/factory.hpp>
+
+// hijack serialization access
+#include <boost/serialization/access.hpp>
+
+#include <boost/mpl/if.hpp>
+
+#include <boost/config/abi_prefix.hpp> // must be the last header
+
+#ifdef BOOST_MSVC
+#  pragma warning(push)
+#  pragma warning(disable : 4251 4231 4660 4275 4511 4512)
+#endif
+
+namespace boost {
+namespace serialization {
+namespace typeid_system {
+
+class BOOST_SYMBOL_VISIBLE extended_type_info_typeid_0 :
+    public extended_type_info
+{
+    virtual const char * get_debug_info() const {
+        if(static_cast<const std::type_info *>(0) == m_ti)
+            return static_cast<const char *>(0);
+        return m_ti->name();
+    }
+protected:
+    const std::type_info * m_ti;
+    BOOST_SERIALIZATION_DECL extended_type_info_typeid_0(const char * key);
+    BOOST_SERIALIZATION_DECL ~extended_type_info_typeid_0();
+    BOOST_SERIALIZATION_DECL void type_register(const std::type_info & ti);
+    BOOST_SERIALIZATION_DECL void type_unregister();
+    BOOST_SERIALIZATION_DECL const extended_type_info *
+    get_extended_type_info(const std::type_info & ti) const;
+public:
+    virtual BOOST_SERIALIZATION_DECL bool
+    is_less_than(const extended_type_info &rhs) const;
+    virtual BOOST_SERIALIZATION_DECL bool
+    is_equal(const extended_type_info &rhs) const;
+    const std::type_info & get_typeid() const {
+        return *m_ti;
+    }
+};
+
+} // typeid_system
+
+template<class T>
+class extended_type_info_typeid : 
+    public typeid_system::extended_type_info_typeid_0,
+    public singleton<extended_type_info_typeid< T > >
+{
+public:
+    extended_type_info_typeid() :
+        typeid_system::extended_type_info_typeid_0(
+            boost::serialization::guid< T >()
+        )
+    {
+        type_register(typeid(T));
+        key_register();
+    }
+    ~extended_type_info_typeid(){
+        key_unregister();
+        type_unregister();
+    }
+    // get the eti record for the true type of this record
+    // relying upon standard type info implemenation (rtti)
+    const extended_type_info *
+    get_derived_extended_type_info(const T & t) const {
+        // note: this implementation - based on usage of typeid (rtti)
+        // only does something if the class has at least one virtual function.
+        BOOST_STATIC_WARNING(boost::is_polymorphic< T >::value);
+        return 
+            typeid_system::extended_type_info_typeid_0::get_extended_type_info(
+                typeid(t)
+            );
+    }
+    const char * get_key() const {
+        return boost::serialization::guid< T >();
+    }
+    virtual void * construct(unsigned int count, ...) const{
+        // count up the arguments
+        std::va_list ap;
+        va_start(ap, count);
+        switch(count){
+        case 0:
+            return factory<typename boost::remove_const< T >::type, 0>(ap);
+        case 1:
+            return factory<typename boost::remove_const< T >::type, 1>(ap);
+        case 2:
+            return factory<typename boost::remove_const< T >::type, 2>(ap);
+        case 3:
+            return factory<typename boost::remove_const< T >::type, 3>(ap);
+        case 4:
+            return factory<typename boost::remove_const< T >::type, 4>(ap);
+        default:
+            BOOST_ASSERT(false); // too many arguments
+            // throw exception here?
+            return NULL;
+        }
+    }
+    virtual void destroy(void const * const p) const {
+        boost::serialization::access::destroy(
+            static_cast<T const *>(p)
+        );
+        //delete static_cast<T const * const>(p);
+    }
+};
+
+} // namespace serialization
+} // namespace boost
+
+///////////////////////////////////////////////////////////////////////////////
+// If no other implementation has been designated as default, 
+// use this one.  To use this implementation as the default, specify it
+// before any of the other headers.
+#ifndef BOOST_SERIALIZATION_DEFAULT_TYPE_INFO
+    #define BOOST_SERIALIZATION_DEFAULT_TYPE_INFO
+    namespace boost {
+    namespace serialization {
+    template<class T>
+    struct extended_type_info_impl {
+        typedef typename 
+            boost::serialization::extended_type_info_typeid< T > type;
+    };
+    } // namespace serialization
+    } // namespace boost
+#endif
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+#include <boost/config/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#endif // BOOST_SERIALIZATION_EXTENDED_TYPE_INFO_TYPEID_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/factory.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/factory.hpp
new file mode 100644
index 00000000000..2db7e7e36c3
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/serialization/factory.hpp
@@ -0,0 +1,102 @@
+#ifndef BOOST_SERIALIZATION_FACTORY_HPP
+#define BOOST_SERIALIZATION_FACTORY_HPP
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+// factory.hpp: create an instance from an extended_type_info instance.
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+#include <cstdarg> // valist
+#include <cstddef> // NULL
+
+#include <boost/preprocessor/control/if.hpp> 
+#include <boost/preprocessor/comparison/greater.hpp>
+#include <boost/assert.hpp>
+
+namespace std{
+    #if defined(__LIBCOMO__)
+        using ::va_list;
+    #endif
+} // namespace std
+
+namespace boost {
+namespace serialization {
+
+// default implementation does nothing.
+template<class T, int N>
+T * factory(std::va_list){
+    BOOST_ASSERT(false);
+    // throw exception here?
+    return NULL;
+}
+
+} // namespace serialization
+} // namespace boost
+
+#define BOOST_SERIALIZATION_FACTORY(N, T, A0, A1, A2, A3) \
+namespace boost {                                         \
+namespace serialization {                                 \
+    template<>                                            \
+    T * factory<T, N>(std::va_list ap){                   \
+        BOOST_PP_IF(BOOST_PP_GREATER(N, 0)                \
+            , A0 a0 = va_arg(ap, A0);, BOOST_PP_EMPTY())  \
+        BOOST_PP_IF(BOOST_PP_GREATER(N, 1)                \
+            , A1 a1 = va_arg(ap, A1);, BOOST_PP_EMPTY())  \
+        BOOST_PP_IF(BOOST_PP_GREATER(N, 2)                \
+            , A2 a2 = va_arg(ap, A2);, BOOST_PP_EMPTY())  \
+        BOOST_PP_IF(BOOST_PP_GREATER(N, 3)                \
+            , A3 a3 = va_arg(ap, A3);, BOOST_PP_EMPTY())  \
+        return new T(                                     \
+            BOOST_PP_IF(BOOST_PP_GREATER(N, 0)            \
+                , a0, BOOST_PP_EMPTY())                   \
+            BOOST_PP_IF(BOOST_PP_GREATER(N, 1))           \
+                , BOOST_PP_COMMA, BOOST_PP_EMPTY)()       \
+            BOOST_PP_IF(BOOST_PP_GREATER(N, 1)            \
+                , a1, BOOST_PP_EMPTY())                   \
+            BOOST_PP_IF(BOOST_PP_GREATER(N, 2))           \
+                , BOOST_PP_COMMA, BOOST_PP_EMPTY)()       \
+            BOOST_PP_IF(BOOST_PP_GREATER(N, 2)            \
+                , a2, BOOST_PP_EMPTY())                   \
+            BOOST_PP_IF(BOOST_PP_GREATER(N, 3))           \
+                , BOOST_PP_COMMA, BOOST_PP_EMPTY)()       \
+            BOOST_PP_IF(BOOST_PP_GREATER(N, 3)            \
+                , a3, BOOST_PP_EMPTY())                   \
+        );                                                \
+    }                                                     \
+}                                                         \
+}   /**/
+
+#define BOOST_SERIALIZATION_FACTORY_4(T, A0, A1, A2, A3) \
+    BOOST_SERIALIZATION_FACTORY(4, T, A0, A1, A2, A3)
+
+#define BOOST_SERIALIZATION_FACTORY_3(T, A0, A1, A2)     \
+    BOOST_SERIALIZATION_FACTORY(3, T, A0, A1, A2, 0)
+
+#define BOOST_SERIALIZATION_FACTORY_2(T, A0, A1)         \
+    BOOST_SERIALIZATION_FACTORY(2, T, A0, A1, 0, 0)
+
+#define BOOST_SERIALIZATION_FACTORY_1(T, A0)             \
+    BOOST_SERIALIZATION_FACTORY(1, T, A0, 0, 0, 0)
+
+#define BOOST_SERIALIZATION_FACTORY_0(T)                 \
+namespace boost {                                        \
+namespace serialization {                                \
+    template<>                                           \
+    T * factory<T, 0>(std::va_list){                     \
+        return new T();                                  \
+    }                                                    \
+}                                                        \
+}                                                        \
+/**/
+
+#endif // BOOST_SERIALIZATION_FACTORY_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/force_include.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/force_include.hpp
new file mode 100644
index 00000000000..55ab79d0d58
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/serialization/force_include.hpp
@@ -0,0 +1,55 @@
+#ifndef BOOST_SERIALIZATION_FORCE_INCLUDE_HPP
+#define BOOST_SERIALIZATION_FORCE_INCLUDE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// force_include.hpp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+#include <boost/config.hpp>
+
+// the following help macro is to guarentee that certain coded
+// is not removed by over-eager linker optimiser.  In certain cases
+// we create static objects must be created but are actually never
+// referenced - creation has a side-effect such as global registration
+// which is important to us. We make an effort to refer these objects
+// so that a smart linker won't remove them as being unreferenced.
+// In microsoft compilers, inlining the code that does the referring
+// means the code gets lost and the static object is not included
+// in the library and hence never registered.  This manifests itself
+// in an ungraceful crash at runtime when (and only when) built in
+// release mode.
+
+#if defined(BOOST_HAS_DECLSPEC) && !defined(__COMO__)
+#   define BOOST_DLLEXPORT __declspec(dllexport)
+#elif ! defined(_WIN32) && ! defined(_WIN64)
+#   if defined(__MWERKS__)
+#       define BOOST_DLLEXPORT __declspec(dllexport)
+#   elif defined(__GNUC__) && (__GNUC__ >= 3)
+#       define BOOST_USED __attribute__ ((__used__))
+#   elif defined(__IBMCPP__) && (__IBMCPP__ >= 1110)
+#       define BOOST_USED __attribute__ ((__used__))
+#   elif defined(__INTEL_COMPILER) && (BOOST_INTEL_CXX_VERSION >= 800)
+#       define BOOST_USED __attribute__ ((__used__))
+#   endif
+#endif
+
+#ifndef BOOST_USED
+#    define BOOST_USED
+#endif
+
+#ifndef BOOST_DLLEXPORT
+#    define BOOST_DLLEXPORT
+#endif
+
+#endif // BOOST_SERIALIZATION_FORCE_INCLUDE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/forward_list.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/forward_list.hpp
new file mode 100644
index 00000000000..b8a3c20a6ea
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/serialization/forward_list.hpp
@@ -0,0 +1,124 @@
+#ifndef BOOST_SERIALIZATION_FORWARD_LIST_HPP
+#define BOOST_SERIALIZATION_FORWARD_LIST_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// forward_list.hpp
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+#include <boost/config.hpp>
+
+#include <forward_list>
+#include <iterator>  // distance
+
+#include <boost/serialization/collections_save_imp.hpp>
+#include <boost/serialization/collections_load_imp.hpp>
+#include <boost/archive/detail/basic_iarchive.hpp>
+#include <boost/serialization/nvp.hpp>
+#include <boost/serialization/collection_size_type.hpp>
+#include <boost/serialization/item_version_type.hpp>
+#include <boost/serialization/split_free.hpp>
+#include <boost/serialization/detail/stack_constructor.hpp>
+#include <boost/serialization/detail/is_default_constructible.hpp>
+#include <boost/move/utility_core.hpp>
+
+namespace boost { 
+namespace serialization {
+
+template<class Archive, class U, class Allocator>
+inline void save(
+    Archive & ar,
+    const std::forward_list<U, Allocator> &t,
+    const unsigned int /*file_version*/
+){
+    const collection_size_type count(std::distance(t.cbegin(), t.cend()));
+    boost::serialization::stl::save_collection<
+        Archive,
+        std::forward_list<U, Allocator>
+    >(ar, t, count);
+}
+
+namespace stl {
+
+template<
+    class Archive,
+    class T,
+    class Allocator
+>
+typename boost::disable_if<
+    typename detail::is_default_constructible<
+        typename std::forward_list<T, Allocator>::value_type
+    >,
+    void
+>::type
+collection_load_impl(
+    Archive & ar,
+    std::forward_list<T, Allocator> &t,
+    collection_size_type count,
+    item_version_type item_version
+){
+    t.clear();
+    boost::serialization::detail::stack_construct<Archive, T> u(ar, item_version);
+    ar >> boost::serialization::make_nvp("item", u.reference());
+    t.push_front(boost::move(u.reference()));
+    typename std::forward_list<T, Allocator>::iterator last;
+    last = t.begin();
+    ar.reset_object_address(&(*t.begin()) , & u.reference());
+    while(--count > 0){
+        detail::stack_construct<Archive, T> u(ar, item_version);
+        ar >> boost::serialization::make_nvp("item", u.reference());
+        last = t.insert_after(last, boost::move(u.reference()));
+        ar.reset_object_address(&(*last) , & u.reference());
+    }
+}
+
+} // stl
+
+template<class Archive, class U, class Allocator>
+inline void load(
+    Archive & ar,
+    std::forward_list<U, Allocator> &t,
+    const unsigned int /*file_version*/
+){
+    const boost::archive::library_version_type library_version(
+        ar.get_library_version()
+    );
+    // retrieve number of elements
+    item_version_type item_version(0);
+    collection_size_type count;
+    ar >> BOOST_SERIALIZATION_NVP(count);
+    if(boost::archive::library_version_type(3) < library_version){
+        ar >> BOOST_SERIALIZATION_NVP(item_version);
+    }
+    stl::collection_load_impl(ar, t, count, item_version);
+}
+
+// split non-intrusive serialization function member into separate
+// non intrusive save/load member functions
+template<class Archive, class U, class Allocator>
+inline void serialize(
+    Archive & ar,
+    std::forward_list<U, Allocator> &t,
+    const unsigned int file_version
+){
+    boost::serialization::split_free(ar, t, file_version);
+}
+
+} // serialization
+} // namespace boost
+
+#include <boost/serialization/collection_traits.hpp>
+
+BOOST_SERIALIZATION_COLLECTION_TRAITS(std::forward_list)
+
+#endif  // BOOST_SERIALIZATION_FORWARD_LIST_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/hash_collections_load_imp.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/hash_collections_load_imp.hpp
new file mode 100644
index 00000000000..88def8f1aa4
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/serialization/hash_collections_load_imp.hpp
@@ -0,0 +1,77 @@
+#ifndef BOOST_SERIALIZATION_HASH_COLLECTIONS_LOAD_IMP_HPP
+#define BOOST_SERIALIZATION_HASH_COLLECTIONS_LOAD_IMP_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+# pragma warning (disable : 4786) // too long name, harmless warning
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// hash_collections_load_imp.hpp: serialization for loading stl collections
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+// helper function templates for serialization of hashed collections
+#include <boost/config.hpp>
+#include <boost/archive/detail/basic_iarchive.hpp>
+#include <boost/serialization/nvp.hpp>
+#include <boost/serialization/collection_size_type.hpp>
+#include <boost/serialization/item_version_type.hpp>
+
+namespace boost{
+namespace serialization {
+namespace stl {
+
+//////////////////////////////////////////////////////////////////////
+// implementation of serialization for STL containers
+//
+template<class Archive, class Container, class InputFunction>
+inline void load_hash_collection(Archive & ar, Container &s)
+{
+    collection_size_type count;
+    collection_size_type bucket_count;
+    boost::serialization::item_version_type item_version(0);
+    boost::archive::library_version_type library_version(
+        ar.get_library_version()
+    );
+    // retrieve number of elements
+    if(boost::archive::library_version_type(6) != library_version){
+        ar >> BOOST_SERIALIZATION_NVP(count);
+        ar >> BOOST_SERIALIZATION_NVP(bucket_count);
+    }
+    else{
+        // note: fixup for error in version 6.  collection size was
+        // changed to size_t BUT for hashed collections it was implemented
+        // as an unsigned int.  This should be a problem only on win64 machines
+        // but I'll leave it for everyone just in case.
+        unsigned int c;
+        unsigned int bc;
+        ar >> BOOST_SERIALIZATION_NVP(c);
+        count = c;
+        ar >> BOOST_SERIALIZATION_NVP(bc);
+        bucket_count = bc;
+    }
+    if(boost::archive::library_version_type(3) < library_version){
+        ar >> BOOST_SERIALIZATION_NVP(item_version);
+    }
+    s.clear();
+    #if ! defined(__MWERKS__)
+    s.resize(bucket_count);
+    #endif
+    InputFunction ifunc;
+    while(count-- > 0){
+        ifunc(ar, s, item_version);
+    }
+}
+
+} // namespace stl 
+} // namespace serialization
+} // namespace boost
+
+#endif //BOOST_SERIALIZATION_HASH_COLLECTIONS_LOAD_IMP_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/hash_collections_save_imp.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/hash_collections_save_imp.hpp
new file mode 100644
index 00000000000..65dfe83f16e
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/serialization/hash_collections_save_imp.hpp
@@ -0,0 +1,97 @@
+#ifndef BOOST_SERIALIZATION_HASH_COLLECTIONS_SAVE_IMP_HPP
+#define BOOST_SERIALIZATION_HASH_COLLECTIONS_SAVE_IMP_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// hash_collections_save_imp.hpp: serialization for stl collections
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+// helper function templates for serialization of collections
+
+#include <boost/config.hpp>
+#include <boost/serialization/nvp.hpp>
+#include <boost/serialization/serialization.hpp>
+#include <boost/serialization/version.hpp>
+#include <boost/serialization/collection_size_type.hpp>
+#include <boost/serialization/item_version_type.hpp>
+
+namespace boost{
+namespace serialization {
+namespace stl {
+
+//////////////////////////////////////////////////////////////////////
+// implementation of serialization for STL containers
+//
+
+template<class Archive, class Container>
+inline void save_hash_collection(Archive & ar, const Container &s)
+{
+    collection_size_type count(s.size());
+    const collection_size_type bucket_count(s.bucket_count());
+    const item_version_type item_version(
+        version<typename Container::value_type>::value
+    );
+
+    #if 0
+    /* should only be necessary to create archives of previous versions
+     * which is not currently supported.  So for now comment this out
+     */
+    boost::archive::library_version_type library_version(
+        ar.get_library_version()
+    );
+    // retrieve number of elements
+    if(boost::archive::library_version_type(6) != library_version){
+        ar << BOOST_SERIALIZATION_NVP(count);
+        ar << BOOST_SERIALIZATION_NVP(bucket_count);
+    }
+    else{
+        // note: fixup for error in version 6.  collection size was
+        // changed to size_t BUT for hashed collections it was implemented
+        // as an unsigned int.  This should be a problem only on win64 machines
+        // but I'll leave it for everyone just in case.
+        const unsigned int c = count;
+        const unsigned int bc = bucket_count;
+        ar << BOOST_SERIALIZATION_NVP(c);
+        ar << BOOST_SERIALIZATION_NVP(bc);
+    }
+    if(boost::archive::library_version_type(3) < library_version){
+        // record number of elements
+        // make sure the target type is registered so we can retrieve
+        // the version when we load
+        ar << BOOST_SERIALIZATION_NVP(item_version);
+    }
+    #else
+        ar << BOOST_SERIALIZATION_NVP(count);
+        ar << BOOST_SERIALIZATION_NVP(bucket_count);
+        ar << BOOST_SERIALIZATION_NVP(item_version);
+    #endif
+
+    typename Container::const_iterator it = s.begin();
+    while(count-- > 0){
+        // note borland emits a no-op without the explicit namespace
+        boost::serialization::save_construct_data_adl(
+            ar, 
+            &(*it), 
+            boost::serialization::version<
+                typename Container::value_type
+            >::value
+        );
+        ar << boost::serialization::make_nvp("item", *it++);
+    }
+}
+
+} // namespace stl 
+} // namespace serialization
+} // namespace boost
+
+#endif //BOOST_SERIALIZATION_HASH_COLLECTIONS_SAVE_IMP_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/hash_map.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/hash_map.hpp
new file mode 100644
index 00000000000..22626db6838
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/serialization/hash_map.hpp
@@ -0,0 +1,232 @@
+#ifndef  BOOST_SERIALIZATION_HASH_MAP_HPP
+#define BOOST_SERIALIZATION_HASH_MAP_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// serialization/hash_map.hpp:
+// serialization for stl hash_map templates
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+#include <boost/config.hpp>
+#ifdef BOOST_HAS_HASH
+#include BOOST_HASH_MAP_HEADER
+
+#include <boost/serialization/utility.hpp>
+#include <boost/serialization/hash_collections_save_imp.hpp>
+#include <boost/serialization/hash_collections_load_imp.hpp>
+#include <boost/serialization/split_free.hpp>
+#include <boost/move/utility_core.hpp>
+
+namespace boost { 
+namespace serialization {
+
+namespace stl {
+
+// map input
+template<class Archive, class Container>
+struct archive_input_hash_map
+{
+    inline void operator()(
+        Archive &ar, 
+        Container &s, 
+        const unsigned int v
+    ){
+        typedef typename Container::value_type type;
+        detail::stack_construct<Archive, type> t(ar, v);
+        // borland fails silently w/o full namespace
+        ar >> boost::serialization::make_nvp("item", t.reference());
+        std::pair<typename Container::const_iterator, bool> result = 
+            s.insert(boost::move(t.reference()));
+        // note: the following presumes that the map::value_type was NOT tracked
+        // in the archive.  This is the usual case, but here there is no way
+        // to determine that.  
+        if(result.second){
+            ar.reset_object_address(
+                & (result.first->second),
+                & t.reference().second
+            );
+        }
+    }
+};
+
+// multimap input
+template<class Archive, class Container>
+struct archive_input_hash_multimap
+{
+    inline void operator()(
+        Archive &ar, 
+        Container &s, 
+        const unsigned int v
+    ){
+        typedef typename Container::value_type type;
+        detail::stack_construct<Archive, type> t(ar, v);
+        // borland fails silently w/o full namespace
+        ar >> boost::serialization::make_nvp("item", t.reference());
+        typename Container::const_iterator result 
+            = s.insert(boost::move(t.reference()));
+        // note: the following presumes that the map::value_type was NOT tracked
+        // in the archive.  This is the usual case, but here there is no way
+        // to determine that.  
+        ar.reset_object_address(
+            & result->second,
+            & t.reference()
+        );
+    }
+};
+
+} // stl
+
+template<
+    class Archive, 
+    class Key, 
+    class HashFcn, 
+    class EqualKey,
+    class Allocator
+>
+inline void save(
+    Archive & ar,
+    const BOOST_STD_EXTENSION_NAMESPACE::hash_map<
+        Key, HashFcn, EqualKey, Allocator
+    > &t,
+    const unsigned int file_version
+){
+    boost::serialization::stl::save_hash_collection<
+        Archive, 
+        BOOST_STD_EXTENSION_NAMESPACE::hash_map<
+            Key, HashFcn, EqualKey, Allocator
+        >
+    >(ar, t);
+}
+
+template<
+    class Archive, 
+    class Key, 
+    class HashFcn, 
+    class EqualKey,
+    class Allocator
+>
+inline void load(
+    Archive & ar,
+    BOOST_STD_EXTENSION_NAMESPACE::hash_map<
+        Key, HashFcn, EqualKey, Allocator
+    > &t,
+    const unsigned int file_version
+){
+    boost::serialization::stl::load_hash_collection<
+        Archive,
+        BOOST_STD_EXTENSION_NAMESPACE::hash_map<
+            Key, HashFcn, EqualKey, Allocator
+        >,
+        boost::serialization::stl::archive_input_hash_map<
+            Archive, 
+            BOOST_STD_EXTENSION_NAMESPACE::hash_map<
+                Key, HashFcn, EqualKey, Allocator
+            >
+        >
+    >(ar, t);
+}
+
+// split non-intrusive serialization function member into separate
+// non intrusive save/load member functions
+template<
+    class Archive, 
+    class Key, 
+    class HashFcn, 
+    class EqualKey,
+    class Allocator
+>
+inline void serialize(
+    Archive & ar,
+    BOOST_STD_EXTENSION_NAMESPACE::hash_map<
+        Key, HashFcn, EqualKey, Allocator
+    > &t,
+    const unsigned int file_version
+){
+    boost::serialization::split_free(ar, t, file_version);
+}
+
+// hash_multimap
+template<
+    class Archive, 
+    class Key, 
+    class HashFcn, 
+    class EqualKey,
+    class Allocator
+>
+inline void save(
+    Archive & ar,
+    const BOOST_STD_EXTENSION_NAMESPACE::hash_multimap<
+        Key, HashFcn, EqualKey, Allocator
+    > &t,
+    const unsigned int file_version
+){
+    boost::serialization::stl::save_hash_collection<
+        Archive, 
+        BOOST_STD_EXTENSION_NAMESPACE::hash_multimap<
+            Key, HashFcn, EqualKey, Allocator
+        >
+    >(ar, t);
+}
+
+template<
+    class Archive, 
+    class Key, 
+    class HashFcn, 
+    class EqualKey,
+    class Allocator
+>
+inline void load(
+    Archive & ar,
+    BOOST_STD_EXTENSION_NAMESPACE::hash_multimap<
+        Key, HashFcn, EqualKey, Allocator
+    > &t,
+    const unsigned int file_version
+){
+    boost::serialization::stl::load_hash_collection<
+        Archive,
+        BOOST_STD_EXTENSION_NAMESPACE::hash_multimap<
+            Key, HashFcn, EqualKey, Allocator
+        >,
+        boost::serialization::stl::archive_input_hash_multimap<
+            Archive, 
+            BOOST_STD_EXTENSION_NAMESPACE::hash_multimap<
+                Key, HashFcn, EqualKey, Allocator
+            >
+        >
+    >(ar, t);
+}
+
+// split non-intrusive serialization function member into separate
+// non intrusive save/load member functions
+template<
+    class Archive, 
+    class Key, 
+    class HashFcn, 
+    class EqualKey,
+    class Allocator
+>
+inline void serialize(
+    Archive & ar,
+    BOOST_STD_EXTENSION_NAMESPACE::hash_multimap<
+        Key, HashFcn, EqualKey, Allocator
+    > &t,
+    const unsigned int file_version
+){
+    boost::serialization::split_free(ar, t, file_version);
+}
+
+} // namespace serialization
+} // namespace boost
+
+#endif // BOOST_HAS_HASH
+#endif // BOOST_SERIALIZATION_HASH_MAP_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/hash_set.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/hash_set.hpp
new file mode 100644
index 00000000000..0c72c18457e
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/serialization/hash_set.hpp
@@ -0,0 +1,222 @@
+#ifndef  BOOST_SERIALIZATION_HASH_SET_HPP
+#define BOOST_SERIALIZATION_HASH_SET_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// hash_set.hpp: serialization for stl hash_set templates
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+#include <boost/config.hpp>
+#ifdef BOOST_HAS_HASH
+#include BOOST_HASH_SET_HEADER
+
+#include <boost/serialization/hash_collections_save_imp.hpp>
+#include <boost/serialization/hash_collections_load_imp.hpp>
+#include <boost/serialization/split_free.hpp>
+#include <boost/move/utility_core.hpp>
+
+namespace boost { 
+namespace serialization {
+
+namespace stl {
+
+// hash_set input
+template<class Archive, class Container>
+struct archive_input_hash_set
+{
+    inline void operator()(
+        Archive &ar, 
+        Container &s, 
+        const unsigned int v
+    ){
+        typedef typename Container::value_type type;
+        detail::stack_construct<Archive, type> t(ar, v);
+        // borland fails silently w/o full namespace
+        ar >> boost::serialization::make_nvp("item", t.reference());
+        std::pair<typename Container::const_iterator, bool> result = 
+            s.insert(boost::move(t.reference()));
+        if(result.second)
+            ar.reset_object_address(& (* result.first), & t.reference());
+    }
+};
+
+// hash_multiset input
+template<class Archive, class Container>
+struct archive_input_hash_multiset
+{
+    inline void operator()(
+        Archive &ar, 
+        Container &s, 
+        const unsigned int v
+    ){
+        typedef typename Container::value_type type;
+        detail::stack_construct<Archive, type> t(ar, v);
+        // borland fails silently w/o full namespace
+        ar >> boost::serialization::make_nvp("item", t.reference());
+        typename Container::const_iterator result 
+            = s.insert(boost::move(t.reference()));
+        ar.reset_object_address(& (* result), & t.reference());
+    }
+};
+
+} // stl
+
+template<
+    class Archive, 
+    class Key, 
+    class HashFcn, 
+    class EqualKey,
+    class Allocator
+>
+inline void save(
+    Archive & ar,
+    const BOOST_STD_EXTENSION_NAMESPACE::hash_set<
+        Key, HashFcn, EqualKey, Allocator
+    > &t,
+    const unsigned int file_version
+){
+    boost::serialization::stl::save_hash_collection<
+        Archive, 
+        BOOST_STD_EXTENSION_NAMESPACE::hash_set<
+            Key, HashFcn, EqualKey, Allocator
+        > 
+    >(ar, t);
+}
+
+template<
+    class Archive, 
+    class Key, 
+    class HashFcn, 
+    class EqualKey,
+    class Allocator
+>
+inline void load(
+    Archive & ar,
+    BOOST_STD_EXTENSION_NAMESPACE::hash_set<
+        Key, HashFcn, EqualKey, Allocator
+    > &t,
+    const unsigned int file_version
+){
+    boost::serialization::stl::load_hash_collection<
+        Archive,
+        BOOST_STD_EXTENSION_NAMESPACE::hash_set<
+            Key, HashFcn, EqualKey, Allocator
+        >,
+        boost::serialization::stl::archive_input_hash_set<
+            Archive, 
+            BOOST_STD_EXTENSION_NAMESPACE::hash_set<
+                Key, HashFcn, EqualKey, Allocator
+            >
+        >
+    >(ar, t);
+}
+
+// split non-intrusive serialization function member into separate
+// non intrusive save/load member functions
+template<
+    class Archive, 
+    class Key, 
+    class HashFcn, 
+    class EqualKey,
+    class Allocator
+>
+inline void serialize(
+    Archive & ar,
+    BOOST_STD_EXTENSION_NAMESPACE::hash_set<
+        Key, HashFcn, EqualKey, Allocator
+    > &t,
+    const unsigned int file_version
+){
+    boost::serialization::split_free(ar, t, file_version);
+}
+
+// hash_multiset
+template<
+    class Archive, 
+    class Key, 
+    class HashFcn, 
+    class EqualKey,
+    class Allocator
+>
+inline void save(
+    Archive & ar,
+    const BOOST_STD_EXTENSION_NAMESPACE::hash_multiset<
+        Key, HashFcn, EqualKey, Allocator
+    > &t,
+    const unsigned int file_version
+){
+    boost::serialization::stl::save_hash_collection<
+        Archive, 
+        BOOST_STD_EXTENSION_NAMESPACE::hash_multiset<
+            Key, HashFcn, EqualKey, Allocator
+        > 
+    >(ar, t);
+}
+
+template<
+    class Archive, 
+    class Key, 
+    class HashFcn, 
+    class EqualKey,
+    class Allocator
+>
+inline void load(
+    Archive & ar,
+    BOOST_STD_EXTENSION_NAMESPACE::hash_multiset<
+        Key, HashFcn, EqualKey, Allocator
+    > &t,
+    const unsigned int file_version
+){
+    boost::serialization::stl::load_hash_collection<
+        Archive,
+        BOOST_STD_EXTENSION_NAMESPACE::hash_multiset<
+            Key, HashFcn, EqualKey, Allocator
+        >,
+        boost::serialization::stl::archive_input_hash_multiset<
+            Archive,
+            BOOST_STD_EXTENSION_NAMESPACE::hash_multiset<
+                Key, HashFcn, EqualKey, Allocator
+            > 
+        >
+    >(ar, t);
+}
+
+// split non-intrusive serialization function member into separate
+// non intrusive save/load member functions
+template<
+    class Archive, 
+    class Key, 
+    class HashFcn, 
+    class EqualKey,
+    class Allocator
+>
+inline void serialize(
+    Archive & ar,
+    BOOST_STD_EXTENSION_NAMESPACE::hash_multiset<
+        Key, HashFcn, EqualKey, Allocator
+    > & t,
+    const unsigned int file_version
+){
+    boost::serialization::split_free(ar, t, file_version);
+}
+
+} // namespace serialization
+} // namespace boost
+
+#include <boost/serialization/collection_traits.hpp>
+
+BOOST_SERIALIZATION_COLLECTION_TRAITS(BOOST_STD_EXTENSION_NAMESPACE::hash_set)
+BOOST_SERIALIZATION_COLLECTION_TRAITS(BOOST_STD_EXTENSION_NAMESPACE::hash_multiset)
+
+#endif // BOOST_HAS_HASH
+#endif // BOOST_SERIALIZATION_HASH_SET_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/is_bitwise_serializable.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/is_bitwise_serializable.hpp
new file mode 100644
index 00000000000..7e24a2cb6d8
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/serialization/is_bitwise_serializable.hpp
@@ -0,0 +1,46 @@
+// (C) Copyright 2007 Matthias Troyer
+
+// Use, modification and distribution is subject to the 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: Matthias Troyer
+
+/** @file is_bitwise_serializable.hpp
+ *
+ *  This header provides a traits class for determining whether a class
+ * can be serialized (in a non-portable way) just by copying the bits.
+ */
+
+
+#ifndef BOOST_SERIALIZATION_IS_BITWISE_SERIALIZABLE_HPP
+#define BOOST_SERIALIZATION_IS_BITWISE_SERIALIZABLE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+#include <boost/mpl/bool_fwd.hpp>
+#include <boost/type_traits/is_arithmetic.hpp>
+
+namespace boost {
+namespace serialization {
+    template<class T>
+    struct is_bitwise_serializable
+     : public is_arithmetic< T >
+    {};
+} // namespace serialization
+} // namespace boost
+
+
+// define a macro to make explicit designation of this more transparent
+#define BOOST_IS_BITWISE_SERIALIZABLE(T)              \
+namespace boost {                                     \
+namespace serialization {                             \
+template<>                                            \
+struct is_bitwise_serializable< T > : mpl::true_ {};  \
+}}                                                    \
+/**/
+
+#endif //BOOST_SERIALIZATION_IS_BITWISE_SERIALIZABLE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/item_version_type.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/item_version_type.hpp
new file mode 100644
index 00000000000..f3e5adac6f8
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/serialization/item_version_type.hpp
@@ -0,0 +1,68 @@
+#ifndef BOOST_SERIALIZATION_ITEM_VERSION_TYPE_HPP
+#define BOOST_SERIALIZATION_ITEM_VERSION_TYPE_HPP
+
+// (C) Copyright 2010 Robert Ramey
+// Use, modification and distribution is subject to the 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/cstdint.hpp> // uint_least8_t
+#include <boost/integer_traits.hpp>
+#include <boost/serialization/level.hpp>
+#include <boost/serialization/is_bitwise_serializable.hpp>
+
+// fixes broken example build on x86_64-linux-gnu-gcc-4.6.0
+#include <boost/assert.hpp>
+
+namespace boost { 
+namespace serialization {
+
+#if defined(_MSC_VER)
+#pragma warning( push )
+#pragma warning( disable : 4244 4267 )
+#endif
+
+class item_version_type {
+private:
+    typedef unsigned int base_type;
+    base_type t;
+public:
+    // should be private - but MPI fails if it's not!!!
+    item_version_type(): t(0) {};
+    explicit item_version_type(const unsigned int t_) : t(t_){
+        BOOST_ASSERT(t_ <= boost::integer_traits<base_type>::const_max);
+    }
+    item_version_type(const item_version_type & t_) : 
+        t(t_.t)
+    {}
+    item_version_type & operator=(item_version_type rhs){
+        t = rhs.t; 
+        return *this;
+    }
+    // used for text output
+    operator base_type () const {
+        return t;
+    }                
+    // used for text input
+    operator base_type & () {
+        return t;
+    }
+    bool operator==(const item_version_type & rhs) const {
+        return t == rhs.t;
+    } 
+    bool operator<(const item_version_type & rhs) const {
+        return t < rhs.t;
+    }
+};
+
+#if defined(_MSC_VER)
+#pragma warning( pop )
+#endif
+
+} } // end namespace boost::serialization
+
+BOOST_IS_BITWISE_SERIALIZABLE(item_version_type)
+
+BOOST_CLASS_IMPLEMENTATION(item_version_type, primitive_type)
+
+#endif //BOOST_SERIALIZATION_ITEM_VERSION_TYPE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/level.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/level.hpp
new file mode 100644
index 00000000000..f6a84d10422
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/serialization/level.hpp
@@ -0,0 +1,116 @@
+#ifndef BOOST_SERIALIZATION_LEVEL_HPP
+#define BOOST_SERIALIZATION_LEVEL_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// level.hpp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+#include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
+
+#include <boost/type_traits/is_fundamental.hpp>
+#include <boost/type_traits/is_enum.hpp>
+#include <boost/type_traits/is_array.hpp>
+#include <boost/type_traits/is_class.hpp>
+#include <boost/type_traits/is_base_and_derived.hpp>
+
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/int.hpp>
+#include <boost/mpl/integral_c.hpp>
+#include <boost/mpl/integral_c_tag.hpp>
+
+#include <boost/serialization/level_enum.hpp>
+
+namespace boost {
+namespace serialization {
+
+struct basic_traits;
+
+// default serialization implementation level
+template<class T>
+struct implementation_level_impl {
+    template<class U>
+    struct traits_class_level {
+        typedef typename U::level type;
+    };
+
+    typedef mpl::integral_c_tag tag;
+    // note: at least one compiler complained w/o the full qualification
+    // on basic traits below
+    typedef
+        typename mpl::eval_if<
+            is_base_and_derived<boost::serialization::basic_traits, T>,
+            traits_class_level< T >,
+        //else
+        typename mpl::eval_if<
+            is_fundamental< T >,
+            mpl::int_<primitive_type>,
+        //else
+        typename mpl::eval_if<
+            is_class< T >,
+            mpl::int_<object_class_info>,
+        //else
+        typename mpl::eval_if<
+            is_array< T >,
+                mpl::int_<object_serializable>,
+        //else
+        typename mpl::eval_if<
+            is_enum< T >,
+                mpl::int_<primitive_type>,
+        //else
+            mpl::int_<not_serializable>
+        >
+        >
+        >
+        >
+        >::type type;
+        // vc 7.1 doesn't like enums here
+    BOOST_STATIC_CONSTANT(int, value = type::value);
+};
+
+template<class T>
+struct implementation_level : 
+    public implementation_level_impl<const T>
+{
+};
+
+template<class T, int L>
+inline bool operator>=(implementation_level< T > t, enum level_type l)
+{
+    return t.value >= (int)l;
+}
+
+} // namespace serialization
+} // namespace boost
+
+// specify the level of serialization implementation for the class
+// require that class info saved when versioning is used
+#define BOOST_CLASS_IMPLEMENTATION(T, E)                 \
+    namespace boost {                                    \
+    namespace serialization {                            \
+    template <>                                          \
+    struct implementation_level_impl< const T >                     \
+    {                                                    \
+        typedef mpl::integral_c_tag tag;                 \
+        typedef mpl::int_< E > type;                     \
+        BOOST_STATIC_CONSTANT(                           \
+            int,                                         \
+            value = implementation_level_impl::type::value    \
+        );                                               \
+    };                                                   \
+    }                                                    \
+    }
+    /**/
+
+#endif // BOOST_SERIALIZATION_LEVEL_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/level_enum.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/level_enum.hpp
new file mode 100644
index 00000000000..baf64e04f31
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/serialization/level_enum.hpp
@@ -0,0 +1,55 @@
+#ifndef BOOST_SERIALIZATION_LEVEL_ENUM_HPP
+#define BOOST_SERIALIZATION_LEVEL_ENUM_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// level_enum.hpp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+namespace boost {
+namespace serialization {
+
+// for each class used in the program, specify which level
+// of serialization should be implemented
+
+// names for each level
+enum level_type
+{
+    // Don't serialize this type. An attempt to do so should
+    // invoke a compile time assertion.
+    not_serializable = 0,
+    // write/read this type directly to the archive. In this case
+    // serialization code won't be called.  This is the default
+    // case for fundamental types.  It presumes a member function or
+    // template in the archive class that can handle this type.
+    // there is no runtime overhead associated reading/writing
+    // instances of this level
+    primitive_type = 1,
+    // Serialize the objects of this type using the objects "serialize"
+    // function or template. This permits values to be written/read
+    // to/from archives but includes no class or version information. 
+    object_serializable = 2,
+    ///////////////////////////////////////////////////////////////////
+    // once an object is serialized at one of the above levels, the
+    // corresponding archives cannot be read if the implementation level
+    // for the archive object is changed.  
+    ///////////////////////////////////////////////////////////////////
+    // Add class information to the archive.  Class information includes
+    // implementation level, class version and class name if available
+    object_class_info = 3
+};
+
+} // namespace serialization
+} // namespace boost
+
+#endif // BOOST_SERIALIZATION_LEVEL_ENUM_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/list.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/list.hpp
new file mode 100644
index 00000000000..5fdc114d7ed
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/serialization/list.hpp
@@ -0,0 +1,85 @@
+#ifndef BOOST_SERIALIZATION_LIST_HPP
+#define BOOST_SERIALIZATION_LIST_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// list.hpp: serialization for stl list templates
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+#include <list>
+
+#include <boost/config.hpp>
+
+#include <boost/serialization/collections_save_imp.hpp>
+#include <boost/serialization/collections_load_imp.hpp>
+
+#include <boost/archive/detail/basic_iarchive.hpp>
+#include <boost/serialization/access.hpp>
+#include <boost/serialization/nvp.hpp>
+#include <boost/serialization/collection_size_type.hpp>
+#include <boost/serialization/item_version_type.hpp>
+#include <boost/serialization/split_free.hpp>
+
+namespace boost { 
+namespace serialization {
+
+template<class Archive, class U, class Allocator>
+inline void save(
+    Archive & ar,
+    const std::list<U, Allocator> &t,
+    const unsigned int /* file_version */
+){
+    boost::serialization::stl::save_collection<
+        Archive, 
+        std::list<U, Allocator> 
+    >(ar, t);
+}
+
+template<class Archive, class U, class Allocator>
+inline void load(
+    Archive & ar,
+    std::list<U, Allocator> &t,
+    const unsigned int /* file_version */
+){
+    const boost::archive::library_version_type library_version(
+        ar.get_library_version()
+    );
+    // retrieve number of elements
+    item_version_type item_version(0);
+    collection_size_type count;
+    ar >> BOOST_SERIALIZATION_NVP(count);
+    if(boost::archive::library_version_type(3) < library_version){
+        ar >> BOOST_SERIALIZATION_NVP(item_version);
+    }
+    stl::collection_load_impl(ar, t, count, item_version);
+}
+
+// split non-intrusive serialization function member into separate
+// non intrusive save/load member functions
+template<class Archive, class U, class Allocator>
+inline void serialize(
+    Archive & ar,
+    std::list<U, Allocator> & t,
+    const unsigned int file_version
+){
+    boost::serialization::split_free(ar, t, file_version);
+}
+
+} // serialization
+} // namespace boost
+
+#include <boost/serialization/collection_traits.hpp>
+
+BOOST_SERIALIZATION_COLLECTION_TRAITS(std::list)
+
+#endif // BOOST_SERIALIZATION_LIST_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/map.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/map.hpp
new file mode 100644
index 00000000000..9209864c8cf
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/serialization/map.hpp
@@ -0,0 +1,139 @@
+#ifndef  BOOST_SERIALIZATION_MAP_HPP
+#define BOOST_SERIALIZATION_MAP_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// serialization/map.hpp:
+// serialization for stl map templates
+
+// (C) Copyright 2002-2014 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+#include <map>
+
+#include <boost/config.hpp>
+
+#include <boost/archive/detail/basic_iarchive.hpp>
+#include <boost/serialization/access.hpp>
+#include <boost/serialization/nvp.hpp>
+#include <boost/serialization/collection_size_type.hpp>
+#include <boost/serialization/item_version_type.hpp>
+#include <boost/serialization/detail/stack_constructor.hpp>
+
+#include <boost/serialization/utility.hpp>
+#include <boost/serialization/collections_save_imp.hpp>
+#include <boost/serialization/split_free.hpp>
+#include <boost/move/utility_core.hpp>
+
+namespace boost { 
+namespace serialization {
+
+////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// implementation of serialization for map and mult-map STL containers
+
+template<class Archive, class Container>
+inline void load_map_collection(Archive & ar, Container &s)
+{
+    s.clear();
+    const boost::archive::library_version_type library_version(
+        ar.get_library_version()
+    );
+    // retrieve number of elements
+    item_version_type item_version(0);
+    collection_size_type count;
+    ar >> BOOST_SERIALIZATION_NVP(count);
+    if(boost::archive::library_version_type(3) < library_version){
+        ar >> BOOST_SERIALIZATION_NVP(item_version);
+    }
+    typename Container::iterator hint;
+    hint = s.begin();
+    while(count-- > 0){
+        typedef typename Container::value_type type;
+        detail::stack_construct<Archive, type> t(ar, item_version);
+        ar >> boost::serialization::make_nvp("item", t.reference());
+        typename Container::iterator result =
+            s.insert(hint, boost::move(t.reference()));
+        ar.reset_object_address(& (result->second), & t.reference().second);
+        hint = result;
+        ++hint;
+    }
+}
+
+// map
+template<class Archive, class Type, class Key, class Compare, class Allocator >
+inline void save(
+    Archive & ar,
+    const std::map<Key, Type, Compare, Allocator> &t,
+    const unsigned int /* file_version */
+){
+    boost::serialization::stl::save_collection<
+        Archive, 
+        std::map<Key, Type, Compare, Allocator> 
+    >(ar, t);
+}
+
+template<class Archive, class Type, class Key, class Compare, class Allocator >
+inline void load(
+    Archive & ar,
+    std::map<Key, Type, Compare, Allocator> &t,
+    const unsigned int /* file_version */
+){
+    load_map_collection(ar, t);
+}
+
+// split non-intrusive serialization function member into separate
+// non intrusive save/load member functions
+template<class Archive, class Type, class Key, class Compare, class Allocator >
+inline void serialize(
+    Archive & ar,
+    std::map<Key, Type, Compare, Allocator> &t,
+    const unsigned int file_version
+){
+    boost::serialization::split_free(ar, t, file_version);
+}
+
+// multimap
+template<class Archive, class Type, class Key, class Compare, class Allocator >
+inline void save(
+    Archive & ar,
+    const std::multimap<Key, Type, Compare, Allocator> &t,
+    const unsigned int /* file_version */
+){
+    boost::serialization::stl::save_collection<
+        Archive, 
+        std::multimap<Key, Type, Compare, Allocator> 
+    >(ar, t);
+}
+
+template<class Archive, class Type, class Key, class Compare, class Allocator >
+inline void load(
+    Archive & ar,
+    std::multimap<Key, Type, Compare, Allocator> &t,
+    const unsigned int /* file_version */
+){
+    load_map_collection(ar, t);
+}
+
+// split non-intrusive serialization function member into separate
+// non intrusive save/load member functions
+template<class Archive, class Type, class Key, class Compare, class Allocator >
+inline void serialize(
+    Archive & ar,
+    std::multimap<Key, Type, Compare, Allocator> &t,
+    const unsigned int file_version
+){
+    boost::serialization::split_free(ar, t, file_version);
+}
+
+} // serialization
+} // namespace boost
+
+#endif // BOOST_SERIALIZATION_MAP_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/nvp.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/nvp.hpp
new file mode 100644
index 00000000000..4e2297b3cc9
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/serialization/nvp.hpp
@@ -0,0 +1,123 @@
+#ifndef BOOST_SERIALIZATION_NVP_HPP
+#define BOOST_SERIALIZATION_NVP_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// nvp.hpp: interface for serialization system.
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+#include <utility>
+
+#include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
+
+#include <boost/serialization/level.hpp>
+#include <boost/serialization/tracking.hpp>
+#include <boost/serialization/split_member.hpp>
+#include <boost/serialization/base_object.hpp>
+#include <boost/serialization/traits.hpp>
+#include <boost/serialization/wrapper.hpp>
+
+namespace boost {
+namespace serialization {
+
+template<class T>
+struct nvp : 
+    public std::pair<const char *, T *>,
+    public wrapper_traits<const nvp< T > >
+{
+//private:
+    nvp(const nvp & rhs) :
+        std::pair<const char *, T *>(rhs.first, rhs.second)
+    {}
+public:
+    explicit nvp(const char * name_, T & t) :
+        // note: added _ to suppress useless gcc warning
+        std::pair<const char *, T *>(name_, & t)
+    {}
+
+    const char * name() const {
+        return this->first;
+    }
+    T & value() const {
+        return *(this->second);
+    }
+
+    const T & const_value() const {
+        return *(this->second);
+    }
+
+    template<class Archive>
+    void save(
+        Archive & ar,
+        const unsigned int /* file_version */
+    ) const {
+        ar.operator<<(const_value());
+    }
+    template<class Archive>
+    void load(
+        Archive & ar,
+        const unsigned int /* file_version */
+    ){
+        ar.operator>>(value());
+    }
+    BOOST_SERIALIZATION_SPLIT_MEMBER()
+};
+
+template<class T>
+inline
+const nvp< T > make_nvp(const char * name, T & t){
+    return nvp< T >(name, t);
+}
+
+// to maintain efficiency and portability, we want to assign
+// specific serialization traits to all instances of this wrappers.
+// we can't strait forward method below as it depends upon
+// Partial Template Specialization and doing so would mean that wrappers
+// wouldn't be treated the same on different platforms.  This would
+// break archive portability. Leave this here as reminder not to use it !!!
+
+template <class T>
+struct implementation_level<nvp< T > >
+{
+    typedef mpl::integral_c_tag tag;
+    typedef mpl::int_<object_serializable> type;
+    BOOST_STATIC_CONSTANT(int, value = implementation_level::type::value);
+};
+
+// nvp objects are generally created on the stack and are never tracked
+template<class T>
+struct tracking_level<nvp< T > >
+{
+    typedef mpl::integral_c_tag tag;
+    typedef mpl::int_<track_never> type;
+    BOOST_STATIC_CONSTANT(int, value = tracking_level::type::value);
+};
+
+} // seralization
+} // boost
+
+#include <boost/preprocessor/stringize.hpp>
+
+#define BOOST_SERIALIZATION_NVP(name)                              \
+    boost::serialization::make_nvp(BOOST_PP_STRINGIZE(name), name)
+/**/
+
+#define BOOST_SERIALIZATION_BASE_OBJECT_NVP(name)                  \
+    boost::serialization::make_nvp(                                \
+        BOOST_PP_STRINGIZE(name),                                  \
+        boost::serialization::base_object<name >(*this)            \
+    )
+/**/
+
+#endif // BOOST_SERIALIZATION_NVP_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/optional.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/optional.hpp
new file mode 100644
index 00000000000..d6ff830a8c3
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/serialization/optional.hpp
@@ -0,0 +1,107 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+
+// (C) Copyright 2002-4 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)
+
+// Provides non-intrusive serialization for boost::optional.
+
+#ifndef BOOST_SERIALIZATION_OPTIONAL_HPP_
+#define BOOST_SERIALIZATION_OPTIONAL_HPP_
+
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+#include <boost/config.hpp>
+
+#include <boost/archive/detail/basic_iarchive.hpp>
+
+#include <boost/optional.hpp>
+#include <boost/move/utility_core.hpp>
+
+#include <boost/serialization/item_version_type.hpp>
+#include <boost/serialization/split_free.hpp>
+#include <boost/serialization/level.hpp>
+#include <boost/serialization/nvp.hpp>
+#include <boost/serialization/version.hpp>
+#include <boost/type_traits/is_pointer.hpp>
+#include <boost/serialization/detail/stack_constructor.hpp>
+#include <boost/serialization/detail/is_default_constructible.hpp>
+#include <boost/serialization/force_include.hpp>
+
+// function specializations must be defined in the appropriate
+// namespace - boost::serialization
+namespace boost { 
+namespace serialization {
+
+template<class Archive, class T>
+void save(
+    Archive & ar, 
+    const boost::optional< T > & t, 
+    const unsigned int /*version*/
+){
+    // It is an inherent limitation to the serialization of optional.hpp
+    // that the underlying type must be either a pointer or must have a
+    // default constructor.  It's possible that this could change sometime
+    // in the future, but for now, one will have to work around it.  This can
+    // be done by serialization the optional<T> as optional<T *>
+    #if ! defined(BOOST_NO_CXX11_HDR_TYPE_TRAITS)
+        BOOST_STATIC_ASSERT(
+            boost::serialization::detail::is_default_constructible<T>::value
+            || boost::is_pointer<T>::value
+        );
+    #endif
+    const bool tflag = t.is_initialized();
+    ar << boost::serialization::make_nvp("initialized", tflag);
+    if (tflag){
+        ar << boost::serialization::make_nvp("value", *t);
+    }
+}
+
+template<class Archive, class T>
+void load(
+    Archive & ar, 
+    boost::optional< T > & t, 
+    const unsigned int version
+){
+    bool tflag;
+    ar >> boost::serialization::make_nvp("initialized", tflag);
+    if(! tflag){
+        t.reset();
+        return;
+    }
+
+    if(0 == version){
+        boost::serialization::item_version_type item_version(0);
+        boost::archive::library_version_type library_version(
+            ar.get_library_version()
+        );
+        if(boost::archive::library_version_type(3) < library_version){
+            ar >> BOOST_SERIALIZATION_NVP(item_version);
+        }
+    }
+    if(! t.is_initialized())
+        t = T();
+    ar >> boost::serialization::make_nvp("value", *t);
+}
+
+template<class Archive, class T>
+void serialize(
+    Archive & ar, 
+    boost::optional< T > & t, 
+    const unsigned int version
+){
+    boost::serialization::split_free(ar, t, version);
+}
+
+template<class T>
+struct version<boost::optional<T> > {
+    BOOST_STATIC_CONSTANT(int, value = 1);
+};
+
+} // serialization
+} // boost
+
+#endif // BOOST_SERIALIZATION_OPTIONAL_HPP_
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/priority_queue.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/priority_queue.hpp
new file mode 100644
index 00000000000..5b08ffd1e82
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/serialization/priority_queue.hpp
@@ -0,0 +1,76 @@
+#ifndef  BOOST_SERIALIZATION_PRIORITY_QUEUE_HPP
+#define BOOST_SERIALIZATION_PRIORITY_QUEUE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// priority_queue.hpp
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+#include <queue>
+#include <boost/config.hpp>
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/identity.hpp>
+
+// function specializations must be defined in the appropriate
+// namespace - boost::serialization
+#if defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION)
+#define STD _STLP_STD
+#else
+#define STD std
+#endif
+
+namespace boost { 
+namespace serialization {
+namespace detail{
+
+template <typename U, typename Container, typename Compare>
+struct priority_queue_save : public STD::priority_queue<U, Container, Compare> {
+    template<class Archive>
+    void operator()(Archive & ar, const unsigned int file_version) const {
+        save(ar, STD::priority_queue<U, Container, Compare>::c, file_version);
+    }
+};
+template <typename U, typename Container, typename Compare>
+struct priority_queue_load : public STD::priority_queue<U, Container, Compare> {
+    template<class Archive>
+    void operator()(Archive & ar, const unsigned int file_version) {
+        load(ar, STD::priority_queue<U, Container, Compare>::c, file_version);
+    }
+};
+
+} // detail
+
+template<class Archive, class T, class Container, class Compare>
+inline void serialize(
+    Archive & ar,
+    std::priority_queue< T, Container, Compare> & t,
+    const unsigned int file_version 
+){
+    typedef typename mpl::eval_if<
+        typename Archive::is_saving,
+        mpl::identity<detail::priority_queue_save<T, Container, Compare> >,
+        mpl::identity<detail::priority_queue_load<T, Container, Compare> >
+    >::type typex;
+    static_cast<typex &>(t)(ar, file_version);
+}
+
+} // namespace serialization
+} // namespace boost
+
+#include <boost/serialization/collection_traits.hpp>
+
+BOOST_SERIALIZATION_COLLECTION_TRAITS(STD::priority_queue)
+
+#undef STD
+
+#endif // BOOST_SERIALIZATION_PRIORITY_QUEUE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/queue.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/queue.hpp
new file mode 100644
index 00000000000..b22745215d9
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/serialization/queue.hpp
@@ -0,0 +1,76 @@
+#ifndef  BOOST_SERIALIZATION_QUEUE_HPP
+#define BOOST_SERIALIZATION_QUEUE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// queue.hpp
+
+// (C) Copyright 2014 Robert Ramey - http://www.rrsd.com .
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+#include <queue>
+#include <boost/config.hpp>
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/identity.hpp>
+
+// function specializations must be defined in the appropriate
+// namespace - boost::serialization
+#if defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION)
+#define STD _STLP_STD
+#else
+#define STD std
+#endif
+
+namespace boost { 
+namespace serialization {
+namespace detail {
+
+template <typename U, typename C>
+struct queue_save : public STD::queue<U, C> {
+    template<class Archive>
+    void operator()(Archive & ar, const unsigned int file_version) const {
+        save(ar, STD::queue<U, C>::c, file_version);
+    }
+};
+template <typename U, typename C>
+struct queue_load : public STD::queue<U, C> {
+    template<class Archive>
+    void operator()(Archive & ar, const unsigned int file_version) {
+        load(ar, STD::queue<U, C>::c, file_version);
+    }
+};
+
+} // detail
+
+template<class Archive, class T, class C>
+inline void serialize(
+    Archive & ar,
+    std::queue< T, C> & t,
+    const unsigned int file_version 
+){
+    typedef typename mpl::eval_if<
+        typename Archive::is_saving,
+        mpl::identity<detail::queue_save<T, C> >,
+        mpl::identity<detail::queue_load<T, C> >
+    >::type typex;
+    static_cast<typex &>(t)(ar, file_version);
+}
+
+} // namespace serialization
+} // namespace boost
+
+#include <boost/serialization/collection_traits.hpp>
+
+BOOST_SERIALIZATION_COLLECTION_TRAITS(STD::queue)
+
+#undef STD
+
+#endif // BOOST_SERIALIZATION_QUEUE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/scoped_ptr.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/scoped_ptr.hpp
new file mode 100644
index 00000000000..0d11f8436e0
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/serialization/scoped_ptr.hpp
@@ -0,0 +1,58 @@
+#ifndef BOOST_SERIALIZATION_SCOPED_PTR_HPP_VP_2003_10_30
+#define BOOST_SERIALIZATION_SCOPED_PTR_HPP_VP_2003_10_30
+
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+//  Copyright (c) 2003 Vladimir Prus.
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// Provides non-intrusive serialization for boost::scoped_ptr
+// Does not allow to serialize scoped_ptr's to builtin types.
+
+#include <boost/config.hpp>
+
+#include <boost/scoped_ptr.hpp>
+#include <boost/serialization/nvp.hpp>
+#include <boost/serialization/split_free.hpp>
+
+namespace boost { 
+namespace serialization {
+    
+    template<class Archive, class T>
+    void save(
+        Archive & ar, 
+        const boost::scoped_ptr< T > & t, 
+        const unsigned int /* version */
+    ){
+        T* r = t.get();
+        ar << boost::serialization::make_nvp("scoped_ptr", r);
+    }
+
+    template<class Archive, class T>
+    void load(
+        Archive & ar, 
+        boost::scoped_ptr< T > & t, 
+        const unsigned int /* version */
+    ){
+        T* r;
+        ar >> boost::serialization::make_nvp("scoped_ptr", r);
+        t.reset(r); 
+    }
+
+    template<class Archive, class T>
+    void serialize(
+        Archive& ar, 
+        boost::scoped_ptr< T >& t, 
+        const unsigned int version
+    ){
+        boost::serialization::split_free(ar, t, version);
+    }
+
+} // namespace serialization
+} // namespace boost
+
+#endif // BOOST_SERIALIZATION_SCOPED_PTR_HPP_VP_2003_10_30
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/serialization.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/serialization.hpp
new file mode 100644
index 00000000000..a4d04723c75
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/serialization/serialization.hpp
@@ -0,0 +1,154 @@
+#ifndef BOOST_SERIALIZATION_SERIALIZATION_HPP
+#define BOOST_SERIALIZATION_SERIALIZATION_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+#if defined(_MSC_VER)
+#  pragma warning (disable : 4675) // suppress ADL warning
+#endif
+
+#include <boost/config.hpp>
+#include <boost/serialization/strong_typedef.hpp>
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// serialization.hpp: interface for serialization system.
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+//////////////////////////////////////////////////////////////////////
+// public interface to serialization. 
+
+/////////////////////////////////////////////////////////////////////////////
+// layer 0 - intrusive verison
+// declared and implemented for each user defined class to be serialized
+//
+//  template<Archive>
+//  serialize(Archive &ar, const unsigned int file_version){
+//      ar & base_object<base>(*this) & member1 & member2 ... ;
+//  }
+
+/////////////////////////////////////////////////////////////////////////////
+// layer 1 - layer that routes member access through the access class.
+// this is what permits us to grant access to private class member functions
+// by specifying friend class boost::serialization::access
+
+#include <boost/serialization/access.hpp>
+
+/////////////////////////////////////////////////////////////////////////////
+// layer 2 - default implementation of non-intrusive serialization.
+//
+// note the usage of function overloading to compensate that C++ does not
+// currently support Partial Template Specialization for function templates 
+// We have declared the version number as "const unsigned long".  
+// Overriding templates for specific data types should declare the version
+// number as "const unsigned int". Template matching will first be applied
+// to functions with the same version types - that is the overloads.  
+// If there is no declared function prototype that matches, the second argument
+// will be converted to "const unsigned long" and a match will be made with 
+// one of the default template functions below.
+
+namespace boost {
+namespace serialization {
+
+BOOST_STRONG_TYPEDEF(unsigned int, version_type)
+
+// default implementation - call the member function "serialize"
+template<class Archive, class T>
+inline void serialize(
+    Archive & ar, T & t, const unsigned int file_version
+){
+    access::serialize(ar, t, static_cast<unsigned int>(file_version));
+}
+
+// save data required for construction
+template<class Archive, class T>
+inline void save_construct_data(
+    Archive & /*ar*/, 
+    const T * /*t*/, 
+    const unsigned int /*file_version */
+){
+    // default is to save no data because default constructor
+    // requires no arguments.
+}
+
+// load data required for construction and invoke constructor in place
+template<class Archive, class T>
+inline void load_construct_data(
+    Archive & /*ar*/, 
+    T * t, 
+    const unsigned int /*file_version*/
+){
+    // default just uses the default constructor.  going
+    // through access permits usage of otherwise private default
+    // constructor
+    access::construct(t);
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// layer 3 - move call into serialization namespace so that ADL will function
+// in the manner we desire.
+//
+// on compilers which don't implement ADL. only the current namespace
+// i.e. boost::serialization will be searched.
+// 
+// on compilers which DO implement ADL
+// serialize overrides can be in any of the following
+// 
+// 1) same namepace as Archive
+// 2) same namespace as T
+// 3) boost::serialization
+//
+// Due to Martin Ecker
+
+template<class Archive, class T>
+inline void serialize_adl(
+    Archive & ar, 
+    T & t, 
+    const unsigned int file_version
+){
+    // note usage of function overloading to delay final resolution
+    // until the point of instantiation.  This works around the two-phase
+    // lookup "feature" which inhibits redefintion of a default function
+    // template implementation. Due to Robert Ramey
+    //
+    // Note that this trick generates problems for compiles which don't support
+    // PFTO, suppress it here.  As far as we know, there are no compilers
+    // which fail to support PFTO while supporting two-phase lookup.
+    const version_type v(file_version);
+    serialize(ar, t, v);
+}
+
+template<class Archive, class T>
+inline void save_construct_data_adl(
+    Archive & ar, 
+    const T * t, 
+    const unsigned int file_version
+){
+    // see above
+    const version_type v(file_version);
+    save_construct_data(ar, t, v);
+}
+
+template<class Archive, class T>
+inline void load_construct_data_adl(
+    Archive & ar, 
+    T * t, 
+    const unsigned int file_version
+){
+    // see above comment
+    const version_type v(file_version);
+    load_construct_data(ar, t, v);
+}
+
+} // namespace serialization
+} // namespace boost
+
+#endif //BOOST_SERIALIZATION_SERIALIZATION_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/set.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/set.hpp
new file mode 100644
index 00000000000..643906c5aac
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/serialization/set.hpp
@@ -0,0 +1,137 @@
+#ifndef  BOOST_SERIALIZATION_SET_HPP
+#define BOOST_SERIALIZATION_SET_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// set.hpp: serialization for stl set templates
+
+// (C) Copyright 2002-2014 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+#include <set>
+
+#include <boost/config.hpp>
+
+#include <boost/archive/detail/basic_iarchive.hpp>
+#include <boost/serialization/access.hpp>
+#include <boost/serialization/nvp.hpp>
+#include <boost/serialization/detail/stack_constructor.hpp>
+#include <boost/serialization/collection_size_type.hpp>
+#include <boost/serialization/item_version_type.hpp>
+
+#include <boost/serialization/collections_save_imp.hpp>
+#include <boost/serialization/split_free.hpp>
+#include <boost/move/utility_core.hpp>
+
+namespace boost { 
+namespace serialization {
+
+template<class Archive, class Container>
+inline void load_set_collection(Archive & ar, Container &s)
+{
+    s.clear();
+    const boost::archive::library_version_type library_version(
+        ar.get_library_version()
+    );
+    // retrieve number of elements
+    item_version_type item_version(0);
+    collection_size_type count;
+    ar >> BOOST_SERIALIZATION_NVP(count);
+    if(boost::archive::library_version_type(3) < library_version){
+        ar >> BOOST_SERIALIZATION_NVP(item_version);
+    }
+    typename Container::iterator hint;
+    hint = s.begin();
+    while(count-- > 0){
+        typedef typename Container::value_type type;
+        detail::stack_construct<Archive, type> t(ar, item_version);
+        // borland fails silently w/o full namespace
+        ar >> boost::serialization::make_nvp("item", t.reference());
+        typename Container::iterator result =
+            s.insert(hint, boost::move(t.reference()));
+        ar.reset_object_address(& (* result), & t.reference());
+        hint = result;
+    }
+}
+
+template<class Archive, class Key, class Compare, class Allocator >
+inline void save(
+    Archive & ar,
+    const std::set<Key, Compare, Allocator> &t,
+    const unsigned int /* file_version */
+){
+    boost::serialization::stl::save_collection<
+        Archive, std::set<Key, Compare, Allocator> 
+    >(ar, t);
+}
+
+template<class Archive, class Key, class Compare, class Allocator >
+inline void load(
+    Archive & ar,
+    std::set<Key, Compare, Allocator> &t,
+    const unsigned int /* file_version */
+){
+    load_set_collection(ar, t);
+}
+
+// split non-intrusive serialization function member into separate
+// non intrusive save/load member functions
+template<class Archive, class Key, class Compare, class Allocator >
+inline void serialize(
+    Archive & ar,
+    std::set<Key, Compare, Allocator> & t,
+    const unsigned int file_version
+){
+    boost::serialization::split_free(ar, t, file_version);
+}
+
+// multiset
+template<class Archive, class Key, class Compare, class Allocator >
+inline void save(
+    Archive & ar,
+    const std::multiset<Key, Compare, Allocator> &t,
+    const unsigned int /* file_version */
+){
+    boost::serialization::stl::save_collection<
+        Archive, 
+        std::multiset<Key, Compare, Allocator> 
+    >(ar, t);
+}
+
+template<class Archive, class Key, class Compare, class Allocator >
+inline void load(
+    Archive & ar,
+    std::multiset<Key, Compare, Allocator> &t,
+    const unsigned int /* file_version */
+){
+    load_set_collection(ar, t);
+}
+
+// split non-intrusive serialization function member into separate
+// non intrusive save/load member functions
+template<class Archive, class Key, class Compare, class Allocator >
+inline void serialize(
+    Archive & ar,
+    std::multiset<Key, Compare, Allocator> & t,
+    const unsigned int file_version
+){
+    boost::serialization::split_free(ar, t, file_version);
+}
+
+} // namespace serialization
+} // namespace boost
+
+#include <boost/serialization/collection_traits.hpp>
+
+BOOST_SERIALIZATION_COLLECTION_TRAITS(std::set)
+BOOST_SERIALIZATION_COLLECTION_TRAITS(std::multiset)
+
+#endif // BOOST_SERIALIZATION_SET_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/shared_ptr.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/shared_ptr.hpp
new file mode 100644
index 00000000000..0d4c5ae6056
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/serialization/shared_ptr.hpp
@@ -0,0 +1,281 @@
+#ifndef BOOST_SERIALIZATION_SHARED_PTR_HPP
+#define BOOST_SERIALIZATION_SHARED_PTR_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// shared_ptr.hpp: serialization for boost shared pointer
+
+// (C) Copyright 2004 Robert Ramey and Martin Ecker
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+#include <cstddef> // NULL
+#include <memory>
+
+#include <boost/config.hpp>
+#include <boost/mpl/integral_c.hpp>
+#include <boost/mpl/integral_c_tag.hpp>
+
+#include <boost/detail/workaround.hpp>
+#include <boost/shared_ptr.hpp>
+
+#include <boost/serialization/shared_ptr_helper.hpp>
+#include <boost/serialization/split_free.hpp>
+#include <boost/serialization/nvp.hpp>
+#include <boost/serialization/version.hpp>
+#include <boost/serialization/tracking.hpp>
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// boost:: shared_ptr serialization traits
+// version 1 to distinguish from boost 1.32 version. Note: we can only do this
+// for a template when the compiler supports partial template specialization
+
+#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+    namespace boost {
+    namespace serialization{
+        template<class T>
+        struct version< ::boost::shared_ptr< T > > {
+            typedef mpl::integral_c_tag tag;
+            #if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3206))
+            typedef typename mpl::int_<1> type;
+            #else
+            typedef mpl::int_<1> type;
+            #endif
+            BOOST_STATIC_CONSTANT(int, value = type::value);
+        };
+        // don't track shared pointers
+        template<class T>
+        struct tracking_level< ::boost::shared_ptr< T > > { 
+            typedef mpl::integral_c_tag tag;
+            #if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3206))
+            typedef typename mpl::int_< ::boost::serialization::track_never> type;
+            #else
+            typedef mpl::int_< ::boost::serialization::track_never> type;
+            #endif
+            BOOST_STATIC_CONSTANT(int, value = type::value);
+        };
+    }}
+    #define BOOST_SERIALIZATION_SHARED_PTR(T)
+#else
+    // define macro to let users of these compilers do this
+    #define BOOST_SERIALIZATION_SHARED_PTR(T)                         \
+    BOOST_CLASS_VERSION(                                              \
+        ::boost::shared_ptr< T >,                                     \
+        1                                                             \
+    )                                                                 \
+    BOOST_CLASS_TRACKING(                                             \
+        ::boost::shared_ptr< T >,                                     \
+        ::boost::serialization::track_never                           \
+    )                                                                 \
+    /**/
+#endif
+
+namespace boost {
+namespace serialization{
+
+struct null_deleter {
+    void operator()(void const *) const {}
+};
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// serialization for boost::shared_ptr
+
+// Using a constant means that all shared pointers are held in the same set.
+// Thus we detect handle multiple pointers to the same value instances
+// in the archive.
+void * const shared_ptr_helper_id = 0;
+
+template<class Archive, class T>
+inline void save(
+    Archive & ar,
+    const boost::shared_ptr< T > &t,
+    const unsigned int /* file_version */
+){
+    // The most common cause of trapping here would be serializing
+    // something like shared_ptr<int>.  This occurs because int
+    // is never tracked by default.  Wrap int in a trackable type
+    BOOST_STATIC_ASSERT((tracking_level< T >::value != track_never));
+    const T * t_ptr = t.get();
+    ar << boost::serialization::make_nvp("px", t_ptr);
+}
+
+#ifdef BOOST_SERIALIZATION_SHARED_PTR_132_HPP
+template<class Archive, class T>
+inline void load(
+    Archive & ar,
+    boost::shared_ptr< T > &t,
+    const unsigned int file_version
+){
+    // something like shared_ptr<int>.  This occurs because int
+    // is never tracked by default.  Wrap int in a trackable type
+    BOOST_STATIC_ASSERT((tracking_level< T >::value != track_never));
+    T* r;
+    if(file_version < 1){
+        ar.register_type(static_cast<
+            boost_132::detail::sp_counted_base_impl<T *, null_deleter > *
+        >(NULL));
+        boost_132::shared_ptr< T > sp;
+        ar >> boost::serialization::make_nvp("px", sp.px);
+        ar >> boost::serialization::make_nvp("pn", sp.pn);
+        // got to keep the sps around so the sp.pns don't disappear
+        boost::serialization::shared_ptr_helper<boost::shared_ptr> & h =
+            ar.template get_helper< shared_ptr_helper<boost::shared_ptr> >(
+                shared_ptr_helper_id
+            );
+        h.append(sp);
+        r = sp.get();
+    }
+    else{
+        ar >> boost::serialization::make_nvp("px", r);
+    }
+    shared_ptr_helper<boost::shared_ptr> & h =
+        ar.template get_helper<shared_ptr_helper<boost::shared_ptr> >(
+            shared_ptr_helper_id
+        );
+    h.reset(t,r);
+}
+#else
+
+template<class Archive, class T>
+inline void load(
+    Archive & ar,
+    boost::shared_ptr< T > &t,
+    const unsigned int /*file_version*/
+){
+    // The most common cause of trapping here would be serializing
+    // something like shared_ptr<int>.  This occurs because int
+    // is never tracked by default.  Wrap int in a trackable type
+    BOOST_STATIC_ASSERT((tracking_level< T >::value != track_never));
+    T* r;
+    ar >> boost::serialization::make_nvp("px", r);
+
+    boost::serialization::shared_ptr_helper<boost::shared_ptr> & h =
+        ar.template get_helper<shared_ptr_helper<boost::shared_ptr> >(
+            shared_ptr_helper_id
+        );
+    h.reset(t,r);    
+}
+#endif
+
+template<class Archive, class T>
+inline void serialize(
+    Archive & ar,
+    boost::shared_ptr< T > &t,
+    const unsigned int file_version
+){
+    // correct shared_ptr serialization depends upon object tracking
+    // being used.
+    BOOST_STATIC_ASSERT(
+        boost::serialization::tracking_level< T >::value
+        != boost::serialization::track_never
+    );
+    boost::serialization::split_free(ar, t, file_version);
+}
+
+} // namespace serialization
+} // namespace boost
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// std::shared_ptr serialization traits
+// version 1 to distinguish from boost 1.32 version. Note: we can only do this
+// for a template when the compiler supports partial template specialization
+
+#ifndef BOOST_NO_CXX11_SMART_PTR
+#include <boost/static_assert.hpp>
+
+// note: we presume that any compiler/library which supports C++11
+// std::pointers also supports template partial specialization
+// trap here if such presumption were to turn out to wrong!!!
+#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+    BOOST_STATIC_ASSERT(false);
+#endif
+
+namespace boost {
+namespace serialization{
+    template<class T>
+    struct version< ::std::shared_ptr< T > > {
+        typedef mpl::integral_c_tag tag;
+        typedef mpl::int_<1> type;
+        BOOST_STATIC_CONSTANT(int, value = type::value);
+    };
+    // don't track shared pointers
+    template<class T>
+    struct tracking_level< ::std::shared_ptr< T > > { 
+        typedef mpl::integral_c_tag tag;
+        typedef mpl::int_< ::boost::serialization::track_never> type;
+        BOOST_STATIC_CONSTANT(int, value = type::value);
+    };
+}}
+// the following just keeps older programs from breaking
+#define BOOST_SERIALIZATION_SHARED_PTR(T)
+
+namespace boost {
+namespace serialization{
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// serialization for std::shared_ptr
+
+template<class Archive, class T>
+inline void save(
+    Archive & ar,
+    const std::shared_ptr< T > &t,
+    const unsigned int /* file_version */
+){
+    // The most common cause of trapping here would be serializing
+    // something like shared_ptr<int>.  This occurs because int
+    // is never tracked by default.  Wrap int in a trackable type
+    BOOST_STATIC_ASSERT((tracking_level< T >::value != track_never));
+    const T * t_ptr = t.get();
+    ar << boost::serialization::make_nvp("px", t_ptr);
+}
+
+template<class Archive, class T>
+inline void load(
+    Archive & ar,
+    std::shared_ptr< T > &t,
+    const unsigned int /*file_version*/
+){
+    // The most common cause of trapping here would be serializing
+    // something like shared_ptr<int>.  This occurs because int
+    // is never tracked by default.  Wrap int in a trackable type
+    BOOST_STATIC_ASSERT((tracking_level< T >::value != track_never));
+    T* r;
+    ar >> boost::serialization::make_nvp("px", r);
+    //void (* const id)(Archive &, std::shared_ptr< T > &, const unsigned int) = & load;
+    boost::serialization::shared_ptr_helper<std::shared_ptr> & h =
+        ar.template get_helper<
+            shared_ptr_helper<std::shared_ptr>
+        >(
+            shared_ptr_helper_id
+        );
+    h.reset(t,r);
+}
+
+template<class Archive, class T>
+inline void serialize(
+    Archive & ar,
+    std::shared_ptr< T > &t,
+    const unsigned int file_version
+){
+    // correct shared_ptr serialization depends upon object tracking
+    // being used.
+    BOOST_STATIC_ASSERT(
+        boost::serialization::tracking_level< T >::value
+        != boost::serialization::track_never
+    );
+    boost::serialization::split_free(ar, t, file_version);
+}
+
+} // namespace serialization
+} // namespace boost
+
+#endif // BOOST_NO_CXX11_SMART_PTR
+
+#endif // BOOST_SERIALIZATION_SHARED_PTR_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/shared_ptr_132.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/shared_ptr_132.hpp
new file mode 100644
index 00000000000..3dfaba4d69a
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/serialization/shared_ptr_132.hpp
@@ -0,0 +1,222 @@
+#ifndef BOOST_SERIALIZATION_SHARED_PTR_132_HPP
+#define BOOST_SERIALIZATION_SHARED_PTR_132_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// shared_ptr.hpp: serialization for boost shared pointer
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+// note: totally unadvised hack to gain access to private variables
+// in shared_ptr and shared_count. Unfortunately its the only way to
+// do this without changing shared_ptr and shared_count
+// the best we can do is to detect a conflict here
+#include <boost/config.hpp>
+
+#include <list>
+#include <cstddef> // NULL
+
+#include <boost/serialization/assume_abstract.hpp>
+#include <boost/serialization/split_free.hpp>
+#include <boost/serialization/nvp.hpp>
+#include <boost/serialization/tracking.hpp>
+#include <boost/serialization/void_cast.hpp>
+
+// mark base class as an (uncreatable) base class
+#include <boost/serialization/detail/shared_ptr_132.hpp>
+
+/////////////////////////////////////////////////////////////
+// Maintain a couple of lists of loaded shared pointers of the old previous
+// version (1.32)
+
+namespace boost_132 { 
+namespace serialization {
+namespace detail {
+
+struct null_deleter {
+    void operator()(void const *) const {}
+};
+
+} // namespace detail
+} // namespace serialization
+} // namespace boost_132
+
+/////////////////////////////////////////////////////////////
+// sp_counted_base_impl serialization
+
+namespace boost { 
+namespace serialization {
+
+template<class Archive, class P, class D>
+inline void serialize(
+    Archive & /* ar */,
+    boost_132::detail::sp_counted_base_impl<P, D> & /* t */,
+    const unsigned int /*file_version*/
+){
+    // register the relationship between each derived class
+    // its polymorphic base
+    boost::serialization::void_cast_register<
+        boost_132::detail::sp_counted_base_impl<P, D>,
+        boost_132::detail::sp_counted_base 
+    >(
+        static_cast<boost_132::detail::sp_counted_base_impl<P, D> *>(NULL),
+        static_cast<boost_132::detail::sp_counted_base *>(NULL)
+    );
+}
+
+template<class Archive, class P, class D>
+inline void save_construct_data(
+    Archive & ar,
+    const 
+    boost_132::detail::sp_counted_base_impl<P, D> *t, 
+    const unsigned int /* file_version */
+){
+    // variables used for construction
+    ar << boost::serialization::make_nvp("ptr", t->ptr);
+}
+
+template<class Archive, class P, class D>
+inline void load_construct_data(
+    Archive & ar,
+    boost_132::detail::sp_counted_base_impl<P, D> * t, 
+    const unsigned int /* file_version */
+){
+    P ptr_;
+    ar >> boost::serialization::make_nvp("ptr", ptr_);
+    // ::new(t)boost_132::detail::sp_counted_base_impl<P, D>(ptr_,  D()); 
+    // placement
+    // note: the original ::new... above is replaced by the one here.  This one
+    // creates all new objects with a null_deleter so that after the archive
+    // is finished loading and the shared_ptrs are destroyed - the underlying
+    // raw pointers are NOT deleted.  This is necessary as they are used by the 
+    // new system as well.
+    ::new(t)boost_132::detail::sp_counted_base_impl<
+        P, 
+        boost_132::serialization::detail::null_deleter
+    >(
+        ptr_,  boost_132::serialization::detail::null_deleter()
+    ); // placement new
+    // compensate for that fact that a new shared count always is 
+    // initialized with one. the add_ref_copy below will increment it
+    // every time its serialized so without this adjustment
+    // the use and weak counts will be off by one.
+    t->use_count_ = 0;
+}
+
+} // serialization
+} // namespace boost
+
+/////////////////////////////////////////////////////////////
+// shared_count serialization
+
+namespace boost { 
+namespace serialization {
+
+template<class Archive>
+inline void save(
+    Archive & ar,
+    const boost_132::detail::shared_count &t,
+    const unsigned int /* file_version */
+){
+    ar << boost::serialization::make_nvp("pi", t.pi_);
+}
+
+template<class Archive>
+inline void load(
+    Archive & ar,
+    boost_132::detail::shared_count &t,
+    const unsigned int /* file_version */
+){
+    ar >> boost::serialization::make_nvp("pi", t.pi_);
+    if(NULL != t.pi_)
+        t.pi_->add_ref_copy();
+}
+
+} // serialization
+} // namespace boost
+
+BOOST_SERIALIZATION_SPLIT_FREE(boost_132::detail::shared_count)
+
+/////////////////////////////////////////////////////////////
+// implement serialization for shared_ptr< T >
+
+namespace boost { 
+namespace serialization {
+
+template<class Archive, class T>
+inline void save(
+    Archive & ar,
+    const boost_132::shared_ptr< T > &t,
+    const unsigned int /* file_version */
+){
+    // only the raw pointer has to be saved
+    // the ref count is maintained automatically as shared pointers are loaded
+    ar.register_type(static_cast<
+        boost_132::detail::sp_counted_base_impl<T *, boost::checked_deleter< T > > *
+    >(NULL));
+    ar << boost::serialization::make_nvp("px", t.px);
+    ar << boost::serialization::make_nvp("pn", t.pn);
+}
+
+template<class Archive, class T>
+inline void load(
+    Archive & ar,
+    boost_132::shared_ptr< T > &t,
+    const unsigned int /* file_version */
+){
+    // only the raw pointer has to be saved
+    // the ref count is maintained automatically as shared pointers are loaded
+    ar.register_type(static_cast<
+        boost_132::detail::sp_counted_base_impl<T *, boost::checked_deleter< T > > *
+    >(NULL));
+    ar >> boost::serialization::make_nvp("px", t.px);
+    ar >> boost::serialization::make_nvp("pn", t.pn);
+}
+
+template<class Archive, class T>
+inline void serialize(
+    Archive & ar,
+    boost_132::shared_ptr< T > &t,
+    const unsigned int file_version
+){
+    // correct shared_ptr serialization depends upon object tracking
+    // being used.
+    BOOST_STATIC_ASSERT(
+        boost::serialization::tracking_level< T >::value
+        != boost::serialization::track_never
+    );
+    boost::serialization::split_free(ar, t, file_version);
+}
+
+} // serialization
+} // namespace boost
+
+// note: change below uses null_deleter 
+// This macro is used to export GUIDS for shared pointers to allow
+// the serialization system to export them properly. David Tonge
+#define BOOST_SHARED_POINTER_EXPORT_GUID(T, K)                     \
+    typedef boost_132::detail::sp_counted_base_impl<               \
+        T *,                                                       \
+        boost::checked_deleter< T >                                \
+    > __shared_ptr_ ## T;                                          \
+    BOOST_CLASS_EXPORT_GUID(__shared_ptr_ ## T, "__shared_ptr_" K) \
+    BOOST_CLASS_EXPORT_GUID(T, K)                                  \
+    /**/
+
+#define BOOST_SHARED_POINTER_EXPORT(T)                             \
+    BOOST_SHARED_POINTER_EXPORT_GUID(                              \
+        T,                                                         \
+        BOOST_PP_STRINGIZE(T)                                      \
+    )                                                              \
+    /**/
+
+#endif // BOOST_SERIALIZATION_SHARED_PTR_132_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/shared_ptr_helper.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/shared_ptr_helper.hpp
new file mode 100644
index 00000000000..37c34d6b2c4
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/serialization/shared_ptr_helper.hpp
@@ -0,0 +1,209 @@
+#ifndef BOOST_SERIALIZATION_SHARED_PTR_HELPER_HPP
+#define BOOST_SERIALIZATION_SHARED_PTR_HELPER_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// shared_ptr_helper.hpp: serialization for boost shared pointern
+
+// (C) Copyright 2004-2009 Robert Ramey, Martin Ecker and Takatoshi Kondo
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+#include <map>
+#include <list>
+#include <utility>
+#include <cstddef> // NULL
+
+#include <boost/config.hpp>
+#include <boost/shared_ptr.hpp>
+#include <boost/type_traits/is_polymorphic.hpp>
+#include <boost/mpl/if.hpp>
+
+#include <boost/serialization/singleton.hpp>
+#include <boost/serialization/extended_type_info.hpp>
+#include <boost/serialization/throw_exception.hpp>
+#include <boost/serialization/type_info_implementation.hpp>
+#include <boost/archive/archive_exception.hpp>
+
+namespace boost_132 {
+    template<class T> class shared_ptr;
+}
+namespace boost {
+namespace serialization {
+
+#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
+template<class Archive, template<class U> class SPT >
+void load(
+    Archive & ar,
+    SPT< class U > &t,
+    const unsigned int file_version
+);
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// a common class for holding various types of shared pointers
+
+template<template<class T> class SPT>
+class shared_ptr_helper {
+    typedef std::map<
+        const void *, // address of object
+        SPT<const void> // address shared ptr to single instance
+    > object_shared_pointer_map;
+
+    // list of shared_pointers create accessable by raw pointer. This
+    // is used to "match up" shared pointers loaded at different
+    // points in the archive. Note, we delay construction until
+    // it is actually used since this is by default included as
+    // a "mix-in" even if shared_ptr isn't used.
+    object_shared_pointer_map * m_o_sp;
+
+    struct null_deleter {
+        void operator()(void const *) const {}
+    };
+
+#if defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS) \
+|| defined(BOOST_MSVC) \
+|| defined(__SUNPRO_CC)
+public:
+#else
+    template<class Archive, class U>
+    friend void boost::serialization::load(
+        Archive & ar,
+        SPT< U > &t,
+        const unsigned int file_version
+    );
+#endif
+
+    #ifdef BOOST_SERIALIZATION_SHARED_PTR_132_HPP
+    // list of loaded pointers.  This is used to be sure that the pointers
+    // stay around long enough to be "matched" with other pointers loaded
+    // by the same archive.  These are created with a "null_deleter" so that
+    // when this list is destroyed - the underlaying raw pointers are not
+    // destroyed.  This has to be done because the pointers are also held by
+    // new system which is disjoint from this set.  This is implemented
+    // by a change in load_construct_data below.  It makes this file suitable
+    // only for loading pointers into a 1.33 or later boost system.
+    std::list<boost_132::shared_ptr<const void> > * m_pointers_132;
+    void
+    append(const boost_132::shared_ptr<const void> & t){
+        if(NULL == m_pointers_132)
+            m_pointers_132 = new std::list<boost_132::shared_ptr<const void> >;
+        m_pointers_132->push_back(t);
+    }
+    #endif
+
+    struct non_polymorphic {
+        template<class U>
+        static const boost::serialization::extended_type_info * 
+        get_object_type(U & ){
+            return & boost::serialization::singleton<
+                typename 
+                boost::serialization::type_info_implementation< U >::type
+            >::get_const_instance();
+        }
+    };
+    struct polymorphic {
+        template<class U>
+        static const boost::serialization::extended_type_info * 
+        get_object_type(U & u){
+            return boost::serialization::singleton<
+                typename 
+                boost::serialization::type_info_implementation< U >::type
+            >::get_const_instance().get_derived_extended_type_info(u);
+        }
+    };
+
+public:
+    template<class T>
+    void reset(SPT< T > & s, T * t){
+        if(NULL == t){
+            s.reset();
+            return;
+        }
+        const boost::serialization::extended_type_info * this_type
+            = & boost::serialization::type_info_implementation< T >::type
+                    ::get_const_instance();
+
+        // get pointer to the most derived object's eti.  This is effectively
+        // the object type identifer
+        typedef typename mpl::if_<
+            is_polymorphic< T >,
+            polymorphic,
+            non_polymorphic
+        >::type type;
+
+        const boost::serialization::extended_type_info * true_type
+            = type::get_object_type(*t);
+
+        // note:if this exception is thrown, be sure that derived pointern
+        // is either registered or exported.
+        if(NULL == true_type)
+            boost::serialization::throw_exception(
+                boost::archive::archive_exception(
+                    boost::archive::archive_exception::unregistered_class,
+                    this_type->get_debug_info()
+                )
+            );
+        // get void pointer to the most derived type
+        // this uniquely identifies the object referred to
+        // oid = "object identifier"
+        const void * oid = void_downcast(
+            *true_type,
+            *this_type,
+            t
+        );
+        if(NULL == oid)
+            boost::serialization::throw_exception(
+                boost::archive::archive_exception(
+                    boost::archive::archive_exception::unregistered_cast,
+                    true_type->get_debug_info(),
+                    this_type->get_debug_info()
+                )
+            );
+
+        // make tracking array if necessary
+        if(NULL == m_o_sp)
+            m_o_sp = new object_shared_pointer_map;
+
+        typename object_shared_pointer_map::iterator i = m_o_sp->find(oid);
+
+        // if it's a new object
+        if(i == m_o_sp->end()){
+            s.reset(t);
+            std::pair<typename object_shared_pointer_map::iterator, bool> result;
+            result = m_o_sp->insert(std::make_pair(oid, s));
+            BOOST_ASSERT(result.second);
+        }
+        // if the object has already been seen
+        else{
+            s = SPT<T>(i->second, t);
+        }
+    }
+
+    shared_ptr_helper() :
+        m_o_sp(NULL)
+        #ifdef BOOST_SERIALIZATION_SHARED_PTR_132_HPP
+            , m_pointers_132(NULL)
+        #endif
+    {}
+    virtual ~shared_ptr_helper(){
+        if(NULL != m_o_sp)
+            delete m_o_sp;
+        #ifdef BOOST_SERIALIZATION_SHARED_PTR_132_HPP
+        if(NULL != m_pointers_132)
+            delete m_pointers_132;
+        #endif
+    }
+};
+
+} // namespace serialization
+} // namespace boost
+
+#endif // BOOST_SERIALIZATION_SHARED_PTR_HELPER_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/singleton.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/singleton.hpp
new file mode 100644
index 00000000000..b50afedbb92
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/serialization/singleton.hpp
@@ -0,0 +1,166 @@
+#ifndef BOOST_SERIALIZATION_SINGLETON_HPP
+#define BOOST_SERIALIZATION_SINGLETON_HPP
+
+/////////1/////////2///////// 3/////////4/////////5/////////6/////////7/////////8
+//  singleton.hpp
+//
+// Copyright David Abrahams 2006. Original version
+//
+// Copyright Robert Ramey 2007.  Changes made to permit
+// application throughout the serialization library.
+//
+// Distributed under the Boost
+// Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// The intention here is to define a template which will convert
+// any class into a singleton with the following features:
+//
+// a) initialized before first use.
+// b) thread-safe for const access to the class
+// c) non-locking
+//
+// In order to do this,
+// a) Initialize dynamically when used.
+// b) Require that all singletons be initialized before main
+// is called or any entry point into the shared library is invoked.
+// This guarentees no race condition for initialization.
+// In debug mode, we assert that no non-const functions are called
+// after main is invoked.
+//
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif 
+
+#include <boost/assert.hpp>
+#include <boost/config.hpp>
+#include <boost/noncopyable.hpp>
+#include <boost/serialization/force_include.hpp>
+
+#include <boost/archive/detail/auto_link_archive.hpp>
+#include <boost/serialization/config.hpp>
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+#ifdef BOOST_MSVC
+#  pragma warning(push)
+#  pragma warning(disable : 4511 4512)
+#endif
+
+namespace boost { 
+namespace serialization { 
+
+//////////////////////////////////////////////////////////////////////
+// Provides a dynamically-initialized (singleton) instance of T in a
+// way that avoids LNK1179 on vc6.  See http://tinyurl.com/ljdp8 or
+// http://lists.boost.org/Archives/boost/2006/05/105286.php for
+// details.
+//
+
+// singletons created by this code are guarenteed to be unique
+// within the executable or shared library which creates them.
+// This is sufficient and in fact ideal for the serialization library.
+// The singleton is created when the module is loaded and destroyed
+// when the module is unloaded.
+
+// This base class has two functions.
+
+// First it provides a module handle for each singleton indicating
+// the executable or shared library in which it was created. This
+// turns out to be necessary and sufficient to implement the tables
+// used by serialization library.
+
+// Second, it provides a mechanism to detect when a non-const function
+// is called after initialization.
+
+// make a singleton to lock/unlock all singletons for alteration.
+// The intent is that all singletons created/used by this code
+// are to be initialized before main is called. A test program
+// can lock all the singletons when main is entereed.  This any
+// attempt to retieve a mutable instances while locked will
+// generate a assertion if compiled for debug.
+
+// note usage of BOOST_DLLEXPORT.  These functions are in danger of
+// being eliminated by the optimizer when building an application in
+// release mode. Usage of the macro is meant to signal the compiler/linker
+// to avoid dropping these functions which seem to be unreferenced.
+// This usage is not related to autolinking.
+
+class BOOST_SYMBOL_VISIBLE singleton_module :
+    public boost::noncopyable
+{
+private:
+    BOOST_SERIALIZATION_DECL BOOST_DLLEXPORT static bool & get_lock() BOOST_USED;
+public:
+    BOOST_DLLEXPORT static void lock(){
+        get_lock() = true;
+    }
+    BOOST_DLLEXPORT static void unlock(){
+        get_lock() = false;
+    }
+    BOOST_DLLEXPORT static bool is_locked(){
+        return get_lock();
+    }
+};
+
+template <class T>
+class singleton : public singleton_module
+{
+private:
+    static T & m_instance;
+    // include this to provoke instantiation at pre-execution time
+    static void use(T const *) {}
+    static T & get_instance() {
+        // use a wrapper so that types T with protected constructors
+        // can be used
+        class singleton_wrapper : public T {};
+        static singleton_wrapper t;
+        // refer to instance, causing it to be instantiated (and
+        // initialized at startup on working compilers)
+        BOOST_ASSERT(! is_destroyed());
+        // note that the following is absolutely essential.
+        // commenting out this statement will cause compilers to fail to
+        // construct the instance at pre-execution time.  This would prevent
+        // our usage/implementation of "locking" and introduce uncertainty into
+        // the sequence of object initializaition.
+        use(& m_instance);
+        return static_cast<T &>(t);
+    }
+    static bool & get_is_destroyed(){
+        static bool is_destroyed;
+        return is_destroyed;
+    }
+
+public:
+    BOOST_DLLEXPORT static T & get_mutable_instance(){
+        BOOST_ASSERT(! is_locked());
+        return get_instance();
+    }
+    BOOST_DLLEXPORT static const T & get_const_instance(){
+        return get_instance();
+    }
+    BOOST_DLLEXPORT static bool is_destroyed(){
+        return get_is_destroyed();
+    }
+    BOOST_DLLEXPORT singleton(){
+        get_is_destroyed() = false;
+    }
+    BOOST_DLLEXPORT ~singleton() {
+        get_is_destroyed() = true;
+    }
+};
+
+template<class T>
+T & singleton< T >::m_instance = singleton< T >::get_instance();
+
+} // namespace serialization
+} // namespace boost
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+#endif // BOOST_SERIALIZATION_SINGLETON_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/slist.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/slist.hpp
new file mode 100644
index 00000000000..d9b971bc4f1
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/serialization/slist.hpp
@@ -0,0 +1,145 @@
+#ifndef BOOST_SERIALIZATION_SLIST_HPP
+#define BOOST_SERIALIZATION_SLIST_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// slist.hpp
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+#include <boost/config.hpp>
+#ifdef BOOST_HAS_SLIST
+#include BOOST_SLIST_HEADER
+
+#include <boost/serialization/collections_save_imp.hpp>
+#include <boost/serialization/collections_load_imp.hpp>
+#include <boost/archive/detail/basic_iarchive.hpp>
+#include <boost/serialization/nvp.hpp>
+#include <boost/serialization/collection_size_type.hpp>
+#include <boost/serialization/item_version_type.hpp>
+#include <boost/serialization/split_free.hpp>
+#include <boost/serialization/detail/stack_constructor.hpp>
+#include <boost/serialization/detail/is_default_constructible.hpp>
+#include <boost/move/utility_core.hpp>
+
+namespace boost { 
+namespace serialization {
+
+template<class Archive, class U, class Allocator>
+inline void save(
+    Archive & ar,
+    const BOOST_STD_EXTENSION_NAMESPACE::slist<U, Allocator> &t,
+    const unsigned int file_version
+){
+    boost::serialization::stl::save_collection<
+        Archive,
+        BOOST_STD_EXTENSION_NAMESPACE::slist<U, Allocator> 
+    >(ar, t);
+}
+
+namespace stl {
+
+template<
+    class Archive,
+    class T,
+    class Allocator
+>
+typename boost::disable_if<
+    typename detail::is_default_constructible<
+        typename BOOST_STD_EXTENSION_NAMESPACE::slist<T, Allocator>::value_type
+    >,
+    void
+>::type
+collection_load_impl(
+    Archive & ar,
+    BOOST_STD_EXTENSION_NAMESPACE::slist<T, Allocator> &t,
+    collection_size_type count,
+    item_version_type item_version
+){
+    t.clear();
+    boost::serialization::detail::stack_construct<Archive, T> u(ar, item_version);
+    ar >> boost::serialization::make_nvp("item", u.reference());
+    t.push_front(boost::move(u.reference()));
+    typename BOOST_STD_EXTENSION_NAMESPACE::slist<T, Allocator>::iterator last;
+    last = t.begin();
+    ar.reset_object_address(&(*t.begin()) , & u.reference());
+    while(--count > 0){
+        detail::stack_construct<Archive, T> u(ar, item_version);
+        ar >> boost::serialization::make_nvp("item", u.reference());
+        last = t.insert_after(last, boost::move(u.reference()));
+        ar.reset_object_address(&(*last) , & u.reference());
+    }
+}
+
+} // stl
+
+template<class Archive, class U, class Allocator>
+inline void load(
+    Archive & ar,
+    BOOST_STD_EXTENSION_NAMESPACE::slist<U, Allocator> &t,
+    const unsigned int file_version
+){
+    const boost::archive::library_version_type library_version(
+        ar.get_library_version()
+    );
+    // retrieve number of elements
+    item_version_type item_version(0);
+    collection_size_type count;
+    ar >> BOOST_SERIALIZATION_NVP(count);
+    if(boost::archive::library_version_type(3) < library_version){
+        ar >> BOOST_SERIALIZATION_NVP(item_version);
+    }
+    if(detail::is_default_constructible<U>()){
+        t.resize(count);
+        typename BOOST_STD_EXTENSION_NAMESPACE::slist<U, Allocator>::iterator hint;
+        hint = t.begin();
+        while(count-- > 0){
+            ar >> boost::serialization::make_nvp("item", *hint++);
+        }
+    }
+    else{
+        t.clear();
+        boost::serialization::detail::stack_construct<Archive, U> u(ar, item_version);
+        ar >> boost::serialization::make_nvp("item", u.reference());
+        t.push_front(boost::move(u.reference()));
+        typename BOOST_STD_EXTENSION_NAMESPACE::slist<U, Allocator>::iterator last;
+        last = t.begin();
+        ar.reset_object_address(&(*t.begin()) , & u.reference());
+        while(--count > 0){
+            detail::stack_construct<Archive, U> u(ar, item_version);
+            ar >> boost::serialization::make_nvp("item", u.reference());
+            last = t.insert_after(last, boost::move(u.reference()));
+            ar.reset_object_address(&(*last) , & u.reference());
+        }
+    }
+}
+
+// split non-intrusive serialization function member into separate
+// non intrusive save/load member functions
+template<class Archive, class U, class Allocator>
+inline void serialize(
+    Archive & ar,
+    BOOST_STD_EXTENSION_NAMESPACE::slist<U, Allocator> &t,
+    const unsigned int file_version
+){
+    boost::serialization::split_free(ar, t, file_version);
+}
+
+} // serialization
+} // namespace boost
+
+#include <boost/serialization/collection_traits.hpp>
+
+BOOST_SERIALIZATION_COLLECTION_TRAITS(BOOST_STD_EXTENSION_NAMESPACE::slist)
+
+#endif  // BOOST_HAS_SLIST
+#endif  // BOOST_SERIALIZATION_SLIST_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/smart_cast.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/smart_cast.hpp
new file mode 100644
index 00000000000..563f36aa20b
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/serialization/smart_cast.hpp
@@ -0,0 +1,275 @@
+#ifndef BOOST_SERIALIZATION_SMART_CAST_HPP
+#define BOOST_SERIALIZATION_SMART_CAST_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// smart_cast.hpp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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/serialization for updates, documentation, and revision history.
+
+// casting of pointers and references.  
+
+// In casting between different C++ classes, there are a number of
+// rules that have to be kept in mind in deciding whether to use
+// static_cast or dynamic_cast.  
+
+// a) dynamic casting can only be applied when one of the types is polymorphic
+// Otherwise static_cast must be used.
+// b) only dynamic casting can do runtime error checking
+// use of static_cast is generally un checked even when compiled for debug
+// c) static_cast would be considered faster than dynamic_cast.
+
+// If casting is applied to a template parameter, there is no apriori way
+// to know which of the two casting methods will be permitted or convenient.
+
+// smart_cast uses C++ type_traits, and program debug mode to select the
+// most convenient cast to use.
+
+#include <exception>
+#include <typeinfo>
+#include <cstddef> // NULL
+
+#include <boost/config.hpp>
+#include <boost/static_assert.hpp>
+
+#include <boost/type_traits/is_base_and_derived.hpp>
+#include <boost/type_traits/is_polymorphic.hpp>
+#include <boost/type_traits/is_pointer.hpp>
+#include <boost/type_traits/is_reference.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/remove_pointer.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/mpl/or.hpp>
+#include <boost/mpl/and.hpp>
+#include <boost/mpl/not.hpp>
+#include <boost/mpl/identity.hpp>
+
+#include <boost/serialization/throw_exception.hpp>
+
+namespace boost {
+namespace serialization {
+namespace smart_cast_impl {
+
+    template<class T>
+    struct reference {
+
+        struct polymorphic {
+
+            struct linear {
+                template<class U>
+                 static T cast(U & u){
+                    return static_cast< T >(u);
+                }
+            };
+
+            struct cross {
+                 template<class U>
+                static T cast(U & u){
+                    return dynamic_cast< T >(u);
+                }
+            };
+
+            template<class U>
+            static T cast(U & u){
+                // if we're in debug mode
+                #if ! defined(NDEBUG)                               \
+                || defined(__MWERKS__)
+                    // do a checked dynamic cast
+                    return cross::cast(u);
+                #else
+                    // borland 5.51 chokes here so we can't use it
+                    // note: if remove_reference isn't function for these types
+                    // cross casting will be selected this will work but will
+                    // not be the most efficient method. This will conflict with
+                    // the original smart_cast motivation.
+                    typedef typename mpl::eval_if<
+                            typename mpl::and_<
+                                mpl::not_<is_base_and_derived<
+                                    typename remove_reference< T >::type,
+                                    U
+                                > >,
+                                mpl::not_<is_base_and_derived<
+                                    U,
+                                    typename remove_reference< T >::type
+                                > >
+                            >,
+                            // borland chokes w/o full qualification here
+                            mpl::identity<cross>,
+                            mpl::identity<linear>
+                    >::type typex;
+                    // typex works around gcc 2.95 issue
+                    return typex::cast(u);
+                #endif
+            }
+        };
+
+        struct non_polymorphic {
+            template<class U>
+             static T cast(U & u){
+                return static_cast< T >(u);
+            }
+        };
+        template<class U>
+        static T cast(U & u){
+            typedef typename mpl::eval_if<
+                boost::is_polymorphic<U>,
+                mpl::identity<polymorphic>,
+                mpl::identity<non_polymorphic>
+            >::type typex;
+            return typex::cast(u);
+        }
+    };
+
+    template<class T>
+    struct pointer {
+
+        struct polymorphic {
+            // unfortunately, this below fails to work for virtual base 
+            // classes.  need has_virtual_base to do this.
+            // Subject for further study
+            #if 0
+            struct linear {
+                template<class U>
+                 static T cast(U * u){
+                    return static_cast< T >(u);
+                }
+            };
+
+            struct cross {
+                template<class U>
+                static T cast(U * u){
+                    T tmp = dynamic_cast< T >(u);
+                    #ifndef NDEBUG
+                        if ( tmp == 0 ) throw_exception(std::bad_cast());
+                    #endif
+                    return tmp;
+                }
+            };
+
+            template<class U>
+            static T cast(U * u){
+                typedef
+                    typename mpl::eval_if<
+                        typename mpl::and_<
+                            mpl::not_<is_base_and_derived<
+                                typename remove_pointer< T >::type,
+                                U
+                            > >,
+                            mpl::not_<is_base_and_derived<
+                                U,
+                                typename remove_pointer< T >::type
+                            > >
+                        >,
+                        // borland chokes w/o full qualification here
+                        mpl::identity<cross>,
+                        mpl::identity<linear>
+                    >::type typex;
+                return typex::cast(u);
+            }
+            #else
+            template<class U>
+            static T cast(U * u){
+                T tmp = dynamic_cast< T >(u);
+                #ifndef NDEBUG
+                    if ( tmp == 0 ) throw_exception(std::bad_cast());
+                #endif
+                return tmp;
+            }
+            #endif
+        };
+
+        struct non_polymorphic {
+            template<class U>
+             static T cast(U * u){
+                return static_cast< T >(u);
+            }
+        };
+
+        template<class U>
+        static T cast(U * u){
+            typedef typename mpl::eval_if<
+                boost::is_polymorphic<U>,
+                mpl::identity<polymorphic>,
+                mpl::identity<non_polymorphic>
+            >::type typex;
+            return typex::cast(u);
+        }
+
+    };
+
+    template<class TPtr>
+    struct void_pointer {
+        template<class UPtr>
+        static TPtr cast(UPtr uptr){
+            return static_cast<TPtr>(uptr);
+        }
+    };
+
+    template<class T>
+    struct error {
+        // if we get here, its because we are using one argument in the
+        // cast on a system which doesn't support partial template 
+        // specialization
+        template<class U>
+        static T cast(U){
+            BOOST_STATIC_ASSERT(sizeof(T)==0);
+            return * static_cast<T *>(NULL);
+        }
+    };
+
+} // smart_cast_impl
+
+// this implements:
+// smart_cast<Target *, Source *>(Source * s)
+// smart_cast<Target &, Source &>(s)
+// note that it will fail with
+// smart_cast<Target &>(s)
+template<class T, class U>
+T smart_cast(U u) {
+    typedef
+        typename mpl::eval_if<
+            typename mpl::or_<
+                boost::is_same<void *, U>,
+                boost::is_same<void *, T>,
+                boost::is_same<const void *, U>,
+                boost::is_same<const void *, T>
+            >,
+            mpl::identity<smart_cast_impl::void_pointer< T > >,
+        // else
+        typename mpl::eval_if<boost::is_pointer<U>,
+            mpl::identity<smart_cast_impl::pointer< T > >,
+        // else
+        typename mpl::eval_if<boost::is_reference<U>,
+            mpl::identity<smart_cast_impl::reference< T > >,
+        // else
+            mpl::identity<smart_cast_impl::error< T >
+        >
+        >
+        >
+        >::type typex;
+    return typex::cast(u);
+}
+
+// this implements:
+// smart_cast_reference<Target &>(Source & s)
+template<class T, class U>
+T smart_cast_reference(U & u) {
+    return smart_cast_impl::reference< T >::cast(u);
+}
+
+} // namespace serialization
+} // namespace boost
+
+#endif // BOOST_SERIALIZATION_SMART_CAST_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/split_free.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/split_free.hpp
new file mode 100644
index 00000000000..85e2f590fe4
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/serialization/split_free.hpp
@@ -0,0 +1,93 @@
+#ifndef BOOST_SERIALIZATION_SPLIT_FREE_HPP
+#define BOOST_SERIALIZATION_SPLIT_FREE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// split_free.hpp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+#include <boost/config.hpp>
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/identity.hpp>
+#include <boost/serialization/serialization.hpp>
+
+namespace boost {
+namespace archive {
+    namespace detail {
+        template<class Archive> class interface_oarchive;
+        template<class Archive> class interface_iarchive;
+    } // namespace detail
+} // namespace archive
+
+namespace serialization {
+
+//namespace detail {
+template<class Archive, class T>
+struct free_saver {
+    static void invoke(
+        Archive & ar, 
+        const  T & t, 
+        const unsigned int file_version
+    ){
+        // use function overload (version_type) to workaround
+        // two-phase lookup issue
+        const version_type v(file_version);
+        save(ar, t, v);
+    }
+};
+template<class Archive, class T>
+struct free_loader {
+    static void invoke(
+        Archive & ar, 
+        T & t, 
+        const unsigned int file_version
+    ){
+        // use function overload (version_type) to workaround
+        // two-phase lookup issue
+        const version_type v(file_version);
+        load(ar, t, v);
+    }
+};
+//} // namespace detail
+
+template<class Archive, class T>
+inline void split_free(
+    Archive & ar, 
+    T & t, 
+    const unsigned int file_version
+){
+    typedef typename mpl::eval_if<
+        typename Archive::is_saving,
+        mpl::identity</* detail:: */ free_saver<Archive, T> >, 
+        mpl::identity</* detail:: */ free_loader<Archive, T> >
+    >::type typex;
+    typex::invoke(ar, t, file_version);
+}
+
+} // namespace serialization
+} // namespace boost
+
+#define BOOST_SERIALIZATION_SPLIT_FREE(T)       \
+namespace boost { namespace serialization {     \
+template<class Archive>                         \
+inline void serialize(                          \
+        Archive & ar,                               \
+        T & t,                                      \
+        const unsigned int file_version             \
+){                                              \
+        split_free(ar, t, file_version);            \
+}                                               \
+}}
+/**/
+
+#endif // BOOST_SERIALIZATION_SPLIT_FREE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/split_member.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/split_member.hpp
new file mode 100644
index 00000000000..5f32520559e
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/serialization/split_member.hpp
@@ -0,0 +1,86 @@
+#ifndef BOOST_SERIALIZATION_SPLIT_MEMBER_HPP
+#define BOOST_SERIALIZATION_SPLIT_MEMBER_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// split_member.hpp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+#include <boost/config.hpp>
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/identity.hpp>
+
+#include <boost/serialization/access.hpp>
+
+namespace boost {
+namespace archive {
+    namespace detail {
+        template<class Archive> class interface_oarchive;
+        template<class Archive> class interface_iarchive;
+    } // namespace detail
+} // namespace archive
+
+namespace serialization {
+namespace detail {
+
+    template<class Archive, class T>
+    struct member_saver {
+        static void invoke(
+            Archive & ar, 
+            const T & t,
+            const unsigned int file_version
+        ){
+            access::member_save(ar, t, file_version);
+        }
+    };
+
+    template<class Archive, class T>
+    struct member_loader {
+        static void invoke(
+            Archive & ar, 
+            T & t,
+            const unsigned int file_version
+        ){
+            access::member_load(ar, t, file_version);
+        }
+    };
+
+} // detail
+
+template<class Archive, class T>
+inline void split_member(
+    Archive & ar, T & t, const unsigned int file_version
+){
+    typedef typename mpl::eval_if<
+        typename Archive::is_saving,
+        mpl::identity<detail::member_saver<Archive, T> >, 
+        mpl::identity<detail::member_loader<Archive, T> >
+    >::type typex;
+    typex::invoke(ar, t, file_version);
+}
+
+} // namespace serialization
+} // namespace boost
+
+// split member function serialize funcition into save/load
+#define BOOST_SERIALIZATION_SPLIT_MEMBER()                       \
+template<class Archive>                                          \
+void serialize(                                                  \
+    Archive &ar,                                                 \
+    const unsigned int file_version                              \
+){                                                               \
+    boost::serialization::split_member(ar, *this, file_version); \
+}                                                                \
+/**/
+
+#endif // BOOST_SERIALIZATION_SPLIT_MEMBER_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/stack.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/stack.hpp
new file mode 100644
index 00000000000..96f90fe8767
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/serialization/stack.hpp
@@ -0,0 +1,76 @@
+#ifndef  BOOST_SERIALIZATION_STACK_HPP
+#define BOOST_SERIALIZATION_STACK_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// stack.hpp
+
+// (C) Copyright 2014 Robert Ramey - http://www.rrsd.com .
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+#include <stack>
+#include <boost/config.hpp>
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/identity.hpp>
+
+// function specializations must be defined in the appropriate
+// namespace - boost::serialization
+#if defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION)
+#define STD _STLP_STD
+#else
+#define STD std
+#endif
+
+namespace boost { 
+namespace serialization {
+namespace detail{
+
+template <typename U, typename C>
+struct stack_save : public STD::stack<U, C> {
+    template<class Archive>
+    void operator()(Archive & ar, const unsigned int file_version) const {
+        save(ar, STD::stack<U, C>::c, file_version);
+    }
+};
+template <typename U, typename C>
+struct stack_load : public STD::stack<U, C> {
+    template<class Archive>
+    void operator()(Archive & ar, const unsigned int file_version) {
+        load(ar, STD::stack<U, C>::c, file_version);
+    }
+};
+
+} // detail
+
+template<class Archive, class T, class C>
+inline void serialize(
+    Archive & ar,
+    std::stack< T, C> & t,
+    const unsigned int file_version 
+){
+    typedef typename mpl::eval_if<
+        typename Archive::is_saving,
+        mpl::identity<detail::stack_save<T, C> >,
+        mpl::identity<detail::stack_load<T, C> >
+    >::type typex;
+    static_cast<typex &>(t)(ar, file_version);
+}
+
+} // namespace serialization
+} // namespace boost
+
+#include <boost/serialization/collection_traits.hpp>
+
+BOOST_SERIALIZATION_COLLECTION_TRAITS(STD::stack)
+
+#undef STD
+
+#endif // BOOST_SERIALIZATION_DEQUE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/state_saver.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/state_saver.hpp
new file mode 100644
index 00000000000..248b8d91556
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/serialization/state_saver.hpp
@@ -0,0 +1,96 @@
+#ifndef BOOST_SERIALIZATION_STATE_SAVER_HPP
+#define BOOST_SERIALIZATION_STATE_SAVER_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// state_saver.hpp:
+
+// (C) Copyright 2003-4 Pavel Vozenilek and Robert Ramey - http://www.rrsd.com.
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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/serialization for updates, documentation, and revision history.
+
+// Inspired by Daryle Walker's iostate_saver concept.  This saves the original
+// value of a variable when a state_saver is constructed and restores
+// upon destruction.  Useful for being sure that state is restored to
+// variables upon exit from scope.
+
+
+#include <boost/config.hpp>
+#ifndef BOOST_NO_EXCEPTIONS
+    #include <exception>
+#endif
+
+#include <boost/call_traits.hpp>
+#include <boost/noncopyable.hpp>
+#include <boost/type_traits/has_nothrow_copy.hpp>
+#include <boost/core/no_exceptions_support.hpp>
+
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/identity.hpp>
+
+namespace boost {
+namespace serialization {
+
+template<class T>
+// T requirements:
+//  - POD or object semantic (cannot be reference, function, ...)
+//  - copy constructor
+//  - operator = (no-throw one preferred)
+class state_saver : private boost::noncopyable
+{
+private:
+    const T previous_value;
+    T & previous_ref;
+
+    struct restore {
+        static void invoke(T & previous_ref, const T & previous_value){
+            previous_ref = previous_value; // won't throw
+        }
+    };
+
+    struct restore_with_exception {
+        static void invoke(T & previous_ref, const T & previous_value){
+            BOOST_TRY{
+                previous_ref = previous_value;
+            } 
+            BOOST_CATCH(::std::exception &) { 
+                // we must ignore it - we are in destructor
+            }
+            BOOST_CATCH_END
+        }
+    };
+
+public:
+    state_saver(
+        T & object
+    ) : 
+        previous_value(object),
+        previous_ref(object) 
+    {}
+    
+    ~state_saver() {
+        #ifndef BOOST_NO_EXCEPTIONS
+            typedef typename mpl::eval_if<
+                has_nothrow_copy< T >,
+                mpl::identity<restore>,
+                mpl::identity<restore_with_exception>
+            >::type typex;
+            typex::invoke(previous_ref, previous_value);
+        #else
+            previous_ref = previous_value;
+        #endif
+    }
+
+}; // state_saver<>
+
+} // serialization
+} // boost
+
+#endif //BOOST_SERIALIZATION_STATE_SAVER_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/static_warning.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/static_warning.hpp
new file mode 100644
index 00000000000..1d9238fc4d9
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/serialization/static_warning.hpp
@@ -0,0 +1,103 @@
+#ifndef BOOST_SERIALIZATION_STATIC_WARNING_HPP
+#define BOOST_SERIALIZATION_STATIC_WARNING_HPP
+
+//  (C) Copyright Robert Ramey 2003. Jonathan Turkanis 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
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+// http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org/libs/static_assert for documentation.
+
+/*
+ Revision history:
+   15 June  2003 - Initial version.
+   31 March 2004 - improved diagnostic messages and portability 
+                   (Jonathan Turkanis)
+   03 April 2004 - works on VC6 at class and namespace scope
+                 - ported to DigitalMars
+                 - static warnings disabled by default; when enabled,
+                   uses pragmas to enable required compiler warnings
+                   on MSVC, Intel, Metrowerks and Borland 5.x.
+                   (Jonathan Turkanis)
+   30 May 2004   - tweaked for msvc 7.1 and gcc 3.3
+                 - static warnings ENabled by default; when enabled,
+                   (Robert Ramey)
+*/
+
+#include <boost/config.hpp>
+
+//
+// Implementation
+// Makes use of the following warnings:
+//  1. GCC prior to 3.3: division by zero.
+//  2. BCC 6.0 preview: unreferenced local variable.
+//  3. DigitalMars: returning address of local automatic variable.
+//  4. VC6: class previously seen as struct (as in 'boost/mpl/print.hpp')
+//  5. All others: deletion of pointer to incomplete type.
+//
+// The trick is to find code which produces warnings containing the name of
+// a structure or variable. Details, with same numbering as above:
+// 1. static_warning_impl<B>::value is zero iff B is false, so diving an int
+//    by this value generates a warning iff B is false.
+// 2. static_warning_impl<B>::type has a constructor iff B is true, so an
+//    unreferenced variable of this type generates a warning iff B is false.
+// 3. static_warning_impl<B>::type overloads operator& to return a dynamically
+//    allocated int pointer only is B is true, so  returning the address of an
+//    automatic variable of this type generates a warning iff B is fasle.
+// 4. static_warning_impl<B>::STATIC_WARNING is decalred as a struct iff B is 
+//    false. 
+// 5. static_warning_impl<B>::type is incomplete iff B is false, so deleting a
+//    pointer to this type generates a warning iff B is false.
+//
+
+//------------------Enable selected warnings----------------------------------//
+
+// Enable the warnings relied on by BOOST_STATIC_WARNING, where possible.
+
+// 6. replaced implementation with one which depends solely on
+//    mpl::print<>.  The previous one was found to fail for functions
+//    under recent versions of gcc and intel compilers - Robert Ramey
+
+#include <boost/mpl/bool.hpp>
+#include <boost/mpl/print.hpp>
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/bool_fwd.hpp>
+#include <boost/static_assert.hpp>
+
+namespace boost {
+namespace serialization {
+
+template<int L> 
+struct BOOST_SERIALIZATION_STATIC_WARNING_LINE{};
+
+template<bool B, int L>
+struct static_warning_test{
+    typename boost::mpl::eval_if_c<
+        B,
+        boost::mpl::true_,
+        typename boost::mpl::identity<
+            boost::mpl::print<
+                BOOST_SERIALIZATION_STATIC_WARNING_LINE<L>
+            >
+        >
+    >::type type;
+};
+
+template<int i>
+struct BOOST_SERIALIZATION_SS {};
+
+} // serialization
+} // boost
+
+#define BOOST_SERIALIZATION_BSW(B, L) \
+    typedef boost::serialization::BOOST_SERIALIZATION_SS< \
+        sizeof( boost::serialization::static_warning_test< B, L > ) \
+    > BOOST_JOIN(STATIC_WARNING_LINE, L) BOOST_ATTRIBUTE_UNUSED; 
+#define BOOST_STATIC_WARNING(B) BOOST_SERIALIZATION_BSW(B, __LINE__)
+
+#endif // BOOST_SERIALIZATION_STATIC_WARNING_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/string.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/string.hpp
new file mode 100644
index 00000000000..76e695d4f3c
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/serialization/string.hpp
@@ -0,0 +1,30 @@
+#ifndef  BOOST_SERIALIZATION_STRING_HPP
+#define BOOST_SERIALIZATION_STRING_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// serialization/string.hpp:
+// serialization for stl string templates
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+#include <string>
+
+#include <boost/config.hpp>
+#include <boost/serialization/level.hpp>
+
+BOOST_CLASS_IMPLEMENTATION(std::string, boost::serialization::primitive_type)
+#ifndef BOOST_NO_STD_WSTRING
+BOOST_CLASS_IMPLEMENTATION(std::wstring, boost::serialization::primitive_type)
+#endif
+
+#endif // BOOST_SERIALIZATION_STRING_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/strong_typedef.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/strong_typedef.hpp
new file mode 100644
index 00000000000..fdd1b24c9cb
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/serialization/strong_typedef.hpp
@@ -0,0 +1,50 @@
+#ifndef BOOST_SERIALIZATION_STRONG_TYPEDEF_HPP
+#define BOOST_SERIALIZATION_STRONG_TYPEDEF_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// strong_typedef.hpp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// (C) Copyright 2016 Ashish Sadanandan
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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/serialization for updates, documentation, and revision history.
+
+// macro used to implement a strong typedef.  strong typedef
+// guarentees that two types are distinguised even though the
+// share the same underlying implementation.  typedef does not create
+// a new type.  BOOST_STRONG_TYPEDEF(T, D) creates a new type named D
+// that operates as a type T.
+
+#include <boost/config.hpp>
+#include <boost/operators.hpp>
+#include <boost/type_traits/has_nothrow_assign.hpp>
+#include <boost/type_traits/has_nothrow_constructor.hpp>
+#include <boost/type_traits/has_nothrow_copy.hpp>
+
+#define BOOST_STRONG_TYPEDEF(T, D)                                                                               \
+struct D                                                                                                         \
+    : boost::totally_ordered1< D                                                                                 \
+    , boost::totally_ordered2< D, T                                                                              \
+    > >                                                                                                          \
+{                                                                                                                \
+    T t;                                                                                                         \
+    explicit D(const T& t_) BOOST_NOEXCEPT_IF(boost::has_nothrow_copy_constructor<T>::value) : t(t_) {}          \
+    D() BOOST_NOEXCEPT_IF(boost::has_nothrow_default_constructor<T>::value) : t() {}                             \
+    D(const D & t_) BOOST_NOEXCEPT_IF(boost::has_nothrow_copy_constructor<T>::value) : t(t_.t) {}                \
+    D& operator=(const D& rhs) BOOST_NOEXCEPT_IF(boost::has_nothrow_assign<T>::value) {t = rhs.t; return *this;} \
+    D& operator=(const T& rhs) BOOST_NOEXCEPT_IF(boost::has_nothrow_assign<T>::value) {t = rhs; return *this;}   \
+    operator const T&() const {return t;}                                                                        \
+    operator T&() {return t;}                                                                                    \
+    bool operator==(const D& rhs) const {return t == rhs.t;}                                                     \
+    bool operator<(const D& rhs) const {return t < rhs.t;}                                                       \
+};
+
+#endif // BOOST_SERIALIZATION_STRONG_TYPEDEF_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/throw_exception.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/throw_exception.hpp
new file mode 100644
index 00000000000..b67618adc92
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/serialization/throw_exception.hpp
@@ -0,0 +1,44 @@
+#ifndef BOOST_SERIALIZATION_THROW_EXCEPTION_HPP_INCLUDED
+#define BOOST_SERIALIZATION_THROW_EXCEPTION_HPP_INCLUDED
+
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+//  boost/throw_exception.hpp
+//
+//  Copyright (c) 2002 Peter Dimov and Multi Media Ltd.
+//
+// Distributed under the 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>
+
+#ifndef BOOST_NO_EXCEPTIONS
+#include <exception>
+#endif
+
+namespace boost {
+namespace serialization {
+
+#ifdef BOOST_NO_EXCEPTIONS
+
+inline void throw_exception(std::exception const & e) {
+    ::boost::throw_exception(e);
+}
+
+#else
+
+template<class E> inline void throw_exception(E const & e){
+    throw e;
+}
+
+#endif
+
+} // namespace serialization
+} // namespace boost
+
+#endif // #ifndef BOOST_SERIALIZATION_THROW_EXCEPTION_HPP_INCLUDED
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/tracking.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/tracking.hpp
new file mode 100644
index 00000000000..d5c79b8409d
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/serialization/tracking.hpp
@@ -0,0 +1,118 @@
+#ifndef BOOST_SERIALIZATION_TRACKING_HPP
+#define BOOST_SERIALIZATION_TRACKING_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// tracking.hpp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+#include <boost/config.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/identity.hpp>
+#include <boost/mpl/int.hpp>
+#include <boost/mpl/equal_to.hpp>
+#include <boost/mpl/greater.hpp>
+#include <boost/mpl/integral_c_tag.hpp>
+
+#include <boost/type_traits/is_base_and_derived.hpp>
+#include <boost/type_traits/is_pointer.hpp>
+#include <boost/serialization/level.hpp>
+#include <boost/serialization/tracking_enum.hpp>
+#include <boost/serialization/type_info_implementation.hpp>
+
+namespace boost {
+namespace serialization {
+
+struct basic_traits;
+
+// default tracking level
+template<class T>
+struct tracking_level_impl {
+    template<class U>
+    struct traits_class_tracking {
+        typedef typename U::tracking type;
+    };
+    typedef mpl::integral_c_tag tag;
+    // note: at least one compiler complained w/o the full qualification
+    // on basic traits below
+    typedef
+        typename mpl::eval_if<
+            is_base_and_derived<boost::serialization::basic_traits, T>,
+            traits_class_tracking< T >,
+        //else
+        typename mpl::eval_if<
+            is_pointer< T >,
+            // pointers are not tracked by default
+            mpl::int_<track_never>,
+        //else
+        typename mpl::eval_if<
+            // for primitives
+            typename mpl::equal_to<
+                implementation_level< T >,
+                mpl::int_<primitive_type> 
+            >,
+            // is never
+            mpl::int_<track_never>,
+            // otherwise its selective
+            mpl::int_<track_selectively>
+    >  > >::type type;
+    BOOST_STATIC_CONSTANT(int, value = type::value);
+};
+
+template<class T>
+struct tracking_level : 
+    public tracking_level_impl<const T>
+{
+};
+
+template<class T, enum tracking_type L>
+inline bool operator>=(tracking_level< T > t, enum tracking_type l)
+{
+    return t.value >= (int)l;
+}
+
+} // namespace serialization
+} // namespace boost
+
+
+// The STATIC_ASSERT is prevents one from setting tracking for a primitive type.  
+// This almost HAS to be an error.  Doing this will effect serialization of all 
+// char's in your program which is almost certainly what you don't want to do.  
+// If you want to track all instances of a given primitive type, You'll have to 
+// wrap it in your own type so its not a primitive anymore.  Then it will compile
+// without problem.
+#define BOOST_CLASS_TRACKING(T, E)           \
+namespace boost {                            \
+namespace serialization {                    \
+template<>                                   \
+struct tracking_level< T >                   \
+{                                            \
+    typedef mpl::integral_c_tag tag;         \
+    typedef mpl::int_< E> type;              \
+    BOOST_STATIC_CONSTANT(                   \
+        int,                                 \
+        value = tracking_level::type::value  \
+    );                                       \
+    /* tracking for a class  */              \
+    BOOST_STATIC_ASSERT((                    \
+        mpl::greater<                        \
+            /* that is a prmitive */         \
+            implementation_level< T >,       \
+            mpl::int_<primitive_type>        \
+        >::value                             \
+    ));                                      \
+};                                           \
+}}
+
+#endif // BOOST_SERIALIZATION_TRACKING_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/tracking_enum.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/tracking_enum.hpp
new file mode 100644
index 00000000000..278051e1baf
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/serialization/tracking_enum.hpp
@@ -0,0 +1,41 @@
+#ifndef BOOST_SERIALIZATION_TRACKING_ENUM_HPP
+#define BOOST_SERIALIZATION_TRACKING_ENUM_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// tracking_enum.hpp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+namespace boost {
+namespace serialization {
+
+// addresses of serialized objects may be tracked to avoid saving/loading
+// redundant copies.  This header defines a class trait that can be used
+// to specify when objects should be tracked
+
+// names for each tracking level
+enum tracking_type
+{
+    // never track this type
+    track_never = 0,
+    // track objects of this type if the object is serialized through a 
+    // pointer.
+    track_selectively = 1,
+    // always track this type
+    track_always = 2
+};
+
+} // namespace serialization
+} // namespace boost
+
+#endif // BOOST_SERIALIZATION_TRACKING_ENUM_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/traits.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/traits.hpp
new file mode 100644
index 00000000000..9e114fdd3df
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/serialization/traits.hpp
@@ -0,0 +1,65 @@
+#ifndef BOOST_SERIALIZATION_TRAITS_HPP
+#define BOOST_SERIALIZATION_TRAITS_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// traits.hpp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+// This header is used to apply serialization traits to templates.  The
+// standard system can't be used for platforms which don't support
+// Partial Templlate Specialization.  
+
+// The motivation for this is the Name-Value Pair (NVP) template.
+// it has to work the same on all platforms in order for archives
+// to be portable accross platforms.
+
+#include <boost/config.hpp>
+#include <boost/static_assert.hpp>
+
+#include <boost/mpl/int.hpp>
+#include <boost/mpl/bool_fwd.hpp>
+#include <boost/serialization/level_enum.hpp>
+#include <boost/serialization/tracking_enum.hpp>
+
+namespace boost {
+namespace serialization {
+
+// common base class used to detect appended traits class
+struct basic_traits {};
+
+template <class T>
+struct extended_type_info_impl;
+
+template<
+    class T, 
+    int Level, 
+    int Tracking,
+    unsigned int Version = 0,
+    class ETII = extended_type_info_impl< T >,
+    class Wrapper = mpl::false_
+>
+struct traits : public basic_traits {
+    BOOST_STATIC_ASSERT(Version == 0 || Level >= object_class_info);
+    BOOST_STATIC_ASSERT(Tracking == track_never || Level >= object_serializable);
+    typedef typename mpl::int_<Level> level;
+    typedef typename mpl::int_<Tracking> tracking;
+    typedef typename mpl::int_<Version> version;
+    typedef ETII type_info_implementation;
+    typedef Wrapper is_wrapper;
+};
+
+} // namespace serialization
+} // namespace boost
+
+#endif // BOOST_SERIALIZATION_TRAITS_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/type_info_implementation.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/type_info_implementation.hpp
new file mode 100644
index 00000000000..24637a8dbb3
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/serialization/type_info_implementation.hpp
@@ -0,0 +1,73 @@
+#ifndef BOOST_SERIALIZATION_TYPE_INFO_IMPLEMENTATION_HPP
+#define BOOST_SERIALIZATION_TYPE_INFO_IMPLEMENTATION_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// type_info_implementation.hpp: interface for portable version of type_info
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+
+#include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
+
+#include <boost/static_assert.hpp>
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/identity.hpp>
+#include <boost/type_traits/is_base_and_derived.hpp>
+#include <boost/serialization/traits.hpp>
+
+namespace boost {
+namespace serialization {
+
+// note that T and const T are folded into const T so that
+// there is only one table entry per type
+template<class T>
+struct type_info_implementation {
+    template<class U>
+    struct traits_class_typeinfo_implementation {
+      typedef typename U::type_info_implementation::type type;
+    };
+    // note: at least one compiler complained w/o the full qualification
+    // on basic traits below
+    typedef 
+        typename mpl::eval_if<
+            is_base_and_derived<boost::serialization::basic_traits, T>,
+            traits_class_typeinfo_implementation< T >,
+        //else
+            mpl::identity<
+                typename extended_type_info_impl< T >::type
+            >
+        >::type type;
+};
+
+} // namespace serialization
+} // namespace boost
+
+// define a macro to assign a particular derivation of extended_type_info
+// to a specified a class. 
+#define BOOST_CLASS_TYPE_INFO(T, ETI)              \
+namespace boost {                                  \
+namespace serialization {                          \
+template<>                                         \
+struct type_info_implementation< T > {             \
+    typedef ETI type;                              \
+};                                                 \
+template<>                                         \
+struct type_info_implementation< const T > {       \
+    typedef ETI type;                              \
+};                                                 \
+}                                                  \
+}                                                  \
+/**/
+
+#endif /// BOOST_SERIALIZATION_TYPE_INFO_IMPLEMENTATION_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/unique_ptr.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/unique_ptr.hpp
new file mode 100644
index 00000000000..8d8703ef4f7
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/serialization/unique_ptr.hpp
@@ -0,0 +1,68 @@
+#ifndef  BOOST_SERIALIZATION_UNIQUE_PTR_HPP
+#define BOOST_SERIALIZATION_UNIQUE_PTR_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// unique_ptr.hpp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+#include <memory>
+#include <boost/serialization/split_free.hpp>
+#include <boost/serialization/nvp.hpp>
+
+namespace boost {
+namespace serialization {
+
+/////////////////////////////////////////////////////////////
+// implement serialization for unique_ptr< T >
+// note: this must be added to the boost namespace in order to
+// be called by the library
+template<class Archive, class T>
+inline void save(
+    Archive & ar,
+    const std::unique_ptr< T > &t,
+    const unsigned int /*file_version*/
+){
+    // only the raw pointer has to be saved
+    // the ref count is rebuilt automatically on load
+    const T * const tx = t.get();
+    ar << BOOST_SERIALIZATION_NVP(tx);
+}
+
+template<class Archive, class T>
+inline void load(
+    Archive & ar,
+    std::unique_ptr< T > &t,
+    const unsigned int /*file_version*/
+){
+    T *tx;
+    ar >> BOOST_SERIALIZATION_NVP(tx);
+    // note that the reset automagically maintains the reference count
+    t.reset(tx);
+}
+
+// split non-intrusive serialization function member into separate
+// non intrusive save/load member functions
+template<class Archive, class T>
+inline void serialize(
+    Archive & ar,
+    std::unique_ptr< T > &t,
+    const unsigned int file_version
+){
+    boost::serialization::split_free(ar, t, file_version);
+}
+
+} // namespace serialization
+} // namespace boost
+
+
+#endif // BOOST_SERIALIZATION_UNIQUE_PTR_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/unordered_collections_load_imp.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/unordered_collections_load_imp.hpp
new file mode 100644
index 00000000000..d56a423d180
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/serialization/unordered_collections_load_imp.hpp
@@ -0,0 +1,73 @@
+#ifndef BOOST_SERIALIZATION_UNORDERED_COLLECTIONS_LOAD_IMP_HPP
+#define BOOST_SERIALIZATION_UNORDERED_COLLECTIONS_LOAD_IMP_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+# pragma warning (disable : 4786) // too long name, harmless warning
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// unordered_collections_load_imp.hpp: serialization for loading stl collections
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// (C) Copyright 2014 Jim Bell
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+// helper function templates for serialization of collections
+
+#include <boost/assert.hpp>
+#include <cstddef> // size_t
+#include <boost/config.hpp> // msvc 6.0 needs this for warning suppression
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{ 
+    using ::size_t; 
+} // namespace std
+#endif
+#include <boost/detail/workaround.hpp>
+
+#include <boost/archive/detail/basic_iarchive.hpp>
+#include <boost/serialization/access.hpp>
+#include <boost/serialization/nvp.hpp>
+#include <boost/serialization/collection_size_type.hpp>
+#include <boost/serialization/item_version_type.hpp>
+
+namespace boost{
+namespace serialization {
+namespace stl {
+
+//////////////////////////////////////////////////////////////////////
+// implementation of serialization for STL containers
+//
+template<class Archive, class Container, class InputFunction>
+inline void load_unordered_collection(Archive & ar, Container &s)
+{
+    collection_size_type count;
+    collection_size_type bucket_count;
+    boost::serialization::item_version_type item_version(0);
+    boost::archive::library_version_type library_version(
+        ar.get_library_version()
+    );
+    // retrieve number of elements
+    ar >> BOOST_SERIALIZATION_NVP(count);
+    ar >> BOOST_SERIALIZATION_NVP(bucket_count);
+    if(boost::archive::library_version_type(3) < library_version){
+        ar >> BOOST_SERIALIZATION_NVP(item_version);
+    }
+    s.clear();
+    s.rehash(bucket_count);
+    InputFunction ifunc;
+    while(count-- > 0){
+        ifunc(ar, s, item_version);
+    }
+}
+
+} // namespace stl 
+} // namespace serialization
+} // namespace boost
+
+#endif //BOOST_SERIALIZATION_UNORDERED_COLLECTIONS_LOAD_IMP_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/unordered_collections_save_imp.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/unordered_collections_save_imp.hpp
new file mode 100644
index 00000000000..56746ebeaa3
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/serialization/unordered_collections_save_imp.hpp
@@ -0,0 +1,86 @@
+#ifndef BOOST_SERIALIZATION_UNORDERED_COLLECTIONS_SAVE_IMP_HPP
+#define BOOST_SERIALIZATION_UNORDERED_COLLECTIONS_SAVE_IMP_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// hash_collections_save_imp.hpp: serialization for stl collections
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// (C) Copyright 2014 Jim Bell
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+// helper function templates for serialization of collections
+
+#include <boost/config.hpp>
+#include <boost/serialization/nvp.hpp>
+#include <boost/serialization/serialization.hpp>
+#include <boost/serialization/version.hpp>
+#include <boost/serialization/collection_size_type.hpp>
+#include <boost/serialization/item_version_type.hpp>
+
+namespace boost{
+namespace serialization {
+namespace stl {
+
+//////////////////////////////////////////////////////////////////////
+// implementation of serialization for STL containers
+//
+
+template<class Archive, class Container>
+inline void save_unordered_collection(Archive & ar, const Container &s)
+{
+    collection_size_type count(s.size());
+    const collection_size_type bucket_count(s.bucket_count());
+    const item_version_type item_version(
+        version<typename Container::value_type>::value
+    );
+
+    #if 0
+    /* should only be necessary to create archives of previous versions
+     * which is not currently supported.  So for now comment this out
+     */
+    boost::archive::library_version_type library_version(
+        ar.get_library_version()
+    );
+    // retrieve number of elements
+	ar << BOOST_SERIALIZATION_NVP(count);
+	ar << BOOST_SERIALIZATION_NVP(bucket_count);
+    if(boost::archive::library_version_type(3) < library_version){
+        // record number of elements
+        // make sure the target type is registered so we can retrieve
+        // the version when we load
+        ar << BOOST_SERIALIZATION_NVP(item_version);
+    }
+    #else
+        ar << BOOST_SERIALIZATION_NVP(count);
+        ar << BOOST_SERIALIZATION_NVP(bucket_count);
+        ar << BOOST_SERIALIZATION_NVP(item_version);
+    #endif
+
+    typename Container::const_iterator it = s.begin();
+    while(count-- > 0){
+        // note borland emits a no-op without the explicit namespace
+        boost::serialization::save_construct_data_adl(
+            ar, 
+            &(*it), 
+            boost::serialization::version<
+                typename Container::value_type
+            >::value
+        );
+        ar << boost::serialization::make_nvp("item", *it++);
+    }
+}
+
+} // namespace stl 
+} // namespace serialization
+} // namespace boost
+
+#endif //BOOST_SERIALIZATION_UNORDERED_COLLECTIONS_SAVE_IMP_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/unordered_map.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/unordered_map.hpp
new file mode 100644
index 00000000000..4fdbddd7b65
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/serialization/unordered_map.hpp
@@ -0,0 +1,160 @@
+#ifndef  BOOST_SERIALIZATION_UNORDERED_MAP_HPP
+#define BOOST_SERIALIZATION_UNORDERED_MAP_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// serialization/unordered_map.hpp:
+// serialization for stl unordered_map templates
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// (C) Copyright 2014 Jim Bell
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+#include <boost/config.hpp>
+
+#include <unordered_map>
+
+#include <boost/serialization/utility.hpp>
+#include <boost/serialization/unordered_collections_save_imp.hpp>
+#include <boost/serialization/unordered_collections_load_imp.hpp>
+#include <boost/serialization/archive_input_unordered_map.hpp>
+#include <boost/serialization/split_free.hpp>
+
+namespace boost { 
+namespace serialization {
+
+template<
+    class Archive, 
+    class Key, 
+    class HashFcn, 
+    class EqualKey,
+    class Allocator
+>
+inline void save(
+    Archive & ar,
+    const std::unordered_map<Key, HashFcn, EqualKey, Allocator> &t,
+    const unsigned int /*file_version*/
+){
+    boost::serialization::stl::save_unordered_collection<
+        Archive, 
+        std::unordered_map<Key, HashFcn, EqualKey, Allocator>
+    >(ar, t);
+}
+
+template<
+    class Archive, 
+    class Key, 
+    class HashFcn, 
+    class EqualKey,
+    class Allocator
+>
+inline void load(
+    Archive & ar,
+    std::unordered_map<Key, HashFcn, EqualKey, Allocator> &t,
+    const unsigned int /*file_version*/
+){
+    boost::serialization::stl::load_unordered_collection<
+        Archive,
+        std::unordered_map<Key, HashFcn, EqualKey, Allocator>,
+        boost::serialization::stl::archive_input_unordered_map<
+            Archive, 
+            std::unordered_map<Key, HashFcn, EqualKey, Allocator>
+        >
+    >(ar, t);
+}
+
+// split non-intrusive serialization function member into separate
+// non intrusive save/load member functions
+template<
+    class Archive, 
+    class Key, 
+    class HashFcn, 
+    class EqualKey,
+    class Allocator
+>
+inline void serialize(
+    Archive & ar,
+    std::unordered_map<Key, HashFcn, EqualKey, Allocator> &t,
+    const unsigned int file_version
+){
+    boost::serialization::split_free(ar, t, file_version);
+}
+
+// unordered_multimap
+template<
+    class Archive, 
+    class Key, 
+    class HashFcn, 
+    class EqualKey,
+    class Allocator
+>
+inline void save(
+    Archive & ar,
+    const std::unordered_multimap<
+        Key, HashFcn, EqualKey, Allocator
+    > &t,
+    const unsigned int /*file_version*/
+){
+    boost::serialization::stl::save_unordered_collection<
+        Archive, 
+        std::unordered_multimap<Key, HashFcn, EqualKey, Allocator>
+    >(ar, t);
+}
+
+template<
+    class Archive, 
+    class Key, 
+    class HashFcn, 
+    class EqualKey,
+    class Allocator
+>
+inline void load(
+    Archive & ar,
+    std::unordered_multimap<
+        Key, HashFcn, EqualKey, Allocator
+    > &t,
+    const unsigned int /*file_version*/
+){
+    boost::serialization::stl::load_unordered_collection<
+        Archive,
+        std::unordered_multimap<
+            Key, HashFcn, EqualKey, Allocator
+        >,
+        boost::serialization::stl::archive_input_unordered_multimap<
+            Archive, 
+            std::unordered_multimap<Key, HashFcn, EqualKey, Allocator>
+        >
+    >(ar, t);
+}
+
+// split non-intrusive serialization function member into separate
+// non intrusive save/load member functions
+template<
+    class Archive, 
+    class Key, 
+    class HashFcn, 
+    class EqualKey,
+    class Allocator
+>
+inline void serialize(
+    Archive & ar,
+    std::unordered_multimap<
+        Key, HashFcn, EqualKey, Allocator
+    > &t,
+    const unsigned int file_version
+){
+    boost::serialization::split_free(ar, t, file_version);
+}
+
+} // namespace serialization
+} // namespace boost
+
+#endif // BOOST_SERIALIZATION_UNORDERED_MAP_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/unordered_set.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/unordered_set.hpp
new file mode 100644
index 00000000000..adfee609cbe
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/serialization/unordered_set.hpp
@@ -0,0 +1,162 @@
+#ifndef  BOOST_SERIALIZATION_UNORDERED_SET_HPP
+#define BOOST_SERIALIZATION_UNORDERED_SET_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// unordered_set.hpp: serialization for stl unordered_set templates
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// (C) Copyright 2014 Jim Bell
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+#include <boost/config.hpp>
+
+#include <unordered_set>
+
+#include <boost/serialization/unordered_collections_save_imp.hpp>
+#include <boost/serialization/unordered_collections_load_imp.hpp>
+#include <boost/serialization/archive_input_unordered_set.hpp>
+#include <boost/serialization/split_free.hpp>
+
+namespace boost { 
+namespace serialization {
+
+template<
+    class Archive, 
+    class Key, 
+    class HashFcn, 
+    class EqualKey,
+    class Allocator
+>
+inline void save(
+    Archive & ar,
+    const std::unordered_set<
+        Key, HashFcn, EqualKey, Allocator
+    > &t,
+    const unsigned int /*file_version*/
+){
+    boost::serialization::stl::save_unordered_collection<
+        Archive, 
+        std::unordered_set<Key, HashFcn, EqualKey, Allocator>
+    >(ar, t);
+}
+
+template<
+    class Archive, 
+    class Key, 
+    class HashFcn, 
+    class EqualKey,
+    class Allocator
+>
+inline void load(
+    Archive & ar,
+    std::unordered_set<
+        Key, HashFcn, EqualKey, Allocator
+    > &t,
+    const unsigned int /*file_version*/
+){
+    boost::serialization::stl::load_unordered_collection<
+        Archive,
+        std::unordered_set<Key, HashFcn, EqualKey, Allocator>,
+        stl::archive_input_unordered_set<
+            Archive, 
+            std::unordered_set<
+                Key, HashFcn, EqualKey, Allocator
+            >
+        >
+    >(ar, t);
+}
+
+// split non-intrusive serialization function member into separate
+// non intrusive save/load member functions
+template<
+    class Archive, 
+    class Key, 
+    class HashFcn, 
+    class EqualKey,
+    class Allocator
+>
+inline void serialize(
+    Archive & ar,
+    std::unordered_set<
+        Key, HashFcn, EqualKey, Allocator
+    > &t,
+    const unsigned int file_version
+){
+    split_free(ar, t, file_version);
+}
+
+// unordered_multiset
+template<
+    class Archive, 
+    class Key, 
+    class HashFcn, 
+    class EqualKey,
+    class Allocator
+>
+inline void save(
+    Archive & ar,
+    const std::unordered_multiset<
+        Key, HashFcn, EqualKey, Allocator
+    > &t,
+    const unsigned int /*file_version*/
+){
+    stl::save_unordered_collection<
+        Archive, 
+        std::unordered_multiset<Key, HashFcn, EqualKey, Allocator>
+    >(ar, t);
+}
+
+template<
+    class Archive, 
+    class Key, 
+    class HashFcn, 
+    class EqualKey,
+    class Allocator
+>
+inline void load(
+    Archive & ar,
+    std::unordered_multiset<
+        Key, HashFcn, EqualKey, Allocator
+    > &t,
+    const unsigned int /*file_version*/
+){
+    boost::serialization::stl::load_unordered_collection<
+        Archive,
+        std::unordered_multiset<Key, HashFcn, EqualKey, Allocator>,
+        boost::serialization::stl::archive_input_unordered_multiset<
+            Archive,
+            std::unordered_multiset<Key, HashFcn, EqualKey, Allocator>
+        >
+    >(ar, t);
+}
+
+// split non-intrusive serialization function member into separate
+// non intrusive save/load member functions
+template<
+    class Archive, 
+    class Key, 
+    class HashFcn, 
+    class EqualKey,
+    class Allocator
+>
+inline void serialize(
+    Archive & ar,
+    std::unordered_multiset<Key, HashFcn, EqualKey, Allocator> &t,
+    const unsigned int file_version
+){
+    boost::serialization::split_free(ar, t, file_version);
+}
+
+} // namespace serialization
+} // namespace boost
+
+#endif // BOOST_SERIALIZATION_UNORDERED_SET_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/utility.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/utility.hpp
new file mode 100644
index 00000000000..4867a4a12d2
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/serialization/utility.hpp
@@ -0,0 +1,56 @@
+#ifndef  BOOST_SERIALIZATION_UTILITY_HPP
+#define BOOST_SERIALIZATION_UTILITY_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// serialization/utility.hpp:
+// serialization for stl utility templates
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+#include <utility>
+#include <boost/config.hpp>
+
+#include <boost/type_traits/remove_const.hpp>
+#include <boost/serialization/nvp.hpp>
+#include <boost/serialization/is_bitwise_serializable.hpp>
+#include <boost/mpl/and.hpp>
+
+namespace boost { 
+namespace serialization {
+
+// pair
+template<class Archive, class F, class S>
+inline void serialize(
+    Archive & ar,
+    std::pair<F, S> & p,
+    const unsigned int /* file_version */
+){
+    // note: we remove any const-ness on the first argument.  The reason is that 
+    // for stl maps, the type saved is pair<const key, T).  We remove
+    // the const-ness in order to be able to load it.
+    typedef typename boost::remove_const<F>::type typef;
+    ar & boost::serialization::make_nvp("first", const_cast<typef &>(p.first));
+    ar & boost::serialization::make_nvp("second", p.second);
+}
+
+/// specialization of is_bitwise_serializable for pairs
+template <class T, class U>
+struct is_bitwise_serializable<std::pair<T,U> >
+ : public mpl::and_<is_bitwise_serializable< T >,is_bitwise_serializable<U> >
+{
+};
+
+} // serialization
+} // namespace boost
+
+#endif // BOOST_SERIALIZATION_UTILITY_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/valarray.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/valarray.hpp
new file mode 100644
index 00000000000..9eece5c1737
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/serialization/valarray.hpp
@@ -0,0 +1,86 @@
+#ifndef BOOST_SERIALIZATION_VALARAY_HPP
+#define BOOST_SERIALIZATION_VALARAY_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// valarray.hpp: serialization for stl vector templates
+
+// (C) Copyright 2005 Matthias Troyer . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+#include <valarray>
+#include <boost/config.hpp>
+
+#include <boost/serialization/collections_save_imp.hpp>
+#include <boost/serialization/collections_load_imp.hpp>
+#include <boost/serialization/split_free.hpp>
+#include <boost/serialization/collection_size_type.hpp>
+#include <boost/serialization/array_wrapper.hpp>
+
+// function specializations must be defined in the appropriate
+// namespace - boost::serialization
+#if defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION)
+#define STD _STLP_STD
+#else
+#define STD std
+#endif
+
+namespace boost { 
+namespace serialization {
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// valarray< T >
+
+template<class Archive, class U>
+void save( Archive & ar, const STD::valarray<U> &t, const unsigned int /*file_version*/ )
+{
+    const collection_size_type count(t.size());
+    ar << BOOST_SERIALIZATION_NVP(count);
+    if (t.size()){
+        // explict template arguments to pass intel C++ compiler
+        ar << serialization::make_array<const U, collection_size_type>(
+            static_cast<const U *>(&t[0]),
+            count
+        );
+    }
+}
+
+template<class Archive, class U>
+void load( Archive & ar, STD::valarray<U> &t,  const unsigned int /*file_version*/ )
+{
+    collection_size_type count;
+    ar >> BOOST_SERIALIZATION_NVP(count);
+    t.resize(count);
+    if (t.size()){
+        // explict template arguments to pass intel C++ compiler
+        ar >> serialization::make_array<U, collection_size_type>(
+            static_cast<U *>(&t[0]),
+            count
+        );
+    }
+}
+
+// split non-intrusive serialization function member into separate
+// non intrusive save/load member functions
+template<class Archive, class U>
+inline void serialize( Archive & ar, STD::valarray<U> & t, const unsigned int file_version)
+{
+    boost::serialization::split_free(ar, t, file_version);
+}
+
+} } // end namespace boost::serialization
+
+#include <boost/serialization/collection_traits.hpp>
+
+BOOST_SERIALIZATION_COLLECTION_TRAITS(STD::valarray)
+#undef STD
+
+#endif // BOOST_SERIALIZATION_VALARAY_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/variant.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/variant.hpp
new file mode 100644
index 00000000000..dce6f3d49e7
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/serialization/variant.hpp
@@ -0,0 +1,158 @@
+#ifndef BOOST_SERIALIZATION_VARIANT_HPP
+#define BOOST_SERIALIZATION_VARIANT_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// variant.hpp - non-intrusive serialization of variant types
+//
+// copyright (c) 2005   
+// troy d. straszheim <troy@resophonic.com>
+// http://www.resophonic.com
+//
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+//
+// thanks to Robert Ramey, Peter Dimov, and Richard Crossley.
+//
+
+#include <boost/mpl/front.hpp>
+#include <boost/mpl/pop_front.hpp>
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/identity.hpp>
+#include <boost/mpl/size.hpp>
+#include <boost/mpl/empty.hpp>
+
+#include <boost/serialization/throw_exception.hpp>
+
+#include <boost/variant.hpp>
+
+#include <boost/archive/archive_exception.hpp>
+
+#include <boost/serialization/split_free.hpp>
+#include <boost/serialization/serialization.hpp>
+#include <boost/serialization/nvp.hpp>
+
+namespace boost {
+namespace serialization {
+
+template<class Archive>
+struct variant_save_visitor : 
+    boost::static_visitor<> 
+{
+    variant_save_visitor(Archive& ar) :
+        m_ar(ar)
+    {}
+    template<class T>
+    void operator()(T const & value) const
+    {
+        m_ar << BOOST_SERIALIZATION_NVP(value);
+    }
+private:
+    Archive & m_ar;
+};
+
+template<class Archive, BOOST_VARIANT_ENUM_PARAMS(/* typename */ class T)>
+void save(
+    Archive & ar,
+    boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> const & v,
+    unsigned int /*version*/
+){
+    int which = v.which();
+    ar << BOOST_SERIALIZATION_NVP(which);
+    variant_save_visitor<Archive> visitor(ar);
+    v.apply_visitor(visitor);
+}
+
+template<class S>
+struct variant_impl {
+
+    struct load_null {
+        template<class Archive, class V>
+        static void invoke(
+            Archive & /*ar*/,
+            int /*which*/,
+            V & /*v*/,
+            const unsigned int /*version*/
+        ){}
+    };
+
+    struct load_impl {
+        template<class Archive, class V>
+        static void invoke(
+            Archive & ar,
+            int which,
+            V & v,
+            const unsigned int version
+        ){
+            if(which == 0){
+                // note: A non-intrusive implementation (such as this one)
+                // necessary has to copy the value.  This wouldn't be necessary
+                // with an implementation that de-serialized to the address of the
+                // aligned storage included in the variant.
+                typedef typename mpl::front<S>::type head_type;
+                head_type value;
+                ar >> BOOST_SERIALIZATION_NVP(value);
+                v = value;
+                ar.reset_object_address(& boost::get<head_type>(v), & value);
+                return;
+            }
+            typedef typename mpl::pop_front<S>::type type;
+            variant_impl<type>::load(ar, which - 1, v, version);
+        }
+    };
+
+    template<class Archive, class V>
+    static void load(
+        Archive & ar,
+        int which,
+        V & v,
+        const unsigned int version
+    ){
+        typedef typename mpl::eval_if<mpl::empty<S>,
+            mpl::identity<load_null>,
+            mpl::identity<load_impl>
+        >::type typex;
+        typex::invoke(ar, which, v, version);
+    }
+
+};
+
+template<class Archive, BOOST_VARIANT_ENUM_PARAMS(/* typename */ class T)>
+void load(
+    Archive & ar, 
+    boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)>& v,
+    const unsigned int version
+){
+    int which;
+    typedef typename boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)>::types types;
+    ar >> BOOST_SERIALIZATION_NVP(which);
+    if(which >=  mpl::size<types>::value)
+        // this might happen if a type was removed from the list of variant types
+        boost::serialization::throw_exception(
+            boost::archive::archive_exception(
+                boost::archive::archive_exception::unsupported_version
+            )
+        );
+    variant_impl<types>::load(ar, which, v, version);
+}
+
+template<class Archive,BOOST_VARIANT_ENUM_PARAMS(/* typename */ class T)>
+inline void serialize(
+    Archive & ar,
+    boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> & v,
+    const unsigned int file_version
+){
+    split_free(ar,v,file_version);
+}
+
+} // namespace serialization
+} // namespace boost
+
+#endif //BOOST_SERIALIZATION_VARIANT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/vector.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/vector.hpp
new file mode 100644
index 00000000000..9a114c00e20
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/serialization/vector.hpp
@@ -0,0 +1,233 @@
+#ifndef  BOOST_SERIALIZATION_VECTOR_HPP
+#define BOOST_SERIALIZATION_VECTOR_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// vector.hpp: serialization for stl vector templates
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// fast array serialization (C) Copyright 2005 Matthias Troyer 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+#include <vector>
+
+#include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
+
+#include <boost/archive/detail/basic_iarchive.hpp>
+#include <boost/serialization/access.hpp>
+#include <boost/serialization/nvp.hpp>
+#include <boost/serialization/collection_size_type.hpp>
+#include <boost/serialization/item_version_type.hpp>
+
+#include <boost/serialization/collections_save_imp.hpp>
+#include <boost/serialization/collections_load_imp.hpp>
+#include <boost/serialization/split_free.hpp>
+#include <boost/serialization/array_wrapper.hpp>
+#include <boost/mpl/bool_fwd.hpp>
+#include <boost/mpl/if.hpp>
+
+// default is being compatible with version 1.34.1 files, not 1.35 files
+#ifndef BOOST_SERIALIZATION_VECTOR_VERSIONED
+#define BOOST_SERIALIZATION_VECTOR_VERSIONED(V) (V==4 || V==5)
+#endif
+
+// function specializations must be defined in the appropriate
+// namespace - boost::serialization
+#if defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION)
+#define STD _STLP_STD
+#else
+#define STD std
+#endif
+
+namespace boost { 
+namespace serialization {
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// vector< T >
+
+// the default versions
+
+template<class Archive, class U, class Allocator>
+inline void save(
+    Archive & ar,
+    const std::vector<U, Allocator> &t,
+    const unsigned int /* file_version */,
+    mpl::false_
+){
+    boost::serialization::stl::save_collection<Archive, STD::vector<U, Allocator> >(
+        ar, t
+    );
+}
+
+template<class Archive, class U, class Allocator>
+inline void load(
+    Archive & ar,
+    std::vector<U, Allocator> &t,
+    const unsigned int /* file_version */,
+    mpl::false_
+){
+    const boost::archive::library_version_type library_version(
+        ar.get_library_version()
+    );
+    // retrieve number of elements
+    item_version_type item_version(0);
+    collection_size_type count;
+    ar >> BOOST_SERIALIZATION_NVP(count);
+    if(boost::archive::library_version_type(3) < library_version){
+        ar >> BOOST_SERIALIZATION_NVP(item_version);
+    }
+    t.reserve(count);
+    stl::collection_load_impl(ar, t, count, item_version);
+}
+
+// the optimized versions
+
+template<class Archive, class U, class Allocator>
+inline void save(
+    Archive & ar,
+    const std::vector<U, Allocator> &t,
+    const unsigned int /* file_version */,
+    mpl::true_
+){
+    const collection_size_type count(t.size());
+    ar << BOOST_SERIALIZATION_NVP(count);
+    if (!t.empty())
+        // explict template arguments to pass intel C++ compiler
+        ar << serialization::make_array<const U, collection_size_type>(
+            static_cast<const U *>(&t[0]),
+            count
+        );
+}
+
+template<class Archive, class U, class Allocator>
+inline void load(
+    Archive & ar,
+    std::vector<U, Allocator> &t,
+    const unsigned int /* file_version */,
+    mpl::true_
+){
+    collection_size_type count(t.size());
+    ar >> BOOST_SERIALIZATION_NVP(count);
+    t.resize(count);
+    unsigned int item_version=0;
+    if(BOOST_SERIALIZATION_VECTOR_VERSIONED(ar.get_library_version())) {
+        ar >> BOOST_SERIALIZATION_NVP(item_version);
+    }
+    if (!t.empty())
+        // explict template arguments to pass intel C++ compiler
+        ar >> serialization::make_array<U, collection_size_type>(
+            static_cast<U *>(&t[0]),
+            count
+        );
+  }
+
+// dispatch to either default or optimized versions
+
+template<class Archive, class U, class Allocator>
+inline void save(
+    Archive & ar,
+    const std::vector<U, Allocator> &t,
+    const unsigned int file_version
+){
+    typedef typename 
+    boost::serialization::use_array_optimization<Archive>::template apply<
+        typename remove_const<U>::type 
+    >::type use_optimized;
+    save(ar,t,file_version, use_optimized());
+}
+
+template<class Archive, class U, class Allocator>
+inline void load(
+    Archive & ar,
+    std::vector<U, Allocator> &t,
+    const unsigned int file_version
+){
+#ifdef BOOST_SERIALIZATION_VECTOR_135_HPP
+    if (ar.get_library_version()==boost::archive::library_version_type(5))
+    {
+      load(ar,t,file_version, boost::is_arithmetic<U>());
+      return;
+    }
+#endif
+    typedef typename 
+    boost::serialization::use_array_optimization<Archive>::template apply<
+        typename remove_const<U>::type 
+    >::type use_optimized;
+    load(ar,t,file_version, use_optimized());
+}
+
+// split non-intrusive serialization function member into separate
+// non intrusive save/load member functions
+template<class Archive, class U, class Allocator>
+inline void serialize(
+    Archive & ar,
+    std::vector<U, Allocator> & t,
+    const unsigned int file_version
+){
+    boost::serialization::split_free(ar, t, file_version);
+}
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// vector<bool>
+template<class Archive, class Allocator>
+inline void save(
+    Archive & ar,
+    const std::vector<bool, Allocator> &t,
+    const unsigned int /* file_version */
+){
+    // record number of elements
+    collection_size_type count (t.size());
+    ar << BOOST_SERIALIZATION_NVP(count);
+    std::vector<bool>::const_iterator it = t.begin();
+    while(count-- > 0){
+        bool tb = *it++;
+        ar << boost::serialization::make_nvp("item", tb);
+    }
+}
+
+template<class Archive, class Allocator>
+inline void load(
+    Archive & ar,
+    std::vector<bool, Allocator> &t,
+    const unsigned int /* file_version */
+){
+    // retrieve number of elements
+    collection_size_type count;
+    ar >> BOOST_SERIALIZATION_NVP(count);
+    t.resize(count);
+    for(collection_size_type i = collection_size_type(0); i < count; ++i){
+        bool b;
+        ar >> boost::serialization::make_nvp("item", b);
+        t[i] = b;
+    }
+}
+
+// split non-intrusive serialization function member into separate
+// non intrusive save/load member functions
+template<class Archive, class Allocator>
+inline void serialize(
+    Archive & ar,
+    std::vector<bool, Allocator> & t,
+    const unsigned int file_version
+){
+    boost::serialization::split_free(ar, t, file_version);
+}
+
+} // serialization
+} // namespace boost
+
+#include <boost/serialization/collection_traits.hpp>
+
+BOOST_SERIALIZATION_COLLECTION_TRAITS(std::vector)
+#undef STD
+
+#endif // BOOST_SERIALIZATION_VECTOR_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/vector_135.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/vector_135.hpp
new file mode 100644
index 00000000000..fd1a7393d1b
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/serialization/vector_135.hpp
@@ -0,0 +1,26 @@
+////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// vector_135.hpp: serialization for stl vector templates for compatibility
+//                 with release 1.35, which had a bug
+
+// (C) Copyright 2008 Matthias Troyer
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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_SERIALIZATION_VECTOR_135_HPP
+#define BOOST_SERIALIZATION_VECTOR_135_HPP
+
+#ifdef BOOST_SERIALIZATION_VECTOR_VERSIONED
+#if BOOST_SERIALIZATION_VECTOR_VERSION != 4
+#error "Boost.Serialization cannot be compatible with both 1.35 and 1.36-1.40 files"
+#endif
+#else
+#define BOOST_SERIALIZATION_VECTOR_VERSIONED(V) (V>4)
+#endif
+
+#include <boost/serialization/vector.hpp>
+
+#endif // BOOST_SERIALIZATION_VECTOR_135_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/version.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/version.hpp
new file mode 100644
index 00000000000..21a74d73daa
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/serialization/version.hpp
@@ -0,0 +1,107 @@
+#ifndef BOOST_SERIALIZATION_VERSION_HPP
+#define BOOST_SERIALIZATION_VERSION_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// version.hpp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+#include <boost/config.hpp>
+#include <boost/mpl/assert.hpp>
+#include <boost/mpl/int.hpp>
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/identity.hpp>
+#include <boost/mpl/integral_c_tag.hpp>
+
+#include <boost/type_traits/is_base_and_derived.hpp>
+
+namespace boost { 
+namespace serialization {
+
+struct basic_traits;
+
+// default version number is 0. Override with higher version
+// when class definition changes.
+template<class T>
+struct version
+{
+    template<class U>
+    struct traits_class_version {
+        typedef typename U::version type;
+    };
+
+    typedef mpl::integral_c_tag tag;
+    // note: at least one compiler complained w/o the full qualification
+    // on basic traits below
+    typedef
+        typename mpl::eval_if<
+            is_base_and_derived<boost::serialization::basic_traits,T>,
+            traits_class_version< T >,
+            mpl::int_<0>
+        >::type type;
+    BOOST_STATIC_CONSTANT(int, value = version::type::value);
+};
+
+#ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
+template<class T>
+const int version<T>::value;
+#endif
+
+} // namespace serialization
+} // namespace boost
+
+/* note: at first it seemed that this would be a good place to trap
+ * as an error an attempt to set a version # for a class which doesn't
+ * save its class information (including version #) in the archive.
+ * However, this imposes a requirement that the version be set after
+ * the implemention level which would be pretty confusing.  If this
+ * is to be done, do this check in the input or output operators when
+ * ALL the serialization traits are available.  Included the implementation
+ * here with this comment as a reminder not to do this!
+ */
+//#include <boost/serialization/level.hpp>
+//#include <boost/mpl/equal_to.hpp>
+
+#include <boost/mpl/less.hpp>
+#include <boost/mpl/comparison.hpp>
+
+// specify the current version number for the class
+// version numbers limited to 8 bits !!!
+#define BOOST_CLASS_VERSION(T, N)                                      \
+namespace boost {                                                      \
+namespace serialization {                                              \
+template<>                                                             \
+struct version<T >                                                     \
+{                                                                      \
+    typedef mpl::int_<N> type;                                         \
+    typedef mpl::integral_c_tag tag;                                   \
+    BOOST_STATIC_CONSTANT(int, value = version::type::value);          \
+    BOOST_MPL_ASSERT((                                                 \
+        boost::mpl::less<                                              \
+            boost::mpl::int_<N>,                                       \
+            boost::mpl::int_<256>                                      \
+        >                                                              \
+    ));                                                                \
+    /*                                                                 \
+    BOOST_MPL_ASSERT((                                                 \
+        mpl::equal_to<                                                 \
+            :implementation_level<T >,                                 \
+            mpl::int_<object_class_info>                               \
+        >::value                                                       \
+    ));                                                                \
+    */                                                                 \
+};                                                                     \
+}                                                                      \
+}
+
+#endif // BOOST_SERIALIZATION_VERSION_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/void_cast.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/void_cast.hpp
new file mode 100644
index 00000000000..f1b38286115
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/serialization/void_cast.hpp
@@ -0,0 +1,298 @@
+#ifndef  BOOST_SERIALIZATION_VOID_CAST_HPP
+#define BOOST_SERIALIZATION_VOID_CAST_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// void_cast.hpp:   interface for run-time casting of void pointers.
+
+// (C) Copyright 2002-2009 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+// gennadiy.rozental@tfn.com
+
+//  See http://www.boost.org for updates, documentation, and revision history.
+
+#include <cstddef> // for ptrdiff_t
+#include <boost/config.hpp>
+#include <boost/noncopyable.hpp>
+
+#include <boost/serialization/smart_cast.hpp>
+#include <boost/serialization/singleton.hpp>
+#include <boost/serialization/force_include.hpp>
+#include <boost/serialization/type_info_implementation.hpp>
+#include <boost/serialization/extended_type_info.hpp>
+#include <boost/type_traits/is_virtual_base_of.hpp>
+#include <boost/serialization/void_cast_fwd.hpp>
+
+#include <boost/serialization/config.hpp>
+#include <boost/config/abi_prefix.hpp> // must be the last header
+
+#ifdef BOOST_MSVC
+#  pragma warning(push)
+#  pragma warning(disable : 4251 4231 4660 4275)
+#endif
+
+namespace boost { 
+namespace serialization { 
+
+class extended_type_info;
+
+// Given a void *, assume that it really points to an instance of one type
+// and alter it so that it would point to an instance of a related type.
+// Return the altered pointer. If there exists no sequence of casts that
+// can transform from_type to to_type, return a NULL.  
+
+BOOST_SERIALIZATION_DECL void const *
+void_upcast(
+    extended_type_info const & derived,  
+    extended_type_info const & base, 
+    void const * const t
+);
+
+inline void *
+void_upcast(
+    extended_type_info const & derived,
+    extended_type_info const & base,
+    void * const t 
+){
+    return const_cast<void*>(void_upcast(
+        derived, 
+        base, 
+        const_cast<void const *>(t)
+    ));
+}
+
+BOOST_SERIALIZATION_DECL void const *
+void_downcast(
+    extended_type_info const & derived,  
+    extended_type_info const & base, 
+    void const * const t
+);
+
+inline void *
+void_downcast(
+    extended_type_info const & derived,
+    extended_type_info const & base,
+    void * const t 
+){
+    return const_cast<void*>(void_downcast(
+        derived, 
+        base, 
+        const_cast<void const *>(t)
+    ));
+}
+
+namespace void_cast_detail {
+
+class BOOST_SYMBOL_VISIBLE void_caster :
+    private boost::noncopyable
+{
+    friend 
+    BOOST_SERIALIZATION_DECL void const *
+    boost::serialization::void_upcast(
+        extended_type_info const & derived,
+        extended_type_info const & base,
+        void const * const
+    );
+    friend 
+    BOOST_SERIALIZATION_DECL void const *
+    boost::serialization::void_downcast(
+        extended_type_info const & derived,
+        extended_type_info const & base,
+        void const * const
+    );
+protected:
+    BOOST_SERIALIZATION_DECL void recursive_register(bool includes_virtual_base = false) const;
+    BOOST_SERIALIZATION_DECL void recursive_unregister() const;
+    virtual bool has_virtual_base() const = 0;
+public:
+    // Data members
+    const extended_type_info * m_derived;
+    const extended_type_info * m_base;
+    /*const*/ std::ptrdiff_t m_difference;
+    void_caster const * const m_parent;
+
+    // note that void_casters are keyed on value of
+    // member extended type info records - NOT their
+    // addresses.  This is necessary in order for the
+    // void cast operations to work across dll and exe
+    // module boundries.
+    bool operator<(const void_caster & rhs) const;
+
+    const void_caster & operator*(){
+        return *this;
+    }
+    // each derived class must re-implement these;
+    virtual void const * upcast(void const * const t) const = 0;
+    virtual void const * downcast(void const * const t) const = 0;
+    // Constructor
+    void_caster(
+        extended_type_info const * derived,
+        extended_type_info const * base,
+        std::ptrdiff_t difference = 0,
+        void_caster const * const parent = 0
+    ) :
+        m_derived(derived),
+        m_base(base),
+        m_difference(difference),
+        m_parent(parent)
+    {}
+    virtual ~void_caster(){}
+};
+
+#ifdef BOOST_MSVC
+#  pragma warning(push)
+#  pragma warning(disable : 4251 4231 4660 4275 4511 4512)
+#endif
+
+template <class Derived, class Base>
+class BOOST_SYMBOL_VISIBLE void_caster_primitive :
+    public void_caster
+{
+    virtual void const * downcast(void const * const t) const {
+        const Derived * d = 
+            boost::serialization::smart_cast<const Derived *, const Base *>(
+                static_cast<const Base *>(t)
+            );
+        return d;
+    }
+    virtual void const * upcast(void const * const t) const {
+        const Base * b = 
+            boost::serialization::smart_cast<const Base *, const Derived *>(
+                static_cast<const Derived *>(t)
+            );
+        return b;
+    }
+    virtual bool has_virtual_base() const {
+        return false;
+    }
+public:
+    void_caster_primitive();
+    virtual ~void_caster_primitive();
+};
+
+template <class Derived, class Base>
+void_caster_primitive<Derived, Base>::void_caster_primitive() :
+    void_caster( 
+        & type_info_implementation<Derived>::type::get_const_instance(), 
+        & type_info_implementation<Base>::type::get_const_instance(),
+        // note:I wanted to displace from 0 here, but at least one compiler
+        // treated 0 by not shifting it at all.
+        reinterpret_cast<std::ptrdiff_t>(
+            static_cast<Derived *>(
+                reinterpret_cast<Base *>(8)
+            )
+        ) - 8
+    )
+{
+    recursive_register();
+}
+
+template <class Derived, class Base>
+void_caster_primitive<Derived, Base>::~void_caster_primitive(){
+    recursive_unregister();
+}
+
+template <class Derived, class Base>
+class BOOST_SYMBOL_VISIBLE void_caster_virtual_base :
+    public void_caster
+{
+    virtual bool has_virtual_base() const {
+        return true;
+    }
+public:
+    virtual void const * downcast(void const * const t) const {
+        const Derived * d = 
+            dynamic_cast<const Derived *>(
+                static_cast<const Base *>(t)
+            );
+        return d;
+    }
+    virtual void const * upcast(void const * const t) const {
+        const Base * b = 
+            dynamic_cast<const Base *>(
+                static_cast<const Derived *>(t)
+            );
+        return b;
+    }
+    void_caster_virtual_base();
+    virtual ~void_caster_virtual_base();
+};
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+template <class Derived, class Base>
+void_caster_virtual_base<Derived,Base>::void_caster_virtual_base() :
+    void_caster( 
+        & (type_info_implementation<Derived>::type::get_const_instance()), 
+        & (type_info_implementation<Base>::type::get_const_instance())
+    )
+{
+    recursive_register(true);
+}
+
+template <class Derived, class Base>
+void_caster_virtual_base<Derived,Base>::~void_caster_virtual_base(){
+    recursive_unregister();
+}
+
+template <class Derived, class Base>
+struct BOOST_SYMBOL_VISIBLE void_caster_base :
+    public void_caster
+{
+    typedef
+        typename mpl::eval_if<boost::is_virtual_base_of<Base,Derived>,
+            mpl::identity<
+                void_cast_detail::void_caster_virtual_base<Derived, Base>
+            >
+        ,// else
+            mpl::identity<
+                void_cast_detail::void_caster_primitive<Derived, Base>
+            >
+        >::type type;
+};
+
+} // void_cast_detail 
+
+template<class Derived, class Base>
+BOOST_DLLEXPORT 
+inline const void_cast_detail::void_caster & void_cast_register(
+    Derived const * /* dnull = NULL */, 
+    Base const * /* bnull = NULL */
+){
+    typedef
+        typename mpl::eval_if<boost::is_virtual_base_of<Base,Derived>,
+            mpl::identity<
+                void_cast_detail::void_caster_virtual_base<Derived, Base>
+            >
+        ,// else
+            mpl::identity<
+                void_cast_detail::void_caster_primitive<Derived, Base>
+            >
+        >::type typex;
+    return singleton<typex>::get_const_instance();
+}
+
+template<class Derived, class Base>
+class BOOST_SYMBOL_VISIBLE void_caster :
+    public void_cast_detail::void_caster_base<Derived, Base>::type
+{
+};
+
+} // namespace serialization
+} // namespace boost
+
+#ifdef BOOST_MSVC  
+#  pragma warning(pop)  
+#endif
+
+#include <boost/config/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#endif // BOOST_SERIALIZATION_VOID_CAST_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/void_cast_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/void_cast_fwd.hpp
new file mode 100644
index 00000000000..def61d52bb7
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/serialization/void_cast_fwd.hpp
@@ -0,0 +1,37 @@
+#ifndef  BOOST_SERIALIZATION_VOID_CAST_FWD_HPP
+#define BOOST_SERIALIZATION_VOID_CAST_FWD_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// void_cast_fwd.hpp:   interface for run-time casting of void pointers.
+
+// (C) Copyright 2005 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+// gennadiy.rozental@tfn.com
+
+//  See http://www.boost.org for updates, documentation, and revision history.
+
+#include <cstddef> // NULL
+#include <boost/serialization/force_include.hpp>
+
+namespace boost {
+namespace serialization {
+namespace void_cast_detail{
+class void_caster;
+} // namespace void_cast_detail
+template<class Derived, class Base>
+BOOST_DLLEXPORT 
+inline const void_cast_detail::void_caster & void_cast_register(
+    const Derived * dnull = NULL, 
+    const Base * bnull = NULL
+) BOOST_USED;
+} // namespace serialization
+} // namespace boost
+
+#endif // BOOST_SERIALIZATION_VOID_CAST_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/weak_ptr.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/weak_ptr.hpp
new file mode 100644
index 00000000000..6952d24cb37
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/serialization/weak_ptr.hpp
@@ -0,0 +1,99 @@
+#ifndef BOOST_SERIALIZATION_WEAK_PTR_HPP
+#define BOOST_SERIALIZATION_WEAK_PTR_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// weak_ptr.hpp: serialization for boost weak pointer
+
+// (C) Copyright 2004 Robert Ramey and Martin Ecker
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.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.
+
+#include <boost/weak_ptr.hpp>
+#include <boost/serialization/shared_ptr.hpp>
+
+namespace boost {
+namespace serialization{
+
+template<class Archive, class T>
+inline void save(
+    Archive & ar,
+    const boost::weak_ptr< T > &t,
+    const unsigned int /* file_version */
+){
+    const boost::shared_ptr< T > sp = t.lock();
+    ar << boost::serialization::make_nvp("weak_ptr", sp);
+}
+
+template<class Archive, class T>
+inline void load(
+    Archive & ar,
+    boost::weak_ptr< T > &t,
+    const unsigned int /* file_version */
+){
+    boost::shared_ptr< T > sp;
+    ar >> boost::serialization::make_nvp("weak_ptr", sp);
+    t = sp;
+}
+
+template<class Archive, class T>
+inline void serialize(
+    Archive & ar,
+    boost::weak_ptr< T > &t,
+    const unsigned int file_version
+){
+    boost::serialization::split_free(ar, t, file_version);
+}
+
+} // namespace serialization
+} // namespace boost
+
+#ifndef BOOST_NO_CXX11_SMART_PTR
+#include <memory>
+
+namespace boost {
+namespace serialization{
+
+template<class Archive, class T>
+inline void save(
+    Archive & ar,
+    const std::weak_ptr< T > &t,
+    const unsigned int /* file_version */
+){
+    const std::shared_ptr< T > sp = t.lock();
+    ar << boost::serialization::make_nvp("weak_ptr", sp);
+}
+
+template<class Archive, class T>
+inline void load(
+    Archive & ar,
+    std::weak_ptr< T > &t,
+    const unsigned int /* file_version */
+){
+    std::shared_ptr< T > sp;
+    ar >> boost::serialization::make_nvp("weak_ptr", sp);
+    t = sp;
+}
+
+template<class Archive, class T>
+inline void serialize(
+    Archive & ar,
+    std::weak_ptr< T > &t,
+    const unsigned int file_version
+){
+    boost::serialization::split_free(ar, t, file_version);
+}
+
+} // namespace serialization
+} // namespace boost
+
+#endif // BOOST_NO_CXX11_SMART_PTR
+
+#endif // BOOST_SERIALIZATION_WEAK_PTR_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/wrapper.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/wrapper.hpp
new file mode 100644
index 00000000000..60d7910b17a
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/serialization/wrapper.hpp
@@ -0,0 +1,60 @@
+#ifndef BOOST_SERIALIZATION_WRAPPER_HPP
+#define BOOST_SERIALIZATION_WRAPPER_HPP
+
+// (C) Copyright 2005-2006 Matthias Troyer
+// Use, modification and distribution is subject to the 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/serialization/traits.hpp>
+#include <boost/type_traits/is_base_and_derived.hpp>
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/bool_fwd.hpp>
+
+namespace boost { namespace serialization {
+
+/// the base class for serialization wrappers
+///
+/// wrappers need to be treated differently at various places in the serialization library,
+/// e.g. saving of non-const wrappers has to be possible. Since partial specialization
+// is not supported by all compilers, we derive all wrappers from wrapper_traits. 
+
+template<
+    class T, 
+    int Level = object_serializable, 
+    int Tracking = track_never,
+    unsigned int Version = 0,
+    class ETII = extended_type_info_impl< T >
+>
+struct wrapper_traits : 
+    public traits<T,Level,Tracking,Version,ETII,mpl::true_> 
+{};
+
+template<class T>
+struct is_wrapper_impl :
+    boost::mpl::eval_if<
+      boost::is_base_and_derived<basic_traits,T>,
+      boost::mpl::true_,
+      boost::mpl::false_
+    >::type
+{};
+
+template<class T>
+struct is_wrapper {
+    typedef typename is_wrapper_impl<const T>::type type;
+};
+
+} // serialization
+} // boost
+
+// A macro to define that a class is a wrapper
+#define BOOST_CLASS_IS_WRAPPER(T)                       \
+namespace boost {                                       \
+namespace serialization {                               \
+template<>                                              \
+struct is_wrapper_impl<const T> : boost::mpl::true_ {}; \
+}                                                       \
+}                                                       \
+/**/
+
+#endif //BOOST_SERIALIZATION_WRAPPER_HPP

From 1b248be8c9c7109e26205a26d594b1d79657c4b1 Mon Sep 17 00:00:00 2001
From: robot-metrika-test <robot-metrika-test@yandex-team.ru>
Date: Thu, 30 Nov 2017 20:25:34 +0300
Subject: [PATCH 017/107] Auto version update to [54318]

---
 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 be5d4cf6005..6751aebb320 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.54310-testing)
-set(VERSION_REVISION 54310)
+set(VERSION_DESCRIBE v1.1.54318-testing)
+set(VERSION_REVISION 54318)
 # end of autochange
 
 set (VERSION_MAJOR 1)
diff --git a/debian/changelog b/debian/changelog
index cff5905660c..3530f559dc3 100644
--- a/debian/changelog
+++ b/debian/changelog
@@ -1,5 +1,5 @@
-clickhouse (1.1.54310) unstable; urgency=low
+clickhouse (1.1.54318) unstable; urgency=low
 
   * Modified source code
 
- --  <robot-metrika-test@yandex-team.ru>  Wed, 01 Nov 2017 08:03:17 +0300
+ --  <robot-metrika-test@yandex-team.ru>  Thu, 30 Nov 2017 20:25:34 +0300

From 9dd07bcc23aab9a0e498631e80505da9336f7e5f Mon Sep 17 00:00:00 2001
From: Vitaliy Zakaznikov <vzakaznikov@protonmail.com>
Date: Sun, 26 May 2019 18:03:30 -0400
Subject: [PATCH 018/107] * Work in progress to redo live view implementation
 to be less invasive

---
 dbms/src/DataStreams/BlocksBlockInputStream.h |  51 +++
 .../DataStreams/LiveViewBlockInputStream.h    | 209 +++++++++
 .../Interpreters/InterpreterWatchQuery.cpp    | 102 +++++
 dbms/src/Interpreters/InterpreterWatchQuery.h |  50 +++
 dbms/src/Parsers/ASTWatchQuery.h              |  59 +++
 dbms/src/Parsers/ParserWatchQuery.cpp         |  77 ++++
 dbms/src/Parsers/ParserWatchQuery.h           |  30 ++
 dbms/src/Storages/LiveViewCommands.h          |  65 +++
 dbms/src/Storages/ProxyStorage.h              |  64 +++
 dbms/src/Storages/StorageLiveView.cpp         | 405 ++++++++++++++++++
 dbms/src/Storages/StorageLiveView.h           | 294 +++++++++++++
 11 files changed, 1406 insertions(+)
 create mode 100644 dbms/src/DataStreams/BlocksBlockInputStream.h
 create mode 100644 dbms/src/DataStreams/LiveViewBlockInputStream.h
 create mode 100644 dbms/src/Interpreters/InterpreterWatchQuery.cpp
 create mode 100644 dbms/src/Interpreters/InterpreterWatchQuery.h
 create mode 100644 dbms/src/Parsers/ASTWatchQuery.h
 create mode 100644 dbms/src/Parsers/ParserWatchQuery.cpp
 create mode 100644 dbms/src/Parsers/ParserWatchQuery.h
 create mode 100644 dbms/src/Storages/LiveViewCommands.h
 create mode 100644 dbms/src/Storages/ProxyStorage.h
 create mode 100644 dbms/src/Storages/StorageLiveView.cpp
 create mode 100644 dbms/src/Storages/StorageLiveView.h

diff --git a/dbms/src/DataStreams/BlocksBlockInputStream.h b/dbms/src/DataStreams/BlocksBlockInputStream.h
new file mode 100644
index 00000000000..ad0d37da622
--- /dev/null
+++ b/dbms/src/DataStreams/BlocksBlockInputStream.h
@@ -0,0 +1,51 @@
+/* Copyright (c) 2018 BlackBerry Limited
+
+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. */
+#pragma once
+
+#include <DataStreams/IBlockInputStream.h>
+
+
+namespace DB
+{
+
+/** A stream of blocks from a shared vector of blocks
+  */
+class BlocksBlockInputStream : public IBlockInputStream
+{
+public:
+    /// Acquires shared ownership of the blocks vector
+    BlocksBlockInputStream(std::shared_ptr<BlocksPtr> blocks_ptr_, Block header)
+        : blocks_ptr(blocks_ptr_), it((*blocks_ptr_)->begin()), end((*blocks_ptr_)->end()), header(header) {}
+
+    String getName() const override { return "Blocks"; }
+
+    Block getHeader() const override { return header; }
+
+protected:
+    Block readImpl() override
+    {
+        if (it == end)
+            return Block();
+
+        Block res = *it;
+        ++it;
+        return res;
+    }
+
+private:
+    std::shared_ptr<BlocksPtr> blocks_ptr;
+    Blocks::iterator it;
+    const Blocks::iterator end;
+    Block header;
+};
+
+}
diff --git a/dbms/src/DataStreams/LiveViewBlockInputStream.h b/dbms/src/DataStreams/LiveViewBlockInputStream.h
new file mode 100644
index 00000000000..3bb0a52efae
--- /dev/null
+++ b/dbms/src/DataStreams/LiveViewBlockInputStream.h
@@ -0,0 +1,209 @@
+/* Copyright (c) 2018 BlackBerry Limited
+
+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. */
+#pragma once
+
+#include <limits>
+
+#include <Common/ConcurrentBoundedQueue.h>
+#include <Poco/Condition.h>
+#include <DataStreams/OneBlockInputStream.h>
+#include <DataStreams/IBlockInputStream.h>
+#include <Storages/StorageLiveView.h>
+
+
+namespace DB
+{
+
+/**
+  */
+
+class LiveViewBlockInputStream : public IBlockInputStream
+{
+
+using NonBlockingResult = std::pair<Block, bool>;
+
+public:
+    ~LiveViewBlockInputStream() override
+    {
+        /// Start storage no users thread
+        /// if we are the last active user
+        if (!storage.is_dropped && blocks_ptr.use_count() < 3)
+            storage.startNoUsersThread();
+    }
+    /// length default -2 because we want LIMIT to specify number of updates so that LIMIT 1 waits for 1 update
+    /// and LIMIT 0 just returns data without waiting for any updates
+    LiveViewBlockInputStream(StorageLiveView & storage_, std::shared_ptr<BlocksPtr> blocks_ptr_, std::shared_ptr<bool> active_ptr_, Poco::Condition & condition_, Poco::FastMutex & mutex_,
+        int64_t length_, const UInt64 & heartbeat_delay_)
+        : storage(storage_), blocks_ptr(blocks_ptr_), active_ptr(active_ptr_), condition(condition_), mutex(mutex_), length(length_ + 1), heartbeat_delay(heartbeat_delay_), blocks_hash("")
+    {
+        /// grab active pointer
+        active = active_ptr.lock();
+    }
+
+    String getName() const override { return "LiveViewBlockInputStream"; }
+
+    void cancel(bool kill) override
+    {
+        if (isCancelled() || storage.is_dropped)
+            return;
+        IBlockInputStream::cancel(kill);
+        Poco::FastMutex::ScopedLock lock(mutex);
+        condition.broadcast();
+    }
+
+    Block getHeader() const override { return storage.getHeader(); }
+
+    void refresh()
+    {
+        if (active && blocks && it == end)
+            it =  blocks->begin();
+    }
+
+    void suspend()
+    {
+        active.reset();
+    }
+
+    void resume()
+    {
+        active = active_ptr.lock();
+        {
+            if (!blocks || blocks.get() != (*blocks_ptr).get())
+                blocks = (*blocks_ptr);
+        }
+        it = blocks->begin();
+        begin = blocks->begin();
+        end = blocks->end();
+    }
+
+    NonBlockingResult tryRead()
+    {
+        return tryRead_(false);
+    }
+
+protected:
+    Block readImpl() override
+    {
+        /// try reading
+        return tryRead_(true).first;
+    }
+
+    /** tryRead method attempts to read a block in either blocking
+     *  or non-blocking mode. If blocking is set to false
+     *  then method return empty block with flag set to false
+     *  to indicate that method would block to get the next block.
+     */
+    NonBlockingResult tryRead_(bool blocking)
+    {
+        Block res;
+
+        if (length == 0)
+        {
+            return { Block(), true };
+        }
+        /// If blocks were never assigned get blocks
+        if (!blocks)
+        {
+            Poco::FastMutex::ScopedLock lock(mutex);
+            if (!active)
+                return { Block(), false };
+            blocks = (*blocks_ptr);
+            it = blocks->begin();
+            begin = blocks->begin();
+            end = blocks->end();
+        }
+
+        if (isCancelled() || storage.is_dropped)
+        {
+            return { Block(), true };
+        }
+
+        if (it == end)
+        {
+            {
+                Poco::FastMutex::ScopedLock lock(mutex);
+                if (!active)
+                    return { Block(), false };
+                /// If we are done iterating over our blocks
+                /// and there are new blocks availble then get them
+                if (blocks.get() != (*blocks_ptr).get())
+                {
+                    blocks = (*blocks_ptr);
+                    it = blocks->begin();
+                    begin = blocks->begin();
+                    end = blocks->end();
+                }
+                /// No new blocks available wait for new ones
+                else
+                {
+                    if (!blocking)
+                    {
+                        return { Block(), false };
+                    }
+                    while (true)
+                    {
+                        bool signaled = condition.tryWait(mutex, std::max((UInt64)0, heartbeat_delay - ((UInt64)timestamp.epochMicroseconds() - last_event_timestamp)) / 1000);
+
+                        if (isCancelled() || storage.is_dropped)
+                        {
+                            return { Block(), true };
+                        }
+                        if (signaled)
+                        {
+                            break;
+                        }
+                        else
+                        {
+                            //hashmap["blocks"] = blocks_hash;
+                            last_event_timestamp = (UInt64)timestamp.epochMicroseconds();
+                            //heartbeat(Heartbeat(last_event_timestamp, std::move(hashmap)));
+                        }
+                    }
+                }
+            }
+            return tryRead_(blocking);
+        }
+
+        res = *it;
+
+        ++it;
+
+        if (it == end)
+        {
+            if (length > 0)
+                --length;
+        }
+
+        last_event_timestamp = (UInt64)timestamp.epochMicroseconds();
+        return { res, true };
+    }
+
+private:
+    StorageLiveView & storage;
+    std::shared_ptr<BlocksPtr> blocks_ptr;
+    std::weak_ptr<bool> active_ptr;
+    std::shared_ptr<bool> active;
+    BlocksPtr blocks;
+    Blocks::iterator it;
+    Blocks::iterator end;
+    Blocks::iterator begin;
+    Poco::Condition & condition;
+    Poco::FastMutex & mutex;
+    /// Length specifies number of updates to send, default -1 (no limit)
+    int64_t length;
+    UInt64 heartbeat_delay;
+    String blocks_hash;
+    UInt64 last_event_timestamp{0};
+    Poco::Timestamp timestamp;
+};
+
+}
diff --git a/dbms/src/Interpreters/InterpreterWatchQuery.cpp b/dbms/src/Interpreters/InterpreterWatchQuery.cpp
new file mode 100644
index 00000000000..4672a42a304
--- /dev/null
+++ b/dbms/src/Interpreters/InterpreterWatchQuery.cpp
@@ -0,0 +1,102 @@
+/* Copyright (c) 2018 BlackBerry Limited
+
+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. */
+#include <Core/Settings.h>
+#include <Common/typeid_cast.h>
+#include <Parsers/ASTWatchQuery.h>
+#include <Interpreters/InterpreterWatchQuery.h>
+#include <DataStreams/IBlockInputStream.h>
+#include <DataStreams/OneBlockInputStream.h>
+
+
+namespace DB
+{
+
+namespace ErrorCodes
+{
+    extern const int UNKNOWN_STORAGE;
+    extern const int TOO_MANY_COLUMNS;
+}
+
+BlockInputStreamPtr InterpreterWatchQuery::executeImpl()
+{
+    return std::make_shared<OneBlockInputStream>(Block());
+}
+
+BlockIO InterpreterWatchQuery::execute()
+{
+    BlockIO res;
+    const ASTWatchQuery & query = typeid_cast<const ASTWatchQuery &>(*query_ptr);
+    String database;
+    String table;
+    /// Get database
+    if (!query.database.empty())
+        database = query.database;
+    else
+        database = context.getCurrentDatabase();
+
+    /// Get table
+    table = query.table;
+
+    /// Get storage
+    storage = context.tryGetTable(database, table);
+
+    /// List of columns to read to execute the query.
+    Names required_columns = storage->getColumns().getNamesOfPhysical();
+
+    /// Get context settings for this query
+    const Settings & settings = context.getSettingsRef();
+
+    /// Limitation on the number of columns to read.
+    if (settings.max_columns_to_read && required_columns.size() > settings.max_columns_to_read)
+        throw Exception("Limit for number of columns to read exceeded. "
+            "Requested: " + std::to_string(required_columns.size())
+            + ", maximum: " + settings.max_columns_to_read.toString(),
+            ErrorCodes::TOO_MANY_COLUMNS);
+
+    size_t max_block_size = settings.max_block_size;
+    size_t max_streams = 1;
+
+    /// Define query info
+    SelectQueryInfo query_info;
+    query_info.query = query_ptr;
+
+    /// From stage
+    QueryProcessingStage::Enum from_stage = QueryProcessingStage::FetchColumns;
+    QueryProcessingStage::Enum to_stage = QueryProcessingStage::Complete;
+
+    /// Watch storage
+    streams = storage->watch(required_columns, query_info, context, from_stage, max_block_size, max_streams);
+
+    /// Constraints on the result, the quota on the result, and also callback for progress.
+    if (IBlockInputStream * stream = dynamic_cast<IBlockInputStream *>(streams[0].get()))
+    {
+        /// Constraints apply only to the final result.
+        if (to_stage == QueryProcessingStage::Complete)
+        {
+            IBlockInputStream::LocalLimits limits;
+            limits.mode = IBlockInputStream::LIMITS_CURRENT;
+            limits.size_limits.max_rows = settings.max_result_rows;
+            limits.size_limits.max_bytes = settings.max_result_bytes;
+            limits.size_limits.overflow_mode = settings.result_overflow_mode;
+
+            stream->setLimits(limits);
+            stream->setQuota(context.getQuota());
+        }
+    }
+
+    res.in = streams[0];
+
+    return res;
+}
+
+
+}
diff --git a/dbms/src/Interpreters/InterpreterWatchQuery.h b/dbms/src/Interpreters/InterpreterWatchQuery.h
new file mode 100644
index 00000000000..9315ee1f889
--- /dev/null
+++ b/dbms/src/Interpreters/InterpreterWatchQuery.h
@@ -0,0 +1,50 @@
+/* Copyright (c) 2018 BlackBerry Limited
+
+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. */
+#pragma once
+
+#include <Core/QueryProcessingStage.h>
+#include <DataStreams/BlockIO.h>
+#include <DataStreams/IBlockInputStream.h>
+#include <Parsers/IAST_fwd.h>
+#include <Interpreters/IInterpreter.h>
+#include <Storages/SelectQueryInfo.h>
+#include <Storages/IStorage.h>
+#include <Interpreters/Context.h>
+
+namespace DB
+{
+
+class IAST;
+using ASTPtr = std::shared_ptr<IAST>;
+using StoragePtr = std::shared_ptr<IStorage>;
+
+class InterpreterWatchQuery : public IInterpreter
+{
+public:
+    InterpreterWatchQuery(const ASTPtr & query_ptr_, Context & context_)
+        : query_ptr(query_ptr_), context(context_) {}
+
+    BlockIO execute() override;
+
+private:
+    ASTPtr query_ptr;
+    Context & context;
+
+    BlockInputStreamPtr executeImpl();
+    /// Table from where to read data, if not subquery.
+    StoragePtr storage;
+    /// Streams of read data
+    BlockInputStreams streams;
+};
+
+
+}
diff --git a/dbms/src/Parsers/ASTWatchQuery.h b/dbms/src/Parsers/ASTWatchQuery.h
new file mode 100644
index 00000000000..7e75d62a629
--- /dev/null
+++ b/dbms/src/Parsers/ASTWatchQuery.h
@@ -0,0 +1,59 @@
+/* Copyright (c) 2018 BlackBerry Limited
+
+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. */
+#pragma once
+
+#include <Parsers/ASTQueryWithTableAndOutput.h>
+
+
+namespace DB
+{
+
+class ASTWatchQuery : public ASTQueryWithTableAndOutput
+{
+
+public:
+    ASTPtr limit_length;
+    bool is_watch_events;
+
+    ASTWatchQuery() = default;
+    String getID(char) const override { return "WatchQuery_" + database + "_" + table; };
+
+    ASTPtr clone() const override
+    {
+        std::shared_ptr<ASTWatchQuery> res = std::make_shared<ASTWatchQuery>(*this);
+        res->children.clear();
+        cloneOutputOptions(*res);
+        return res;
+    }
+
+protected:
+    void formatQueryImpl(const FormatSettings & s, FormatState & state, FormatStateStacked frame) const override
+    {
+        std::string indent_str = s.one_line ? "" : std::string(4 * frame.indent, ' ');
+
+        s.ostr << (s.hilite ? hilite_keyword : "") << "WATCH" << " " << (s.hilite ? hilite_none : "")
+            << (!database.empty() ? backQuoteIfNeed(database) + "." : "") << backQuoteIfNeed(table);
+
+        if (is_watch_events)
+        {
+            s.ostr << " " << (s.hilite ? hilite_keyword : "") << "EVENTS" << (s.hilite ? hilite_none : "");
+        }
+
+        if (limit_length)
+        {
+            s.ostr << (s.hilite ? hilite_keyword : "") << s.nl_or_ws << indent_str << "LIMIT " << (s.hilite ? hilite_none : "");
+            limit_length->formatImpl(s, state, frame);
+        }
+    }
+};
+
+}
diff --git a/dbms/src/Parsers/ParserWatchQuery.cpp b/dbms/src/Parsers/ParserWatchQuery.cpp
new file mode 100644
index 00000000000..c29320c5a56
--- /dev/null
+++ b/dbms/src/Parsers/ParserWatchQuery.cpp
@@ -0,0 +1,77 @@
+/* Copyright (c) 2018 BlackBerry Limited
+
+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. */
+#include <Parsers/ASTLiteral.h>
+#include <Parsers/ASTIdentifier.h>
+#include <Parsers/ASTWatchQuery.h>
+#include <Parsers/CommonParsers.h>
+#include <Parsers/ParserWatchQuery.h>
+#include <Parsers/ExpressionElementParsers.h>
+
+
+namespace DB
+{
+
+bool ParserWatchQuery::parseImpl(Pos & pos, ASTPtr & node, Expected & expected)
+{
+    ParserKeyword s_watch("WATCH");
+    ParserToken s_dot(TokenType::Dot);
+    ParserIdentifier name_p;
+    ParserKeyword s_events("EVENTS");
+    ParserKeyword s_limit("LIMIT");
+
+    ASTPtr database;
+    ASTPtr table;
+    auto query = std::make_shared<ASTWatchQuery>();
+
+    if (!s_watch.ignore(pos, expected))
+    {
+        return false;
+    }
+
+    if (!name_p.parse(pos, table, expected))
+        return false;
+
+    if (s_dot.ignore(pos, expected))
+    {
+        database = table;
+        if (!name_p.parse(pos, table, expected))
+            return false;
+    }
+
+    /// EVENTS
+    if (s_events.ignore(pos, expected))
+    {
+        query->is_watch_events = true;
+    }
+
+    /// LIMIT length
+    if (s_limit.ignore(pos, expected))
+    {
+        ParserNumber num;
+
+        if (!num.parse(pos, query->limit_length, expected))
+            return false;
+    }
+
+    if (database)
+        getIdentifierName(database, query->database);
+
+    if (table)
+        getIdentifierName(table, query->table);
+
+    node = query;
+
+    return true;
+}
+
+
+}
diff --git a/dbms/src/Parsers/ParserWatchQuery.h b/dbms/src/Parsers/ParserWatchQuery.h
new file mode 100644
index 00000000000..330f0a432df
--- /dev/null
+++ b/dbms/src/Parsers/ParserWatchQuery.h
@@ -0,0 +1,30 @@
+/* Copyright (c) 2018 BlackBerry Limited
+
+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. */
+#pragma once
+
+#include <Parsers/IParserBase.h>
+
+
+namespace DB
+{
+
+/** Query like this:
+  * WATCH [db.]table EVENTS
+  */
+class ParserWatchQuery : public IParserBase
+{
+protected:
+    const char * getName() const { return "WATCH query"; }
+    bool parseImpl(Pos & pos, ASTPtr & node, Expected & expected);
+};
+
+}
diff --git a/dbms/src/Storages/LiveViewCommands.h b/dbms/src/Storages/LiveViewCommands.h
new file mode 100644
index 00000000000..35015a7e5aa
--- /dev/null
+++ b/dbms/src/Storages/LiveViewCommands.h
@@ -0,0 +1,65 @@
+/* Copyright (c) 2018 BlackBerry Limited
+
+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. */
+
+#pragma once
+
+#include <Parsers/ASTAlterQuery.h>
+#include <optional>
+#include <Storages/StorageLiveView.h>
+
+namespace DB
+{
+
+namespace ErrorCodes
+{
+    extern const int UNKNOWN_STORAGE;
+}
+
+struct LiveViewCommand
+{
+    enum Type
+    {
+        REFRESH
+    };
+
+    Type type;
+
+    ASTPtr values;
+
+    static LiveViewCommand refresh(const ASTPtr & values)
+    {
+        LiveViewCommand res;
+        res.type = REFRESH;
+        res.values = values;
+        return res;
+    }
+
+    static std::optional<LiveViewCommand> parse(ASTAlterCommand * command)
+    {
+        if (command->type == ASTAlterCommand::LIVE_VIEW_REFRESH)
+            return refresh(command->values);
+        return {};
+    }
+};
+
+
+class LiveViewCommands : public std::vector<LiveViewCommand>
+{
+public:
+    void validate(const IStorage & table)
+    {
+        if (!empty() && !dynamic_cast<const StorageLiveView *>(&table))
+            throw Exception("Wrong storage type. Must be StorageLiveView", DB::ErrorCodes::UNKNOWN_STORAGE);
+    }
+};
+
+}
diff --git a/dbms/src/Storages/ProxyStorage.h b/dbms/src/Storages/ProxyStorage.h
new file mode 100644
index 00000000000..a4196b7d6f2
--- /dev/null
+++ b/dbms/src/Storages/ProxyStorage.h
@@ -0,0 +1,64 @@
+#pragma once
+
+#include <Storages/IStorage.h>
+
+namespace DB
+{
+
+class ProxyStorage : public IStorage
+{
+public:
+    ProxyStorage(StoragePtr storage, BlockInputStreams streams, QueryProcessingStage::Enum to_stage)
+    : storage(std::move(storage)), streams(std::move(streams)), to_stage(to_stage) {}
+
+public:
+    std::string getName() const override { return "ProxyStorage(" + storage->getName() + ")"; }
+    std::string getTableName() const override { return storage->getTableName(); }
+
+    bool isRemote() const override { return storage->isRemote(); }
+    bool supportsSampling() const override { return storage->supportsSampling(); }
+    bool supportsFinal() const override { return storage->supportsFinal(); }
+    bool supportsPrewhere() const override { return storage->supportsPrewhere(); }
+    bool supportsReplication() const override { return storage->supportsReplication(); }
+    bool supportsDeduplication() const override { return storage->supportsDeduplication(); }
+
+    QueryProcessingStage::Enum getQueryProcessingStage(const Context & /*context*/) const override { return to_stage; }
+
+    BlockInputStreams read(
+            const Names & /*column_names*/,
+            const SelectQueryInfo & /*query_info*/,
+            const Context & /*context*/,
+            QueryProcessingStage::Enum /*processed_stage*/,
+            size_t /*max_block_size*/,
+            unsigned /*num_streams*/) override
+    {
+        return streams;
+    }
+
+    bool supportsIndexForIn() const override { return storage->supportsIndexForIn(); }
+    bool mayBenefitFromIndexForIn(const ASTPtr & left_in_operand, const Context & query_context) const override { return storage->mayBenefitFromIndexForIn(left_in_operand, query_context); }
+    ASTPtr getPartitionKeyAST() const override { return storage->getPartitionKeyAST(); }
+    ASTPtr getSortingKeyAST() const override { return storage->getSortingKeyAST(); }
+    ASTPtr getPrimaryKeyAST() const override { return storage->getPrimaryKeyAST(); }
+    ASTPtr getSamplingKeyAST() const override { return storage->getSamplingKeyAST(); }
+    Names getColumnsRequiredForPartitionKey() const override { return storage->getColumnsRequiredForPartitionKey(); }
+    Names getColumnsRequiredForSortingKey() const override { return storage->getColumnsRequiredForSortingKey(); }
+    Names getColumnsRequiredForPrimaryKey() const override { return storage->getColumnsRequiredForPrimaryKey(); }
+    Names getColumnsRequiredForSampling() const override { return storage->getColumnsRequiredForSampling(); }
+    Names getColumnsRequiredForFinal() const override { return storage->getColumnsRequiredForFinal(); }
+
+    NameAndTypePair getColumn(const String & column_name) const override { return storage->getColumn(column_name); }
+    bool hasColumn(const String & column_name) const override { return storage->hasColumn(column_name); }
+    static StoragePtr createProxyStorage(StoragePtr storage, BlockInputStreams streams, QueryProcessingStage::Enum to_stage)
+    {
+        return std::make_shared<ProxyStorage>(std::move(storage), std::move(streams), to_stage);
+    }
+private:
+    StoragePtr storage;
+    BlockInputStreams streams;
+    QueryProcessingStage::Enum to_stage;
+};
+
+
+
+}
diff --git a/dbms/src/Storages/StorageLiveView.cpp b/dbms/src/Storages/StorageLiveView.cpp
new file mode 100644
index 00000000000..5a4e225e52c
--- /dev/null
+++ b/dbms/src/Storages/StorageLiveView.cpp
@@ -0,0 +1,405 @@
+/* Copyright (c) 2018 BlackBerry Limited
+
+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. */
+#include <Parsers/ASTSelectQuery.h>
+#include <Parsers/ASTCreateQuery.h>
+#include <Parsers/ASTWatchQuery.h>
+#include <Parsers/ASTDropQuery.h>
+#include <Parsers/ASTIdentifier.h>
+#include <Parsers/ASTLiteral.h>
+#include <Interpreters/Context.h>
+#include <Interpreters/InterpreterDropQuery.h>
+#include <DataStreams/NullBlockInputStream.h>
+#include <DataStreams/LiveViewBlockInputStream.h>
+#include <DataStreams/MaterializingBlockInputStream.h>
+#include <Common/typeid_cast.h>
+
+#include <Storages/StorageLiveView.h>
+#include <Storages/StorageFactory.h>
+#include <Storages/ProxyStorage.h>
+#include <Parsers/ASTTablesInSelectQuery.h>
+#include <Parsers/ASTSubquery.h>
+#include <Interpreters/DatabaseAndTableWithAlias.h>
+#include <Interpreters/AddDefaultDatabaseVisitor.h>
+
+namespace DB
+{
+
+namespace ErrorCodes
+{
+    extern const int LOGICAL_ERROR;
+    extern const int INCORRECT_QUERY;
+    extern const int TABLE_WAS_NOT_DROPPED;
+    extern const int QUERY_IS_NOT_SUPPORTED_IN_LIVE_VIEW;
+}
+
+static void extractDependentTable(ASTSelectQuery & query, String & select_database_name, String & select_table_name)
+{
+    auto db_and_table = getDatabaseAndTable(query, 0);
+    ASTPtr subquery = extractTableExpression(query, 0);
+
+    if (!db_and_table && !subquery)
+        return;
+
+    if (db_and_table)
+    {
+        select_table_name = db_and_table->table;
+
+        if (db_and_table->database.empty())
+        {
+            db_and_table->database = select_database_name;
+            AddDefaultDatabaseVisitor visitor(select_database_name);
+            visitor.visit(query);
+        }
+        else
+            select_database_name = db_and_table->database;
+    }
+    else if (auto * ast_select = subquery->as<ASTSelectWithUnionQuery>())
+    {
+        if (ast_select->list_of_selects->children.size() != 1)
+            throw Exception("UNION is not supported for LIVE VIEW", ErrorCodes::QUERY_IS_NOT_SUPPORTED_IN_LIVE_VIEW);
+
+        auto & inner_query = ast_select->list_of_selects->children.at(0);
+
+        extractDependentTable(inner_query->as<ASTSelectQuery &>(), select_database_name, select_table_name);
+    }
+    else
+        throw Exception("Logical error while creating StorageLiveView."
+            " Could not retrieve table name from select query.",
+            DB::ErrorCodes::LOGICAL_ERROR);
+}
+
+static void checkAllowedQueries(const ASTSelectQuery & query)
+{
+    if (query.prewhere() || query.final() || query.sample_size())
+        throw Exception("LIVE VIEW cannot have PREWHERE, SAMPLE or FINAL.", DB::ErrorCodes::QUERY_IS_NOT_SUPPORTED_IN_LIVE_VIEW);
+
+    ASTPtr subquery = extractTableExpression(query, 0);
+    if (!subquery)
+        return;
+
+    if (const auto * ast_select = subquery->as<ASTSelectWithUnionQuery>())
+    {
+        if (ast_select->list_of_selects->children.size() != 1)
+            throw Exception("UNION is not supported for LIVE VIEW", ErrorCodes::QUERY_IS_NOT_SUPPORTED_IN_LIVE_VIEW);
+
+        const auto & inner_query = ast_select->list_of_selects->children.at(0);
+
+        checkAllowedQueries(inner_query->as<ASTSelectQuery &>());
+    }
+}
+
+StorageLiveView::StorageLiveView(
+    const String & table_name_,
+    const String & database_name_,
+    Context & local_context,
+    const ASTCreateQuery & query,
+    const ColumnsDescription & columns)
+    : IStorage(columns), table_name(table_name_),
+    database_name(database_name_), global_context(local_context.getGlobalContext())
+{
+    if (!query.select)
+        throw Exception("SELECT query is not specified for " + getName(), ErrorCodes::INCORRECT_QUERY);
+
+    /// Default value, if only table name exist in the query
+    select_database_name = local_context.getCurrentDatabase();
+    if (query.select->list_of_selects->children.size() != 1)
+        throw Exception("UNION is not supported for LIVE VIEW", ErrorCodes::QUERY_IS_NOT_SUPPORTED_IN_LIVE_VIEW);
+
+    inner_query = query.select->list_of_selects->children.at(0);
+
+    ASTSelectQuery & select_query = typeid_cast<ASTSelectQuery &>(*inner_query);
+    extractDependentTable(select_query, select_database_name, select_table_name);
+
+    /// If the table is not specified - use the table `system.one`
+    if (select_table_name.empty())
+    {
+        select_database_name = "system";
+        select_table_name = "one";
+    }
+
+    global_context.addDependency(
+        DatabaseAndTableName(select_database_name, select_table_name),
+        DatabaseAndTableName(database_name, table_name));
+
+    is_temporary = query.temporary;
+
+    blocks_ptr = std::make_shared<BlocksPtr>();
+    active_ptr = std::make_shared<bool>(true);
+}
+
+Block StorageLiveView::getHeader() const
+{
+    if (!sample_block)
+    {
+        auto storage = global_context.getTable(select_database_name, select_table_name);
+        sample_block = InterpreterSelectQuery(inner_query, global_context, storage).getSampleBlock();
+    }
+
+    return sample_block;
+}
+
+bool StorageLiveView::getNewBlocks()
+{
+    Block block;
+    SipHash hash;
+    UInt128 key;
+    BlocksPtr new_blocks = std::make_shared<Blocks>();
+    BlocksPtr new_mergeable_blocks = std::make_shared<Blocks>();
+
+    InterpreterSelectQuery interpreter(inner_query->clone(), global_context, SelectQueryOptions(QueryProcessingStage::WithMergeableState), Names());
+    auto mergeable_stream = std::make_shared<MaterializingBlockInputStream>(interpreter.execute().in);
+
+    while (Block block = mergeable_stream->read())
+        new_mergeable_blocks->push_back(block);
+
+    mergeable_blocks = std::make_shared<std::vector<BlocksPtr>>();
+    mergeable_blocks->push_back(new_mergeable_blocks);
+    BlockInputStreamPtr from = std::make_shared<BlocksBlockInputStream>(std::make_shared<BlocksPtr>(new_mergeable_blocks), mergeable_stream->getHeader());
+    auto proxy_storage = ProxyStorage::createProxyStorage(global_context.getTable(select_database_name, select_table_name), {from}, QueryProcessingStage::WithMergeableState);
+    InterpreterSelectQuery select(inner_query->clone(), global_context, proxy_storage, SelectQueryOptions(QueryProcessingStage::Complete));
+    BlockInputStreamPtr data = std::make_shared<MaterializingBlockInputStream>(select.execute().in);
+    while (Block block = data->read())
+    {
+        block.updateHash(hash);
+        new_blocks->push_back(block);
+    }
+
+    hash.get128(key.low, key.high);
+
+    /// Update blocks only if hash keys do not match
+    /// NOTE: hash could be different for the same result
+    ///       if blocks are not in the same order
+    bool updated = false;
+    {
+        if (hash_key != key.toHexString())
+        {
+            if (new_blocks->empty())
+            {
+                new_blocks->push_back(getHeader());
+            }
+            (*blocks_ptr) = new_blocks;
+            hash_key = key.toHexString();
+            updated = true;
+        }
+    }
+    return updated;
+}
+
+void StorageLiveView::checkTableCanBeDropped() const
+{
+    Dependencies dependencies = global_context.getDependencies(database_name, table_name);
+    if (!dependencies.empty())
+    {
+        DatabaseAndTableName database_and_table_name = dependencies.front();
+        throw Exception("Table has dependency " + database_and_table_name.first + "." + database_and_table_name.second, ErrorCodes::TABLE_WAS_NOT_DROPPED);
+    }
+}
+
+void StorageLiveView::noUsersThread()
+{
+    if (shutdown_called)
+        return;
+
+    bool drop_table = false;
+
+    {
+        Poco::FastMutex::ScopedLock lock(noUsersThreadMutex);
+        while (1)
+        {
+            if (!noUsersThreadWakeUp && !noUsersThreadCondition.tryWait(noUsersThreadMutex, global_context.getSettingsRef().temporary_live_view_timeout.totalSeconds() * 1000))
+            {
+                noUsersThreadWakeUp = false;
+                if (shutdown_called)
+                    return;
+                if (hasUsers())
+                    return;
+                if (!global_context.getDependencies(database_name, table_name).empty())
+                    continue;
+                drop_table = true;
+            }
+            break;
+        }
+    }
+
+    if (drop_table)
+    {
+        if (global_context.tryGetTable(database_name, table_name))
+        {
+            try
+            {
+                /// We create and execute `drop` query for this table
+                auto drop_query = std::make_shared<ASTDropQuery>();
+                drop_query->database = database_name;
+                drop_query->table = table_name;
+                ASTPtr ast_drop_query = drop_query;
+                InterpreterDropQuery drop_interpreter(ast_drop_query, global_context);
+                drop_interpreter.execute();
+            }
+            catch (...)
+            {
+            }
+        }
+    }
+}
+
+void StorageLiveView::startNoUsersThread()
+{
+    bool expected = false;
+    if (!startnousersthread_called.compare_exchange_strong(expected, true))
+        return;
+
+    if (is_dropped)
+        return;
+
+    if (is_temporary)
+    {
+        if (no_users_thread.joinable())
+        {
+            {
+                Poco::FastMutex::ScopedLock lock(noUsersThreadMutex);
+                noUsersThreadWakeUp = true;
+                noUsersThreadCondition.signal();
+            }
+            no_users_thread.join();
+        }
+        {
+            Poco::FastMutex::ScopedLock lock(noUsersThreadMutex);
+            noUsersThreadWakeUp = false;
+        }
+        if (!is_dropped)
+            no_users_thread = std::thread(&StorageLiveView::noUsersThread, this);
+    }
+    startnousersthread_called = false;
+}
+
+void StorageLiveView::startup()
+{
+    startNoUsersThread();
+}
+
+void StorageLiveView::shutdown()
+{
+    bool expected = false;
+    if (!shutdown_called.compare_exchange_strong(expected, true))
+        return;
+
+    if (no_users_thread.joinable())
+    {
+        Poco::FastMutex::ScopedLock lock(noUsersThreadMutex);
+        noUsersThreadWakeUp = true;
+        noUsersThreadCondition.signal();
+        /// Must detach the no users thread
+        /// as we can't join it as it will result
+        /// in a deadlock
+        no_users_thread.detach();
+    }
+}
+
+StorageLiveView::~StorageLiveView()
+{
+    shutdown();
+}
+
+void StorageLiveView::drop()
+{
+    global_context.removeDependency(
+        DatabaseAndTableName(select_database_name, select_table_name),
+        DatabaseAndTableName(database_name, table_name));
+    Poco::FastMutex::ScopedLock lock(mutex);
+    is_dropped = true;
+    condition.broadcast();
+}
+
+void StorageLiveView::refresh(const Context & context)
+{
+    auto alter_lock = lockAlterIntention(context.getCurrentQueryId());
+    {
+        Poco::FastMutex::ScopedLock lock(mutex);
+        if (getNewBlocks())
+            condition.broadcast();
+    }
+}
+
+BlockInputStreams StorageLiveView::read(
+    const Names & /*column_names*/,
+    const SelectQueryInfo & /*query_info*/,
+    const Context & /*context*/,
+    QueryProcessingStage::Enum /*processed_stage*/,
+    const size_t /*max_block_size*/,
+    const unsigned /*num_streams*/)
+{
+    /// add user to the blocks_ptr
+    std::shared_ptr<BlocksPtr> stream_blocks_ptr = blocks_ptr;
+    {
+        Poco::FastMutex::ScopedLock lock(mutex);
+        if (!(*blocks_ptr))
+        {
+            if (getNewBlocks())
+                condition.broadcast();
+        }
+    }
+    return { std::make_shared<BlocksBlockInputStream>(stream_blocks_ptr, getHeader()) };
+}
+
+BlockInputStreams StorageLiveView::watch(
+    const Names & /*column_names*/,
+    const SelectQueryInfo & query_info,
+    const Context & context,
+    QueryProcessingStage::Enum & processed_stage,
+    size_t /*max_block_size*/,
+    const unsigned /*num_streams*/)
+{
+    ASTWatchQuery & query = typeid_cast<ASTWatchQuery &>(*query_info.query);
+
+    /// By default infinite stream of updates
+    int64_t length = -2;
+
+    if (query.limit_length)
+        length = (int64_t)safeGet<UInt64>(typeid_cast<ASTLiteral &>(*query.limit_length).value);
+
+    auto reader = std::make_shared<LiveViewBlockInputStream>(*this, blocks_ptr, active_ptr, condition, mutex, length, context.getSettingsRef().heartbeat_delay);
+
+    if (no_users_thread.joinable())
+    {
+        Poco::FastMutex::ScopedLock lock(noUsersThreadMutex);
+        noUsersThreadWakeUp = true;
+        noUsersThreadCondition.signal();
+    }
+
+    {
+        Poco::FastMutex::ScopedLock lock(mutex);
+        if (!(*blocks_ptr))
+        {
+           if (getNewBlocks())
+               condition.broadcast();
+        }
+    }
+
+    processed_stage = QueryProcessingStage::Complete;
+
+    return { reader };
+}
+
+BlockOutputStreamPtr StorageLiveView::write(const ASTPtr & /*query*/, const Context & /*context*/)
+{
+    return std::make_shared<LiveViewBlockOutputStream>(*this);
+}
+
+void registerStorageLiveView(StorageFactory & factory)
+{
+    factory.registerStorage("LiveView", [](const StorageFactory::Arguments & args)
+    {
+        return StorageLiveView::create(args.table_name, args.database_name, args.local_context, args.query, args.columns);
+    });
+}
+
+}
diff --git a/dbms/src/Storages/StorageLiveView.h b/dbms/src/Storages/StorageLiveView.h
new file mode 100644
index 00000000000..cb90e2b3e71
--- /dev/null
+++ b/dbms/src/Storages/StorageLiveView.h
@@ -0,0 +1,294 @@
+/* Copyright (c) 2018 BlackBerry Limited
+
+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. */
+#pragma once
+
+#include <Poco/Condition.h>
+#include <Interpreters/InterpreterSelectQuery.h>
+#include <DataStreams/IBlockOutputStream.h>
+#include <DataStreams/OneBlockInputStream.h>
+#include <DataStreams/BlocksBlockInputStream.h>
+#include <DataStreams/MaterializingBlockInputStream.h>
+#include <DataStreams/copyData.h>
+#include <ext/shared_ptr_helper.h>
+#include <Common/SipHash.h>
+#include <Storages/IStorage.h>
+#include <Storages/ProxyStorage.h>
+
+namespace DB
+{
+
+class IAST;
+using ASTPtr = std::shared_ptr<IAST>;
+
+class StorageLiveView : public ext::shared_ptr_helper<StorageLiveView>, public IStorage
+{
+friend struct ext::shared_ptr_helper<StorageLiveView>;
+friend class LiveViewBlockOutputStream;
+
+public:
+    ~StorageLiveView() override;
+    String getName() const override { return "LiveView"; }
+    String getTableName() const override { return table_name; }
+    String getDatabaseName() const { return database_name; }
+    String getSelectDatabaseName() const { return select_database_name; }
+    String getSelectTableName() const { return select_table_name; }
+
+    // const NamesAndTypesList & getColumnsListImpl() const override { return *columns; }
+    ASTPtr getInnerQuery() const { return inner_query->clone(); };
+
+    /// It is passed inside the query and solved at its level.
+    bool supportsSampling() const override { return true; }
+    bool supportsFinal() const override { return true; }
+
+    /// Mutex for the blocks and ready condition
+    Poco::FastMutex mutex;
+    /// New blocks ready condition to broadcast to readers
+    /// that new blocks are available
+    Poco::Condition condition;
+
+    bool isTemporary() { return is_temporary; }
+
+    /// Check if we have any readers
+    /// must be called with mutex locked
+    bool hasUsers()
+    {
+        return blocks_ptr.use_count() > 1;
+    }
+
+    /// Check we we have any active readers
+    /// must be called with mutex locked
+    bool hasActiveUsers()
+    {
+        return active_ptr.use_count() > 1;
+    }
+    /// Background thread for temporary tables
+    /// which drops this table if there are no users
+    void startNoUsersThread();
+    Poco::FastMutex noUsersThreadMutex;
+    bool noUsersThreadWakeUp{false};
+    Poco::Condition noUsersThreadCondition;
+
+    String getBlocksHashKey()
+    {
+        return hash_key;
+    }
+
+    /// Reset blocks
+    /// must be called with mutex locked
+    void reset()
+    {
+        (*blocks_ptr).reset();
+        mergeable_blocks.reset();
+        hash_key = "";
+    }
+
+    void checkTableCanBeDropped() const override;
+    void drop() override;
+    void startup() override;
+    void shutdown() override;
+
+    void refresh(const Context & context);
+
+    BlockOutputStreamPtr write(
+        const ASTPtr &,
+        const Context &) override;
+
+    BlockInputStreams read(
+        const Names & column_names,
+        const SelectQueryInfo & query_info,
+        const Context & context,
+        QueryProcessingStage::Enum processed_stage,
+        size_t max_block_size,
+        unsigned num_streams) override;
+
+    BlockInputStreams watch(
+        const Names & column_names,
+        const SelectQueryInfo & query_info,
+        const Context & context,
+        QueryProcessingStage::Enum & processed_stage,
+        size_t max_block_size,
+        unsigned num_streams) override;
+
+    std::shared_ptr<BlocksPtr> getBlocksPtr() { return blocks_ptr; }
+    BlocksPtrs getMergeableBlocks() { return mergeable_blocks; }
+    std::shared_ptr<bool> getActivePtr() { return active_ptr; }
+
+    /// Read new data blocks that store query result
+    bool getNewBlocks();
+
+    Block getHeader() const;
+
+    static void writeIntoLiveView(StorageLiveView & live_view,
+                              const Block & block,
+                              const Context & context,
+                              BlockOutputStreamPtr & output)
+    {
+        /// Check if live view has any readers if not
+        /// just reset blocks to empty and do nothing else
+        /// When first reader comes the blocks will be read.
+        {
+            Poco::FastMutex::ScopedLock lock(live_view.mutex);
+            if (!live_view.hasActiveUsers())
+            {
+                live_view.reset();
+                return;
+            }
+        }
+
+        SipHash hash;
+        UInt128 key;
+        BlockInputStreams from;
+        BlocksPtr blocks = std::make_shared<Blocks>();
+        BlocksPtrs mergeable_blocks;
+        BlocksPtr new_mergeable_blocks = std::make_shared<Blocks>();
+
+        {
+            auto parent_storage = context.getTable(live_view.getSelectDatabaseName(), live_view.getSelectTableName());
+            BlockInputStreams streams = {std::make_shared<OneBlockInputStream>(block)};
+            auto proxy_storage = std::make_shared<ProxyStorage>(parent_storage, std::move(streams), QueryProcessingStage::FetchColumns);
+            InterpreterSelectQuery select_block(live_view.getInnerQuery(), context, proxy_storage,
+                                                QueryProcessingStage::WithMergeableState);
+            auto data_mergeable_stream = std::make_shared<MaterializingBlockInputStream>(select_block.execute().in);
+            while (Block this_block = data_mergeable_stream->read())
+                new_mergeable_blocks->push_back(this_block);
+        }
+
+        if (new_mergeable_blocks->empty())
+            return;
+
+        {
+            Poco::FastMutex::ScopedLock lock(live_view.mutex);
+
+            mergeable_blocks = live_view.getMergeableBlocks();
+            if (!mergeable_blocks || mergeable_blocks->size() >= 64)
+            {
+                mergeable_blocks = std::make_shared<std::vector<BlocksPtr>>();
+                BlocksPtr base_mergeable_blocks = std::make_shared<Blocks>();
+                InterpreterSelectQuery interpreter(live_view.getInnerQuery(), context, SelectQueryOptions(QueryProcessingStage::WithMergeableState), Names{});
+                auto view_mergeable_stream = std::make_shared<MaterializingBlockInputStream>(interpreter.execute().in);
+                while (Block this_block = view_mergeable_stream->read())
+                    base_mergeable_blocks->push_back(this_block);
+                mergeable_blocks->push_back(base_mergeable_blocks);
+            }
+
+            /// Need make new mergeable block structure match the other mergeable blocks
+            if (!mergeable_blocks->front()->empty() && !new_mergeable_blocks->empty())
+            {
+                auto sample_block = mergeable_blocks->front()->front();
+                auto sample_new_block = new_mergeable_blocks->front();
+                for (auto col : sample_new_block)
+                {
+                    for (auto & new_block : *new_mergeable_blocks)
+                    {
+                        if (!sample_block.has(col.name))
+                            new_block.erase(col.name);
+                    }
+                }
+            }
+
+            mergeable_blocks->push_back(new_mergeable_blocks);
+
+            /// Create from blocks streams
+            for (auto & blocks : *mergeable_blocks)
+            {
+                auto sample_block = mergeable_blocks->front()->front().cloneEmpty();
+                BlockInputStreamPtr stream = std::make_shared<BlocksBlockInputStream>(std::make_shared<BlocksPtr>(blocks), sample_block);
+                from.push_back(std::move(stream));
+            }
+        }
+
+        auto parent_storage = context.getTable(live_view.getSelectDatabaseName(), live_view.getSelectTableName());
+        auto proxy_storage = std::make_shared<ProxyStorage>(parent_storage, std::move(from), QueryProcessingStage::WithMergeableState);
+        InterpreterSelectQuery select(live_view.getInnerQuery(), context, proxy_storage, QueryProcessingStage::Complete);
+        BlockInputStreamPtr data = std::make_shared<MaterializingBlockInputStream>(select.execute().in);
+        while (Block this_block = data->read())
+        {
+            this_block.updateHash(hash);
+            blocks->push_back(this_block);
+        }
+        /// get hash key
+        hash.get128(key.low, key.high);
+        /// Update blocks only if hash keys do not match
+        /// NOTE: hash could be different for the same result
+        ///       if blocks are not in the same order
+        if (live_view.getBlocksHashKey() != key.toHexString())
+        {
+            auto sample_block = blocks->front().cloneEmpty();
+            BlockInputStreamPtr new_data = std::make_shared<BlocksBlockInputStream>(std::make_shared<BlocksPtr>(blocks), sample_block);
+            {
+                Poco::FastMutex::ScopedLock lock(live_view.mutex);
+                copyData(*new_data, *output);
+            }
+        }
+    }
+
+private:
+    String select_database_name;
+    String select_table_name;
+    String table_name;
+    String database_name;
+    ASTPtr inner_query;
+    Context & global_context;
+    bool is_temporary {false};
+    mutable Block sample_block;
+
+    /// Active users
+    std::shared_ptr<bool> active_ptr;
+    /// Current data blocks that store query result
+    std::shared_ptr<BlocksPtr> blocks_ptr;
+    BlocksPtr new_blocks;
+    BlocksPtrs mergeable_blocks;
+
+    /// Current blocks hash key
+    String hash_key;
+    String new_hash_key;
+
+    void noUsersThread();
+    std::thread no_users_thread;
+    std::atomic<bool> shutdown_called{false};
+    std::atomic<bool> startnousersthread_called{false};
+
+    StorageLiveView(
+        const String & table_name_,
+        const String & database_name_,
+        Context & local_context,
+        const ASTCreateQuery & query,
+        const ColumnsDescription & columns
+    );
+};
+
+class LiveViewBlockOutputStream : public IBlockOutputStream
+{
+public:
+    explicit LiveViewBlockOutputStream(StorageLiveView & storage_) : storage(storage_) {}
+
+    void write(const Block & block) override
+    {
+        if (!new_blocks)
+            new_blocks = std::make_shared<Blocks>();
+
+        new_blocks->push_back(block);
+        // FIXME: do I need to calculate block hash?
+        (*storage.blocks_ptr) = new_blocks;
+        new_blocks.reset();
+        storage.condition.broadcast();
+    }
+
+    Block getHeader() const override { return storage.getHeader(); }
+
+private:
+    BlocksPtr new_blocks;
+    String new_hash_key;
+    StorageLiveView & storage;
+};
+
+}

From d112695c42a36b905a74eacd9b057718c0867a2c Mon Sep 17 00:00:00 2001
From: Vitaliy Zakaznikov <vzakaznikov@protonmail.com>
Date: Tue, 28 May 2019 17:17:48 -0400
Subject: [PATCH 019/107] * Adding other changes to support LIVE VIEWs

---
 dbms/src/Common/ErrorCodes.cpp                |   1 +
 dbms/src/Common/UInt128.h                     |  10 +-
 dbms/src/Core/Block.h                         |   3 +-
 dbms/src/Core/Defines.h                       |   4 +
 dbms/src/Core/Settings.h                      |   6 +-
 .../DataStreams/LiveViewBlockInputStream.h    |   8 +-
 .../LiveViewEventsBlockInputStream.h          | 227 +++++++++
 .../PushingToViewsBlockOutputStream.cpp       |  12 +-
 .../PushingToViewsBlockOutputStream.h         |   2 +-
 dbms/src/Databases/DatabasesCommon.cpp        |   2 +-
 .../Interpreters/InterpreterAlterQuery.cpp    |  20 +
 dbms/src/Interpreters/InterpreterFactory.cpp  |   6 +
 dbms/src/Parsers/ASTAlterQuery.cpp            |  52 +-
 dbms/src/Parsers/ASTAlterQuery.h              |  25 +
 dbms/src/Parsers/ASTCreateQuery.cpp           |  13 +
 dbms/src/Parsers/ASTCreateQuery.h             |   3 +
 dbms/src/Parsers/ParserAlterQuery.cpp         | 475 +++++++++++-------
 dbms/src/Parsers/ParserAlterQuery.h           |  21 +
 dbms/src/Parsers/ParserCreateQuery.cpp        |  91 ++++
 dbms/src/Parsers/ParserCreateQuery.h          |  10 +-
 dbms/src/Parsers/ParserQueryWithOutput.cpp    |   5 +-
 dbms/src/Storages/IStorage.h                  |  30 ++
 dbms/src/Storages/StorageFactory.cpp          |  28 ++
 dbms/src/Storages/StorageLiveView.cpp         |  64 ++-
 dbms/src/Storages/StorageLiveView.h           |  47 +-
 dbms/src/Storages/registerStorages.cpp        |   4 +
 26 files changed, 940 insertions(+), 229 deletions(-)
 create mode 100644 dbms/src/DataStreams/LiveViewEventsBlockInputStream.h

diff --git a/dbms/src/Common/ErrorCodes.cpp b/dbms/src/Common/ErrorCodes.cpp
index 7b1aa175c92..752146d9a5b 100644
--- a/dbms/src/Common/ErrorCodes.cpp
+++ b/dbms/src/Common/ErrorCodes.cpp
@@ -427,6 +427,7 @@ namespace ErrorCodes
     extern const int BAD_TTL_EXPRESSION = 450;
     extern const int BAD_TTL_FILE = 451;
     extern const int SETTING_CONSTRAINT_VIOLATION = 452;
+    extern const int QUERY_IS_NOT_SUPPORTED_IN_LIVE_VIEW = 453;
 
     extern const int KEEPER_EXCEPTION = 999;
     extern const int POCO_EXCEPTION = 1000;
diff --git a/dbms/src/Common/UInt128.h b/dbms/src/Common/UInt128.h
index 72fb1a2503a..491d3a980cb 100644
--- a/dbms/src/Common/UInt128.h
+++ b/dbms/src/Common/UInt128.h
@@ -1,7 +1,8 @@
 #pragma once
 
 #include <tuple>
-
+#include <sstream>
+#include <iomanip>
 #include <city.h>
 
 #include <Core/Types.h>
@@ -33,6 +34,13 @@ struct UInt128
 
     auto tuple() const { return std::tie(high, low); }
 
+    String toHexString() const
+    {
+        std::ostringstream os;
+        os << std::setw(16) << std::setfill('0') << std::hex << high << low;
+        return String(os.str());
+    }
+
     bool inline operator== (const UInt128 rhs) const { return tuple() == rhs.tuple(); }
     bool inline operator!= (const UInt128 rhs) const { return tuple() != rhs.tuple(); }
     bool inline operator<  (const UInt128 rhs) const { return tuple() < rhs.tuple(); }
diff --git a/dbms/src/Core/Block.h b/dbms/src/Core/Block.h
index d3ce0c67b79..4a93e5ed803 100644
--- a/dbms/src/Core/Block.h
+++ b/dbms/src/Core/Block.h
@@ -144,7 +144,8 @@ private:
 
 using Blocks = std::vector<Block>;
 using BlocksList = std::list<Block>;
-
+using BlocksPtr = std::shared_ptr<Blocks>;
+using BlocksPtrs = std::shared_ptr<std::vector<BlocksPtr>>;
 
 /// Compare number of columns, data types, column types, column names, and values of constant columns.
 bool blocksHaveEqualStructure(const Block & lhs, const Block & rhs);
diff --git a/dbms/src/Core/Defines.h b/dbms/src/Core/Defines.h
index b8db4d64843..82e882d29f2 100644
--- a/dbms/src/Core/Defines.h
+++ b/dbms/src/Core/Defines.h
@@ -32,7 +32,11 @@
   */
 #define DEFAULT_MERGE_BLOCK_SIZE 8192
 
+#define DEFAULT_TEMPORARY_LIVE_VIEW_TIMEOUT_SEC 5
+#define DEFAULT_TEMPORARY_LIVE_CHANNEL_TIMEOUT_SEC 15
+#define DEFAULT_ALTER_LIVE_CHANNEL_WAIT_MS 10000
 #define SHOW_CHARS_ON_SYNTAX_ERROR ptrdiff_t(160)
+#define DEFAULT_HEARTBEAT_DELAY 15000000
 #define DBMS_DEFAULT_DISTRIBUTED_CONNECTIONS_POOL_SIZE 1024
 #define DBMS_CONNECTION_POOL_WITH_FAILOVER_DEFAULT_MAX_TRIES 3
 /// each period reduces the error counter by 2 times
diff --git a/dbms/src/Core/Settings.h b/dbms/src/Core/Settings.h
index 21eb792e20c..ae7f891a17d 100644
--- a/dbms/src/Core/Settings.h
+++ b/dbms/src/Core/Settings.h
@@ -325,7 +325,11 @@ struct Settings : public SettingsCollection<Settings>
     M(SettingBool, allow_hyperscan, true, "Allow functions that use Hyperscan library. Disable to avoid potentially long compilation times and excessive resource usage.") \
     M(SettingBool, allow_simdjson, 1, "Allow using simdjson library in 'JSON*' functions if AVX2 instructions are available. If disabled rapidjson will be used.") \
     \
-    M(SettingUInt64, max_partitions_per_insert_block, 100, "Limit maximum number of partitions in single INSERTed block. Zero means unlimited. Throw exception if the block contains too many partitions. This setting is a safety threshold, because using large number of partitions is a common misconception.")
+    M(SettingUInt64, max_partitions_per_insert_block, 100, "Limit maximum number of partitions in single INSERTed block. Zero means unlimited. Throw exception if the block contains too many partitions. This setting is a safety threshold, because using large number of partitions is a common misconception.") \
+    M(SettingUInt64, heartbeat_delay, DEFAULT_HEARTBEAT_DELAY, "The interval in microseconds to indicate live query is alive.") \
+    M(SettingSeconds, temporary_live_view_timeout, DEFAULT_TEMPORARY_LIVE_VIEW_TIMEOUT_SEC, "Timeout after which temporary live view is deleted.") \
+    M(SettingSeconds, temporary_live_channel_timeout, DEFAULT_TEMPORARY_LIVE_CHANNEL_TIMEOUT_SEC, "Timeout after which temporary live channel is deleted.") \
+    M(SettingMilliseconds, alter_channel_wait_ms, DEFAULT_ALTER_LIVE_CHANNEL_WAIT_MS, "The wait time for alter channel request.")
 
     DECLARE_SETTINGS_COLLECTION(LIST_OF_SETTINGS)
 
diff --git a/dbms/src/DataStreams/LiveViewBlockInputStream.h b/dbms/src/DataStreams/LiveViewBlockInputStream.h
index 3bb0a52efae..62ab983aad1 100644
--- a/dbms/src/DataStreams/LiveViewBlockInputStream.h
+++ b/dbms/src/DataStreams/LiveViewBlockInputStream.h
@@ -41,9 +41,11 @@ public:
     }
     /// length default -2 because we want LIMIT to specify number of updates so that LIMIT 1 waits for 1 update
     /// and LIMIT 0 just returns data without waiting for any updates
-    LiveViewBlockInputStream(StorageLiveView & storage_, std::shared_ptr<BlocksPtr> blocks_ptr_, std::shared_ptr<bool> active_ptr_, Poco::Condition & condition_, Poco::FastMutex & mutex_,
+    LiveViewBlockInputStream(StorageLiveView & storage_, std::shared_ptr<BlocksPtr> blocks_ptr_,
+        std::shared_ptr<BlocksMetadataPtr> blocks_metadata_ptr_,
+        std::shared_ptr<bool> active_ptr_, Poco::Condition & condition_, Poco::FastMutex & mutex_,
         int64_t length_, const UInt64 & heartbeat_delay_)
-        : storage(storage_), blocks_ptr(blocks_ptr_), active_ptr(active_ptr_), condition(condition_), mutex(mutex_), length(length_ + 1), heartbeat_delay(heartbeat_delay_), blocks_hash("")
+        : storage(storage_), blocks_ptr(blocks_ptr_), blocks_metadata_ptr(blocks_metadata_ptr_), active_ptr(active_ptr_), condition(condition_), mutex(mutex_), length(length_ + 1), heartbeat_delay(heartbeat_delay_), blocks_hash("")
     {
         /// grab active pointer
         active = active_ptr.lock();
@@ -190,9 +192,11 @@ protected:
 private:
     StorageLiveView & storage;
     std::shared_ptr<BlocksPtr> blocks_ptr;
+    std::shared_ptr<BlocksMetadataPtr> blocks_metadata_ptr;
     std::weak_ptr<bool> active_ptr;
     std::shared_ptr<bool> active;
     BlocksPtr blocks;
+    BlocksMetadataPtr blocks_metadata;
     Blocks::iterator it;
     Blocks::iterator end;
     Blocks::iterator begin;
diff --git a/dbms/src/DataStreams/LiveViewEventsBlockInputStream.h b/dbms/src/DataStreams/LiveViewEventsBlockInputStream.h
new file mode 100644
index 00000000000..d9fdda97d21
--- /dev/null
+++ b/dbms/src/DataStreams/LiveViewEventsBlockInputStream.h
@@ -0,0 +1,227 @@
+/* Copyright (c) 2018 BlackBerry Limited
+
+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. */
+#pragma once
+
+#include <limits>
+
+#include <Common/ConcurrentBoundedQueue.h>
+#include <Poco/Condition.h>
+#include <DataTypes/DataTypesNumber.h>
+#include <DataTypes/DataTypeString.h>
+#include <DataStreams/OneBlockInputStream.h>
+#include <DataStreams/IBlockInputStream.h>
+#include <Storages/StorageLiveView.h>
+
+
+namespace DB
+{
+
+/**
+  */
+
+class LiveViewEventsBlockInputStream : public IBlockInputStream
+{
+
+using NonBlockingResult = std::pair<Block, bool>;
+
+public:
+    ~LiveViewEventsBlockInputStream() override
+    {
+        /// Start storage no users thread
+        /// if we are the last active user
+        if (!storage.is_dropped && blocks_ptr.use_count() < 3)
+            storage.startNoUsersThread();
+    }
+    /// length default -2 because we want LIMIT to specify number of updates so that LIMIT 1 waits for 1 update
+    /// and LIMIT 0 just returns data without waiting for any updates
+    LiveViewEventsBlockInputStream(StorageLiveView & storage_, std::shared_ptr<BlocksPtr> blocks_ptr_, std::shared_ptr<BlocksMetadataPtr> blocks_metadata_ptr_, std::shared_ptr<bool> active_ptr_, Poco::Condition & condition_, Poco::FastMutex & mutex_,
+        int64_t length_, const UInt64 & heartbeat_delay_)
+        : storage(storage_), blocks_ptr(blocks_ptr_), blocks_metadata_ptr(blocks_metadata_ptr_), active_ptr(active_ptr_), condition(condition_), mutex(mutex_), length(length_ + 1), heartbeat_delay(heartbeat_delay_)
+    {
+        /// grab active pointer
+        active = active_ptr.lock();
+    }
+
+    String getName() const override { return "LiveViewEventsBlockInputStream"; }
+
+    void cancel(bool kill) override
+    {
+        if (isCancelled() || storage.is_dropped)
+            return;
+        IBlockInputStream::cancel(kill);
+        Poco::FastMutex::ScopedLock lock(mutex);
+        condition.broadcast();
+    }
+
+    Block getHeader() const override { return storage.getHeader(); }
+
+    void refresh()
+    {
+        if (active && blocks && it == end)
+            it =  blocks->begin();
+    }
+
+    void suspend()
+    {
+        active.reset();
+    }
+
+    void resume()
+    {
+        active = active_ptr.lock();
+        {
+            if (!blocks || blocks.get() != (*blocks_ptr).get()) {
+                blocks = (*blocks_ptr);
+                blocks_metadata = (*blocks_metadata_ptr);
+            }
+        }
+        it = blocks->begin();
+        begin = blocks->begin();
+        end = blocks->end();
+    }
+
+    NonBlockingResult tryRead()
+    {
+        return tryRead_(false);
+    }
+
+protected:
+    Block readImpl() override
+    {
+        /// try reading
+        return tryRead_(true).first;
+    }
+
+    /** tryRead method attempts to read a block in either blocking
+     *  or non-blocking mode. If blocking is set to false
+     *  then method return empty block with flag set to false
+     *  to indicate that method would block to get the next block.
+     */
+    NonBlockingResult tryRead_(bool blocking)
+    {
+        if (length == 0)
+        {
+            return { Block(), true };
+        }
+        /// If blocks were never assigned get blocks
+        if (!blocks)
+        {
+            Poco::FastMutex::ScopedLock lock(mutex);
+            if (!active)
+                return { Block(), false };
+            blocks = (*blocks_ptr);
+            blocks_metadata = (*blocks_metadata_ptr);
+            it = blocks->begin();
+            begin = blocks->begin();
+            end = blocks->end();
+        }
+
+        if (isCancelled() || storage.is_dropped)
+        {
+            return { Block(), true };
+        }
+
+        if (it == end)
+        {
+            {
+                Poco::FastMutex::ScopedLock lock(mutex);
+                if (!active)
+                    return { Block(), false };
+                /// If we are done iterating over our blocks
+                /// and there are new blocks availble then get them
+                if (blocks.get() != (*blocks_ptr).get())
+                {
+                    blocks = (*blocks_ptr);
+                    blocks_metadata = (*blocks_metadata_ptr);
+                    it = blocks->begin();
+                    begin = blocks->begin();
+                    end = blocks->end();
+                }
+                /// No new blocks available wait for new ones
+                else
+                {
+                    if (!blocking)
+                    {
+                        return { Block(), false };
+                    }
+                    while (true)
+                    {
+                        bool signaled = condition.tryWait(mutex, std::max((UInt64)0, heartbeat_delay - ((UInt64)timestamp.epochMicroseconds() - last_event_timestamp)) / 1000);
+
+                        if (isCancelled() || storage.is_dropped)
+                        {
+                            return { Block(), true };
+                        }
+                        if (signaled)
+                        {
+                            break;
+                        }
+                        else
+                        {
+                            // return Block(version, hash)
+                            //hashmap["blocks"] = blocks_hash;
+                            last_event_timestamp = (UInt64)timestamp.epochMicroseconds();
+                            //heartbeat(Heartbeat(last_event_timestamp, std::move(hashmap)));
+                        }
+                    }
+                }
+            }
+            return tryRead_(blocking);
+        }
+
+        // move right to the end
+        it = end;
+
+        if (it == end)
+        {
+            if (length > 0)
+                --length;
+        }
+
+        last_event_timestamp = (UInt64)timestamp.epochMicroseconds();
+
+        Block res{
+            ColumnWithTypeAndName(
+                DataTypeUInt64().createColumnConst(1, blocks_metadata->version)->convertToFullColumnIfConst(),
+                std::make_shared<DataTypeUInt64>(),
+                "version"),
+            ColumnWithTypeAndName(
+                DataTypeString().createColumnConst(1, blocks_metadata->hash)->convertToFullColumnIfConst(),
+                std::make_shared<DataTypeString>(),
+                "hash"),
+
+        };
+
+        return { res, true };
+    }
+
+private:
+    StorageLiveView & storage;
+    std::shared_ptr<BlocksPtr> blocks_ptr;
+    std::shared_ptr<BlocksMetadataPtr> blocks_metadata_ptr;
+    std::weak_ptr<bool> active_ptr;
+    std::shared_ptr<bool> active;
+    BlocksPtr blocks;
+    BlocksMetadataPtr blocks_metadata;
+    Blocks::iterator it;
+    Blocks::iterator end;
+    Blocks::iterator begin;
+    Poco::Condition & condition;
+    Poco::FastMutex & mutex;
+    /// Length specifies number of updates to send, default -1 (no limit)
+    int64_t length;
+    UInt64 heartbeat_delay;
+    UInt64 last_event_timestamp{0};
+    Poco::Timestamp timestamp;
+};
+
+}
diff --git a/dbms/src/DataStreams/PushingToViewsBlockOutputStream.cpp b/dbms/src/DataStreams/PushingToViewsBlockOutputStream.cpp
index 195c5edcb07..9ac8fd2ce50 100644
--- a/dbms/src/DataStreams/PushingToViewsBlockOutputStream.cpp
+++ b/dbms/src/DataStreams/PushingToViewsBlockOutputStream.cpp
@@ -7,6 +7,7 @@
 #include <Common/getNumberOfPhysicalCPUCores.h>
 #include <Common/ThreadPool.h>
 #include <Storages/MergeTree/ReplicatedMergeTreeBlockOutputStream.h>
+#include <Storages/StorageLiveView.h>
 
 namespace DB
 {
@@ -72,8 +73,15 @@ void PushingToViewsBlockOutputStream::write(const Block & block)
       */
     Nested::validateArraySizes(block);
 
-    if (output)
-        output->write(block);
+    if (auto * live_view = dynamic_cast<StorageLiveView *>(storage.get()))
+    {
+	    StorageLiveView::writeIntoLiveView(*live_view, block, context, output);
+    }
+    else
+    {
+        if (output)
+            output->write(block);
+    }
 
     /// Don't process materialized views if this block is duplicate
     if (replicated_output && replicated_output->lastBlockIsDuplicate())
diff --git a/dbms/src/DataStreams/PushingToViewsBlockOutputStream.h b/dbms/src/DataStreams/PushingToViewsBlockOutputStream.h
index 3381a828ff0..8aa927ca84f 100644
--- a/dbms/src/DataStreams/PushingToViewsBlockOutputStream.h
+++ b/dbms/src/DataStreams/PushingToViewsBlockOutputStream.h
@@ -5,7 +5,7 @@
 #include <DataStreams/OneBlockInputStream.h>
 #include <DataStreams/MaterializingBlockInputStream.h>
 #include <Storages/StorageMaterializedView.h>
-
+#include <Storages/StorageLiveView.h>
 
 namespace DB
 {
diff --git a/dbms/src/Databases/DatabasesCommon.cpp b/dbms/src/Databases/DatabasesCommon.cpp
index 2d0fc6f4b33..5d0aec84e8b 100644
--- a/dbms/src/Databases/DatabasesCommon.cpp
+++ b/dbms/src/Databases/DatabasesCommon.cpp
@@ -40,7 +40,7 @@ String getTableDefinitionFromCreateQuery(const ASTPtr & query)
     create.replace_view = false;
 
     /// For views it is necessary to save the SELECT query itself, for the rest - on the contrary
-    if (!create.is_view && !create.is_materialized_view)
+    if (!create.is_view && !create.is_materialized_view && !create.is_live_view)
         create.select = nullptr;
 
     create.format = nullptr;
diff --git a/dbms/src/Interpreters/InterpreterAlterQuery.cpp b/dbms/src/Interpreters/InterpreterAlterQuery.cpp
index 8751ff067b1..6d2fc61f080 100644
--- a/dbms/src/Interpreters/InterpreterAlterQuery.cpp
+++ b/dbms/src/Interpreters/InterpreterAlterQuery.cpp
@@ -8,7 +8,9 @@
 #include <Storages/AlterCommands.h>
 #include <Storages/MutationCommands.h>
 #include <Storages/PartitionCommands.h>
+#include <Storages/LiveViewCommands.h>
 #include <Common/typeid_cast.h>
+#include <Storages/StorageLiveView.h>
 
 #include <algorithm>
 
@@ -48,6 +50,7 @@ BlockIO InterpreterAlterQuery::execute()
     AlterCommands alter_commands;
     PartitionCommands partition_commands;
     MutationCommands mutation_commands;
+    LiveViewCommands live_view_commands;
     for (ASTAlterCommand * command_ast : alter.command_list->commands)
     {
         if (auto alter_command = AlterCommand::parse(command_ast))
@@ -56,6 +59,8 @@ BlockIO InterpreterAlterQuery::execute()
             partition_commands.emplace_back(std::move(*partition_command));
         else if (auto mut_command = MutationCommand::parse(command_ast))
             mutation_commands.emplace_back(std::move(*mut_command));
+        else if (auto live_view_command = LiveViewCommand::parse(command_ast))
+            live_view_commands.emplace_back(std::move(*live_view_command));
         else
             throw Exception("Wrong parameter type in ALTER query", ErrorCodes::LOGICAL_ERROR);
     }
@@ -72,6 +77,21 @@ BlockIO InterpreterAlterQuery::execute()
         table->alterPartition(query_ptr, partition_commands, context);
     }
 
+    if (!live_view_commands.empty())
+    {
+	    live_view_commands.validate(*table);
+	    for (const LiveViewCommand & command : live_view_commands)
+	    {
+		auto live_view = std::dynamic_pointer_cast<StorageLiveView>(table);
+		switch (command.type)
+		{
+		    case LiveViewCommand::REFRESH:
+		        live_view->refresh(context);
+		        break;
+                }
+            }
+    }
+
     if (!alter_commands.empty())
     {
         auto table_lock_holder = table->lockAlterIntention(context.getCurrentQueryId());
diff --git a/dbms/src/Interpreters/InterpreterFactory.cpp b/dbms/src/Interpreters/InterpreterFactory.cpp
index 54611860227..eaba1d1d9dc 100644
--- a/dbms/src/Interpreters/InterpreterFactory.cpp
+++ b/dbms/src/Interpreters/InterpreterFactory.cpp
@@ -14,6 +14,7 @@
 #include <Parsers/ASTUseQuery.h>
 #include <Parsers/ASTExplainQuery.h>
 #include <Parsers/TablePropertiesQueriesASTs.h>
+#include <Parsers/ASTWatchQuery.h>
 
 #include <Interpreters/InterpreterAlterQuery.h>
 #include <Interpreters/InterpreterCheckQuery.h>
@@ -35,6 +36,7 @@
 #include <Interpreters/InterpreterShowTablesQuery.h>
 #include <Interpreters/InterpreterSystemQuery.h>
 #include <Interpreters/InterpreterUseQuery.h>
+#include <Interpreters/InterpreterWatchQuery.h>
 
 #include <Parsers/ASTSystemQuery.h>
 
@@ -173,6 +175,10 @@ std::unique_ptr<IInterpreter> InterpreterFactory::get(ASTPtr & query, Context &
         throwIfNoAccess(context);
         return std::make_unique<InterpreterSystemQuery>(query, context);
     }
+    else if (query->as<ASTWatchQuery>())
+    {
+        return std::make_unique<InterpreterWatchQuery>(query, context);
+    }
     else
         throw Exception("Unknown type of query: " + query->getID(), ErrorCodes::UNKNOWN_TYPE_OF_QUERY);
 }
diff --git a/dbms/src/Parsers/ASTAlterQuery.cpp b/dbms/src/Parsers/ASTAlterQuery.cpp
index e614f64d208..15d89f5aaa7 100644
--- a/dbms/src/Parsers/ASTAlterQuery.cpp
+++ b/dbms/src/Parsers/ASTAlterQuery.cpp
@@ -45,6 +45,11 @@ ASTPtr ASTAlterCommand::clone() const
         res->ttl = ttl->clone();
         res->children.push_back(res->ttl);
     }
+    if (values)
+    {
+        res->values = values->clone();
+        res->children.push_back(res->values);
+    }
 
     return res;
 }
@@ -172,6 +177,46 @@ void ASTAlterCommand::formatImpl(
         settings.ostr << (settings.hilite ? hilite_keyword : "") << " WHERE " << (settings.hilite ? hilite_none : "");
         predicate->formatImpl(settings, state, frame);
     }
+    else if (type == ASTAlterCommand::LIVE_VIEW_REFRESH)
+    {
+        settings.ostr << (settings.hilite ? hilite_keyword : "") << indent_str << "REFRESH " << (settings.hilite ? hilite_none : "");
+    }
+    else if (type == ASTAlterCommand::LIVE_CHANNEL_ADD)
+    {
+        settings.ostr << (settings.hilite ? hilite_keyword : "") << indent_str << "ADD " << (settings.hilite ? hilite_none : "");
+
+        values->formatImpl(settings, state, frame);
+    }
+    else if (type == ASTAlterCommand::LIVE_CHANNEL_DROP)
+    {
+        settings.ostr << (settings.hilite ? hilite_keyword : "") << indent_str << "DROP " << (settings.hilite ? hilite_none : "");
+
+        values->formatImpl(settings, state, frame);
+    }
+    else if (type == ASTAlterCommand::LIVE_CHANNEL_MODIFY)
+    {
+        settings.ostr << (settings.hilite ? hilite_keyword : "") << indent_str << "MODIFY " << (settings.hilite ? hilite_none : "");
+
+        values->formatImpl(settings, state, frame);
+    }
+    else if (type == ASTAlterCommand::LIVE_CHANNEL_SUSPEND)
+    {
+        settings.ostr << (settings.hilite ? hilite_keyword : "") << indent_str << "SUSPEND " << (settings.hilite ? hilite_none : "");
+
+        values->formatImpl(settings, state, frame);
+    }
+    else if (type == ASTAlterCommand::LIVE_CHANNEL_RESUME)
+    {
+        settings.ostr << (settings.hilite ? hilite_keyword : "") << indent_str << "RESUME " << (settings.hilite ? hilite_none : "");
+
+        values->formatImpl(settings, state, frame);
+    }
+    else if (type == ASTAlterCommand::LIVE_CHANNEL_REFRESH)
+    {
+        settings.ostr << (settings.hilite ? hilite_keyword : "") << indent_str << "REFRESH " << (settings.hilite ? hilite_none : "");
+
+        values->formatImpl(settings, state, frame);
+    }
     else if (type == ASTAlterCommand::COMMENT_COLUMN)
     {
         settings.ostr << (settings.hilite ? hilite_keyword : "") << indent_str << "COMMENT COLUMN " << (settings.hilite ? hilite_none : "");
@@ -236,7 +281,12 @@ void ASTAlterQuery::formatQueryImpl(const FormatSettings & settings, FormatState
 
     std::string indent_str = settings.one_line ? "" : std::string(4u * frame.indent, ' ');
 
-    settings.ostr << (settings.hilite ? hilite_keyword : "") << indent_str << "ALTER TABLE " << (settings.hilite ? hilite_none : "");
+    if (is_live_view)
+        settings.ostr << (settings.hilite ? hilite_keyword : "") << indent_str << "ALTER LIVE VIEW " << (settings.hilite ? hilite_none : "");
+    else if (is_live_channel)
+        settings.ostr << (settings.hilite ? hilite_keyword : "") << indent_str << "ALTER LIVE CHANNEL " << (settings.hilite ? hilite_none : "");
+    else
+        settings.ostr << (settings.hilite ? hilite_keyword : "") << indent_str << "ALTER TABLE " << (settings.hilite ? hilite_none : "");
 
     if (!table.empty())
     {
diff --git a/dbms/src/Parsers/ASTAlterQuery.h b/dbms/src/Parsers/ASTAlterQuery.h
index 2c4b3ddbaf1..3f81eab6ba6 100644
--- a/dbms/src/Parsers/ASTAlterQuery.h
+++ b/dbms/src/Parsers/ASTAlterQuery.h
@@ -15,6 +15,15 @@ namespace DB
  *      MODIFY COLUMN col_name type,
  *      DROP PARTITION partition,
  *      COMMENT_COLUMN col_name 'comment',
+ *  ALTER LIVE VIEW [db.]name_type
+ *      REFRESH
+ *  ALTER CHANNEL [db.]name_type
+ *      ADD live_view,...
+ *      DROP live_view,...
+ *      SUSPEND live_view,...
+ *      RESUME live_view,...
+ *      REFRESH live_view,...
+ *      MODIFY live_view,...
  */
 
 class ASTAlterCommand : public IAST
@@ -43,6 +52,15 @@ public:
         UPDATE,
 
         NO_TYPE,
+
+        LIVE_VIEW_REFRESH,
+
+        LIVE_CHANNEL_ADD,
+        LIVE_CHANNEL_DROP,
+        LIVE_CHANNEL_SUSPEND,
+        LIVE_CHANNEL_RESUME,
+        LIVE_CHANNEL_REFRESH,
+        LIVE_CHANNEL_MODIFY
     };
 
     Type type = NO_TYPE;
@@ -88,6 +106,10 @@ public:
     /// For MODIFY TTL query
     ASTPtr ttl;
 
+    /** In ALTER CHANNEL, ADD, DROP, SUSPEND, RESUME, REFRESH, MODIFY queries, the list of live views is stored here
+     */
+    ASTPtr values;
+
     bool detach = false;        /// true for DETACH PARTITION
 
     bool part = false;          /// true for ATTACH PART
@@ -142,6 +164,9 @@ protected:
 class ASTAlterQuery : public ASTQueryWithTableAndOutput, public ASTQueryWithOnCluster
 {
 public:
+    bool is_live_view{false}; /// true for ALTER LIVE VIEW
+    bool is_live_channel{false}; /// true for ALTER LIVE CHANNEL
+
     ASTAlterCommandList * command_list = nullptr;
 
     String getID(char) const override;
diff --git a/dbms/src/Parsers/ASTCreateQuery.cpp b/dbms/src/Parsers/ASTCreateQuery.cpp
index e99c543f5ec..1ed7e06ec45 100644
--- a/dbms/src/Parsers/ASTCreateQuery.cpp
+++ b/dbms/src/Parsers/ASTCreateQuery.cpp
@@ -173,6 +173,8 @@ ASTPtr ASTCreateQuery::clone() const
         res->set(res->storage, storage->clone());
     if (select)
         res->set(res->select, select->clone());
+    if (tables)
+        res->set(res->tables, tables->clone());
 
     cloneOutputOptions(*res);
 
@@ -204,6 +206,11 @@ void ASTCreateQuery::formatQueryImpl(const FormatSettings & settings, FormatStat
             what = "VIEW";
         if (is_materialized_view)
             what = "MATERIALIZED VIEW";
+        if (is_live_view)
+            what = "LIVE VIEW";
+        if (is_live_channel)
+            what = "LIVE CHANNEL";
+
 
         settings.ostr
             << (settings.hilite ? hilite_keyword : "")
@@ -253,6 +260,12 @@ void ASTCreateQuery::formatQueryImpl(const FormatSettings & settings, FormatStat
         settings.ostr << (settings.hilite ? hilite_keyword : "") << " AS" << settings.nl_or_ws << (settings.hilite ? hilite_none : "");
         select->formatImpl(settings, state, frame);
     }
+
+    if (tables)
+    {
+        settings.ostr << (settings.hilite ? hilite_keyword : "") << " WITH " << (settings.hilite ? hilite_none : "");
+        tables->formatImpl(settings, state, frame);
+    }
 }
 
 }
diff --git a/dbms/src/Parsers/ASTCreateQuery.h b/dbms/src/Parsers/ASTCreateQuery.h
index 2755e1a3d78..dedec37a4ad 100644
--- a/dbms/src/Parsers/ASTCreateQuery.h
+++ b/dbms/src/Parsers/ASTCreateQuery.h
@@ -55,9 +55,12 @@ public:
     bool if_not_exists{false};
     bool is_view{false};
     bool is_materialized_view{false};
+    bool is_live_view{false};
+    bool is_live_channel{false};
     bool is_populate{false};
     bool replace_view{false}; /// CREATE OR REPLACE VIEW
     ASTColumns * columns_list = nullptr;
+    ASTExpressionList *tables = nullptr;
     String to_database;   /// For CREATE MATERIALIZED VIEW mv TO table.
     String to_table;
     ASTStorage * storage = nullptr;
diff --git a/dbms/src/Parsers/ParserAlterQuery.cpp b/dbms/src/Parsers/ParserAlterQuery.cpp
index 98891bbdf5f..f8803cc3bc8 100644
--- a/dbms/src/Parsers/ParserAlterQuery.cpp
+++ b/dbms/src/Parsers/ParserAlterQuery.cpp
@@ -32,6 +32,13 @@ bool ParserAlterCommand::parseImpl(Pos & pos, ASTPtr & node, Expected & expected
     ParserKeyword s_add_index("ADD INDEX");
     ParserKeyword s_drop_index("DROP INDEX");
 
+    ParserKeyword s_add("ADD");
+    ParserKeyword s_drop("DROP");
+    ParserKeyword s_suspend("SUSPEND");
+    ParserKeyword s_resume("RESUME");
+    ParserKeyword s_refresh("REFRESH");
+    ParserKeyword s_modify("MODIFY");
+
     ParserKeyword s_attach_partition("ATTACH PARTITION");
     ParserKeyword s_detach_partition("DETACH PARTITION");
     ParserKeyword s_drop_partition("DROP PARTITION");
@@ -63,234 +70,294 @@ bool ParserAlterCommand::parseImpl(Pos & pos, ASTPtr & node, Expected & expected
     ParserList parser_assignment_list(
         std::make_unique<ParserAssignment>(), std::make_unique<ParserToken>(TokenType::Comma),
         /* allow_empty = */ false);
+    ParserNameList values_p;
 
-    if (s_add_column.ignore(pos, expected))
+    if (is_live_view)
     {
-        if (s_if_not_exists.ignore(pos, expected))
-            command->if_not_exists = true;
-
-        if (!parser_col_decl.parse(pos, command->col_decl, expected))
-            return false;
-
-        if (s_after.ignore(pos, expected))
+        if (s_refresh.ignore(pos, expected))
         {
-            if (!parser_name.parse(pos, command->column, expected))
-                return false;
+            command->type = ASTAlterCommand::LIVE_VIEW_REFRESH;
         }
-
-        command->type = ASTAlterCommand::ADD_COLUMN;
-    }
-    else if (s_drop_partition.ignore(pos, expected))
-    {
-        if (!parser_partition.parse(pos, command->partition, expected))
+        else
             return false;
-
-        command->type = ASTAlterCommand::DROP_PARTITION;
     }
-    else if (s_drop_column.ignore(pos, expected))
+    else if (is_live_channel)
     {
-        if (s_if_exists.ignore(pos, expected))
-            command->if_exists = true;
-
-        if (!parser_name.parse(pos, command->column, expected))
-            return false;
-
-        command->type = ASTAlterCommand::DROP_COLUMN;
-        command->detach = false;
-    }
-    else if (s_add_index.ignore(pos, expected))
-    {
-        if (s_if_not_exists.ignore(pos, expected))
-            command->if_not_exists = true;
-
-        if (!parser_idx_decl.parse(pos, command->index_decl, expected))
-            return false;
-
-        if (s_after.ignore(pos, expected))
+        if (s_add.ignore(pos, expected))
         {
-            if (!parser_name.parse(pos, command->index, expected))
+            if (!values_p.parse(pos, command->values, expected))
                 return false;
+
+            command->type = ASTAlterCommand::LIVE_CHANNEL_ADD;
         }
+        else if (s_drop.ignore(pos, expected))
+        {
+            if (!values_p.parse(pos, command->values, expected))
+                return false;
 
-        command->type = ASTAlterCommand::ADD_INDEX;
-    }
-    else if (s_drop_index.ignore(pos, expected))
-    {
-        if (s_if_exists.ignore(pos, expected))
-            command->if_exists = true;
+            command->type = ASTAlterCommand::LIVE_CHANNEL_DROP;
+        }
+        else if (s_suspend.ignore(pos, expected))
+        {
+            if (!values_p.parse(pos, command->values, expected))
+                return false;
 
-        if (!parser_name.parse(pos, command->index, expected))
+            command->type = ASTAlterCommand::LIVE_CHANNEL_SUSPEND;
+        }
+        else if (s_resume.ignore(pos, expected))
+        {
+            if (!values_p.parse(pos, command->values, expected))
+                return false;
+
+            command->type = ASTAlterCommand::LIVE_CHANNEL_RESUME;
+        }
+        else if (s_refresh.ignore(pos, expected))
+        {
+            if (!values_p.parse(pos, command->values, expected))
+                return false;
+
+            command->type = ASTAlterCommand::LIVE_CHANNEL_REFRESH;
+        }
+        else if (s_modify.ignore(pos, expected))
+        {
+            if (!values_p.parse(pos, command->values, expected))
+                return false;
+
+            command->type = ASTAlterCommand::LIVE_CHANNEL_MODIFY;
+        }
+        else
             return false;
-
-        command->type = ASTAlterCommand::DROP_INDEX;
-        command->detach = false;
     }
-    else if (s_clear_column.ignore(pos, expected))
+    else
     {
-        if (s_if_exists.ignore(pos, expected))
-            command->if_exists = true;
+        if (s_add_column.ignore(pos, expected))
+        {
+            if (s_if_not_exists.ignore(pos, expected))
+                command->if_not_exists = true;
 
-        if (!parser_name.parse(pos, command->column, expected))
-            return false;
+            if (!parser_col_decl.parse(pos, command->col_decl, expected))
+                return false;
 
-        command->type = ASTAlterCommand::DROP_COLUMN;
-        command->clear_column = true;
-        command->detach = false;
+            if (s_after.ignore(pos, expected))
+            {
+                if (!parser_name.parse(pos, command->column, expected))
+                    return false;
+            }
 
-        if (s_in_partition.ignore(pos, expected))
+            command->type = ASTAlterCommand::ADD_COLUMN;
+        }
+        else if (s_drop_partition.ignore(pos, expected))
         {
             if (!parser_partition.parse(pos, command->partition, expected))
                 return false;
+
+            command->type = ASTAlterCommand::DROP_PARTITION;
         }
-    }
-    else if (s_detach_partition.ignore(pos, expected))
-    {
-        if (!parser_partition.parse(pos, command->partition, expected))
-            return false;
-
-        command->type = ASTAlterCommand::DROP_PARTITION;
-        command->detach = true;
-    }
-    else if (s_attach_partition.ignore(pos, expected))
-    {
-        if (!parser_partition.parse(pos, command->partition, expected))
-            return false;
-
-        if (s_from.ignore(pos))
+        else if (s_drop_column.ignore(pos, expected))
         {
+            if (s_if_exists.ignore(pos, expected))
+                command->if_exists = true;
+
+            if (!parser_name.parse(pos, command->column, expected))
+                return false;
+
+            command->type = ASTAlterCommand::DROP_COLUMN;
+            command->detach = false;
+        }
+        else if (s_add_index.ignore(pos, expected))
+        {
+            if (s_if_not_exists.ignore(pos, expected))
+                command->if_not_exists = true;
+
+            if (!parser_idx_decl.parse(pos, command->index_decl, expected))
+                return false;
+
+            if (s_after.ignore(pos, expected))
+            {
+                if (!parser_name.parse(pos, command->index, expected))
+                    return false;
+            }
+
+            command->type = ASTAlterCommand::ADD_INDEX;
+        }
+        else if (s_drop_index.ignore(pos, expected))
+        {
+            if (s_if_exists.ignore(pos, expected))
+                command->if_exists = true;
+
+            if (!parser_name.parse(pos, command->index, expected))
+                return false;
+
+            command->type = ASTAlterCommand::DROP_INDEX;
+            command->detach = false;
+        }
+        else if (s_clear_column.ignore(pos, expected))
+        {
+            if (s_if_exists.ignore(pos, expected))
+                command->if_exists = true;
+
+            if (!parser_name.parse(pos, command->column, expected))
+                return false;
+
+            command->type = ASTAlterCommand::DROP_COLUMN;
+            command->clear_column = true;
+            command->detach = false;
+
+            if (s_in_partition.ignore(pos, expected))
+            {
+                if (!parser_partition.parse(pos, command->partition, expected))
+                    return false;
+            }
+        }
+        else if (s_detach_partition.ignore(pos, expected))
+        {
+            if (!parser_partition.parse(pos, command->partition, expected))
+                return false;
+
+            command->type = ASTAlterCommand::DROP_PARTITION;
+            command->detach = true;
+        }
+        else if (s_attach_partition.ignore(pos, expected))
+        {
+            if (!parser_partition.parse(pos, command->partition, expected))
+                return false;
+
+            if (s_from.ignore(pos))
+            {
+                if (!parseDatabaseAndTableName(pos, expected, command->from_database, command->from_table))
+                    return false;
+
+                command->replace = false;
+                command->type = ASTAlterCommand::REPLACE_PARTITION;
+            }
+            else
+            {
+                command->type = ASTAlterCommand::ATTACH_PARTITION;
+            }
+        }
+        else if (s_replace_partition.ignore(pos, expected))
+        {
+            if (!parser_partition.parse(pos, command->partition, expected))
+                return false;
+
+            if (!s_from.ignore(pos, expected))
+                return false;
+
             if (!parseDatabaseAndTableName(pos, expected, command->from_database, command->from_table))
                 return false;
 
-            command->replace = false;
+            command->replace = true;
             command->type = ASTAlterCommand::REPLACE_PARTITION;
         }
-        else
+        else if (s_attach_part.ignore(pos, expected))
         {
+            if (!parser_string_literal.parse(pos, command->partition, expected))
+                return false;
+
+            command->part = true;
             command->type = ASTAlterCommand::ATTACH_PARTITION;
         }
-    }
-    else if (s_replace_partition.ignore(pos, expected))
-    {
-        if (!parser_partition.parse(pos, command->partition, expected))
-            return false;
-
-        if (!s_from.ignore(pos, expected))
-            return false;
-
-        if (!parseDatabaseAndTableName(pos, expected, command->from_database, command->from_table))
-            return false;
-
-        command->replace = true;
-        command->type = ASTAlterCommand::REPLACE_PARTITION;
-    }
-    else if (s_attach_part.ignore(pos, expected))
-    {
-        if (!parser_string_literal.parse(pos, command->partition, expected))
-            return false;
-
-        command->part = true;
-        command->type = ASTAlterCommand::ATTACH_PARTITION;
-    }
-    else if (s_fetch_partition.ignore(pos, expected))
-    {
-        if (!parser_partition.parse(pos, command->partition, expected))
-            return false;
-
-        if (!s_from.ignore(pos, expected))
-            return false;
-
-        ASTPtr ast_from;
-        if (!parser_string_literal.parse(pos, ast_from, expected))
-            return false;
-
-        command->from = ast_from->as<ASTLiteral &>().value.get<const String &>();
-        command->type = ASTAlterCommand::FETCH_PARTITION;
-    }
-    else if (s_freeze.ignore(pos, expected))
-    {
-        if (s_partition.ignore(pos, expected))
+        else if (s_fetch_partition.ignore(pos, expected))
         {
             if (!parser_partition.parse(pos, command->partition, expected))
                 return false;
 
-            command->type = ASTAlterCommand::FREEZE_PARTITION;
+            if (!s_from.ignore(pos, expected))
+                return false;
+
+            ASTPtr ast_from;
+            if (!parser_string_literal.parse(pos, ast_from, expected))
+                return false;
+
+            command->from = ast_from->as<ASTLiteral &>().value.get<const String &>();
+            command->type = ASTAlterCommand::FETCH_PARTITION;
+        }
+        else if (s_freeze.ignore(pos, expected))
+        {
+            if (s_partition.ignore(pos, expected))
+            {
+                if (!parser_partition.parse(pos, command->partition, expected))
+                    return false;
+
+                command->type = ASTAlterCommand::FREEZE_PARTITION;
+            }
+            else
+            {
+                command->type = ASTAlterCommand::FREEZE_ALL;
+            }
+
+            /// WITH NAME 'name' - place local backup to directory with specified name
+            if (s_with.ignore(pos, expected))
+            {
+                if (!s_name.ignore(pos, expected))
+                    return false;
+
+                ASTPtr ast_with_name;
+                if (!parser_string_literal.parse(pos, ast_with_name, expected))
+                    return false;
+
+                command->with_name = ast_with_name->as<ASTLiteral &>().value.get<const String &>();
+            }
+        }
+        else if (s_modify_column.ignore(pos, expected))
+        {
+            if (s_if_exists.ignore(pos, expected))
+                command->if_exists = true;
+
+            if (!parser_modify_col_decl.parse(pos, command->col_decl, expected))
+                return false;
+
+            command->type = ASTAlterCommand::MODIFY_COLUMN;
+        }
+        else if (s_modify_order_by.ignore(pos, expected))
+        {
+            if (!parser_exp_elem.parse(pos, command->order_by, expected))
+                return false;
+
+            command->type = ASTAlterCommand::MODIFY_ORDER_BY;
+        }
+        else if (s_delete_where.ignore(pos, expected))
+        {
+            if (!parser_exp_elem.parse(pos, command->predicate, expected))
+                return false;
+
+            command->type = ASTAlterCommand::DELETE;
+        }
+        else if (s_update.ignore(pos, expected))
+        {
+            if (!parser_assignment_list.parse(pos, command->update_assignments, expected))
+                return false;
+
+            if (!s_where.ignore(pos, expected))
+                return false;
+
+            if (!parser_exp_elem.parse(pos, command->predicate, expected))
+                return false;
+
+            command->type = ASTAlterCommand::UPDATE;
+        }
+        else if (s_comment_column.ignore(pos, expected))
+        {
+            if (s_if_exists.ignore(pos, expected))
+                command->if_exists = true;
+
+            if (!parser_name.parse(pos, command->column, expected))
+                return false;
+
+            if (!parser_string_literal.parse(pos, command->comment, expected))
+                return false;
+
+            command->type = ASTAlterCommand::COMMENT_COLUMN;
+        }
+        else if (s_modify_ttl.ignore(pos, expected))
+        {
+            if (!parser_exp_elem.parse(pos, command->ttl, expected))
+                return false;
+            command->type = ASTAlterCommand::MODIFY_TTL;
         }
         else
-        {
-            command->type = ASTAlterCommand::FREEZE_ALL;
-        }
-
-        /// WITH NAME 'name' - place local backup to directory with specified name
-        if (s_with.ignore(pos, expected))
-        {
-            if (!s_name.ignore(pos, expected))
-                return false;
-
-            ASTPtr ast_with_name;
-            if (!parser_string_literal.parse(pos, ast_with_name, expected))
-                return false;
-
-            command->with_name = ast_with_name->as<ASTLiteral &>().value.get<const String &>();
-        }
+            return false;
     }
-    else if (s_modify_column.ignore(pos, expected))
-    {
-        if (s_if_exists.ignore(pos, expected))
-            command->if_exists = true;
-
-        if (!parser_modify_col_decl.parse(pos, command->col_decl, expected))
-            return false;
-
-        command->type = ASTAlterCommand::MODIFY_COLUMN;
-    }
-    else if (s_modify_order_by.ignore(pos, expected))
-    {
-        if (!parser_exp_elem.parse(pos, command->order_by, expected))
-            return false;
-
-        command->type = ASTAlterCommand::MODIFY_ORDER_BY;
-    }
-    else if (s_delete_where.ignore(pos, expected))
-    {
-        if (!parser_exp_elem.parse(pos, command->predicate, expected))
-            return false;
-
-        command->type = ASTAlterCommand::DELETE;
-    }
-    else if (s_update.ignore(pos, expected))
-    {
-        if (!parser_assignment_list.parse(pos, command->update_assignments, expected))
-            return false;
-
-        if (!s_where.ignore(pos, expected))
-            return false;
-
-        if (!parser_exp_elem.parse(pos, command->predicate, expected))
-            return false;
-
-        command->type = ASTAlterCommand::UPDATE;
-    }
-    else if (s_comment_column.ignore(pos, expected))
-    {
-        if (s_if_exists.ignore(pos, expected))
-            command->if_exists = true;
-
-        if (!parser_name.parse(pos, command->column, expected))
-            return false;
-
-        if (!parser_string_literal.parse(pos, command->comment, expected))
-            return false;
-
-        command->type = ASTAlterCommand::COMMENT_COLUMN;
-    }
-    else if (s_modify_ttl.ignore(pos, expected))
-    {
-        if (!parser_exp_elem.parse(pos, command->ttl, expected))
-            return false;
-        command->type = ASTAlterCommand::MODIFY_TTL;
-    }
-    else
-        return false;
 
     if (command->col_decl)
         command->children.push_back(command->col_decl);
@@ -304,6 +371,8 @@ bool ParserAlterCommand::parseImpl(Pos & pos, ASTPtr & node, Expected & expected
         command->children.push_back(command->predicate);
     if (command->update_assignments)
         command->children.push_back(command->update_assignments);
+    if (command->values)
+        command->children.push_back(command->values);
     if (command->comment)
         command->children.push_back(command->comment);
     if (command->ttl)
@@ -319,7 +388,7 @@ bool ParserAlterCommandList::parseImpl(Pos & pos, ASTPtr & node, Expected & expe
     node = command_list;
 
     ParserToken s_comma(TokenType::Comma);
-    ParserAlterCommand p_command;
+    ParserAlterCommand p_command(is_live_view, is_live_channel);
 
     do
     {
@@ -368,8 +437,28 @@ bool ParserAlterQuery::parseImpl(Pos & pos, ASTPtr & node, Expected & expected)
     node = query;
 
     ParserKeyword s_alter_table("ALTER TABLE");
+    ParserKeyword s_alter_live_view("ALTER LIVE VIEW");
+    ParserKeyword s_alter_live_channel("ALTER LIVE CHANNEL");
+
+    bool is_live_view = false;
+    bool is_live_channel = false;
+
     if (!s_alter_table.ignore(pos, expected))
-        return false;
+    {
+        if (!s_alter_live_view.ignore(pos, expected))
+	        if (!s_alter_live_channel.ignore(pos, expected))
+                return false;
+            else
+                is_live_channel = true;
+        else
+            is_live_view = true;
+    }
+
+    if (is_live_view)
+        query->is_live_view = true;
+
+    if (is_live_channel)
+        query->is_live_channel = true;
 
     if (!parseDatabaseAndTableName(pos, expected, query->database, query->table))
         return false;
@@ -382,7 +471,7 @@ bool ParserAlterQuery::parseImpl(Pos & pos, ASTPtr & node, Expected & expected)
     }
     query->cluster = cluster_str;
 
-    ParserAlterCommandList p_command_list;
+    ParserAlterCommandList p_command_list(is_live_view, is_live_channel);
     ASTPtr command_list;
     if (!p_command_list.parse(pos, command_list, expected))
         return false;
diff --git a/dbms/src/Parsers/ParserAlterQuery.h b/dbms/src/Parsers/ParserAlterQuery.h
index 282a4277e17..3dd7f89062b 100644
--- a/dbms/src/Parsers/ParserAlterQuery.h
+++ b/dbms/src/Parsers/ParserAlterQuery.h
@@ -19,6 +19,15 @@ namespace DB
   *     [FREEZE [PARTITION] [WITH NAME name]]
   *     [DELETE WHERE ...]
   *     [UPDATE col_name = expr, ... WHERE ...]
+  * ALTER LIVE VIEW [db.name]
+  *     [REFRESH]
+  * ALTER LIVE CHANNEL [db.name] [ON CLUSTER cluster]
+  *     [ADD live_view, ...]
+  *     [DROP live_view, ...]
+  *     [SUSPEND live_view, ...]
+  *     [RESUME live_view, ...]
+  *     [REFRESH live_view, ...]
+  *     [MODIFY live_view, ...]
   */
 
 class ParserAlterQuery : public IParserBase
@@ -34,6 +43,12 @@ class ParserAlterCommandList : public IParserBase
 protected:
     const char * getName() const { return "a list of ALTER commands"; }
     bool parseImpl(Pos & pos, ASTPtr & node, Expected & expected);
+
+public:
+    bool is_live_view;
+    bool is_live_channel;
+
+    ParserAlterCommandList(bool is_live_view = false, bool is_live_channel = false) : is_live_view(is_live_view), is_live_channel(is_live_channel) {}
 };
 
 
@@ -42,6 +57,12 @@ class ParserAlterCommand : public IParserBase
 protected:
     const char * getName() const { return "ALTER command"; }
     bool parseImpl(Pos & pos, ASTPtr & node, Expected & expected);
+
+public:
+    bool is_live_view;
+    bool is_live_channel;
+
+    ParserAlterCommand(bool is_live_view = false, bool is_live_channel = false) : is_live_view(is_live_view), is_live_channel(is_live_channel) {}
 };
 
 
diff --git a/dbms/src/Parsers/ParserCreateQuery.cpp b/dbms/src/Parsers/ParserCreateQuery.cpp
index fd6665a5a2c..4064dde5213 100644
--- a/dbms/src/Parsers/ParserCreateQuery.cpp
+++ b/dbms/src/Parsers/ParserCreateQuery.cpp
@@ -94,6 +94,12 @@ bool ParserColumnDeclarationList::parseImpl(Pos & pos, ASTPtr & node, Expected &
         .parse(pos, node, expected);
 }
 
+bool ParserNameList::parseImpl(Pos & pos, ASTPtr & node, Expected & expected)
+{
+    return ParserList(std::make_unique<ParserCompoundIdentifier>(), std::make_unique<ParserToken>(TokenType::Comma), false)
+        .parse(pos, node, expected);
+}
+
 bool ParserIndexDeclaration::parseImpl(Pos & pos, ASTPtr & node, Expected & expected)
 {
     ParserKeyword s_type("TYPE");
@@ -309,7 +315,10 @@ bool ParserCreateQuery::parseImpl(Pos & pos, ASTPtr & node, Expected & expected)
     ParserKeyword s_if_not_exists("IF NOT EXISTS");
     ParserKeyword s_as("AS");
     ParserKeyword s_view("VIEW");
+    ParserKeyword s_with("WITH");
     ParserKeyword s_materialized("MATERIALIZED");
+    ParserKeyword s_live("LIVE");
+    ParserKeyword s_channel("CHANNEL");
     ParserKeyword s_populate("POPULATE");
     ParserKeyword s_or_replace("OR REPLACE");
     ParserToken s_dot(TokenType::Dot);
@@ -319,6 +328,7 @@ bool ParserCreateQuery::parseImpl(Pos & pos, ASTPtr & node, Expected & expected)
     ParserIdentifier name_p;
     ParserColumnsOrIndicesDeclarationList columns_or_indices_p;
     ParserSelectWithUnionQuery select_p;
+    ParserNameList names_p;
 
     ASTPtr database;
     ASTPtr table;
@@ -329,11 +339,15 @@ bool ParserCreateQuery::parseImpl(Pos & pos, ASTPtr & node, Expected & expected)
     ASTPtr as_database;
     ASTPtr as_table;
     ASTPtr select;
+    ASTPtr tables;
+
     String cluster_str;
     bool attach = false;
     bool if_not_exists = false;
     bool is_view = false;
     bool is_materialized_view = false;
+    bool is_live_view = false;
+    bool is_live_channel = false;
     bool is_populate = false;
     bool is_temporary = false;
     bool replace_view = false;
@@ -426,6 +440,80 @@ bool ParserCreateQuery::parseImpl(Pos & pos, ASTPtr & node, Expected & expected)
             }
         }
     }
+    else if (s_live.ignore(pos, expected))
+    {
+        if (s_channel.ignore(pos, expected))
+           is_live_channel = true;
+        else if (s_view.ignore(pos, expected))
+           is_live_view = true;
+        else
+           return false;
+
+        if (s_if_not_exists.ignore(pos, expected))
+           if_not_exists = true;
+
+        if (!name_p.parse(pos, table, expected))
+            return false;
+
+        if (s_dot.ignore(pos, expected))
+        {
+            database = table;
+            if (!name_p.parse(pos, table, expected))
+                return false;
+        }
+
+        if (ParserKeyword{"ON"}.ignore(pos, expected))
+        {
+            if (!ASTQueryWithOnCluster::parse(pos, cluster_str, expected))
+                return false;
+        }
+
+        if (!is_live_channel)
+        {
+            // TO [db.]table
+            if (ParserKeyword{"TO"}.ignore(pos, expected))
+            {
+                if (!name_p.parse(pos, to_table, expected))
+                    return false;
+
+                if (s_dot.ignore(pos, expected))
+                {
+                    to_database = to_table;
+                    if (!name_p.parse(pos, to_table, expected))
+                        return false;
+                }
+            }
+        }
+
+        /// Optional - a list of columns can be specified. It must fully comply with SELECT.
+        if (s_lparen.ignore(pos, expected))
+        {
+            if (!columns_or_indices_p.parse(pos, columns_list, expected))
+                return false;
+
+            if (!s_rparen.ignore(pos, expected))
+                return false;
+        }
+
+        if (is_live_channel)
+        {
+            if (s_with.ignore(pos, expected))
+            {
+                if (!names_p.parse(pos, tables, expected))
+                    return false;
+            }
+        }
+        else
+        {
+            /// AS SELECT ...
+            if (!s_as.ignore(pos, expected))
+                return false;
+
+            ParserSelectWithUnionQuery select_p;
+            if (!select_p.parse(pos, select, expected))
+                return false;
+        }
+    }
     else if (is_temporary)
         return false;
     else if (s_database.ignore(pos, expected))
@@ -530,6 +618,8 @@ bool ParserCreateQuery::parseImpl(Pos & pos, ASTPtr & node, Expected & expected)
     query->if_not_exists = if_not_exists;
     query->is_view = is_view;
     query->is_materialized_view = is_materialized_view;
+    query->is_live_view = is_live_view;
+    query->is_live_channel = is_live_channel;
     query->is_populate = is_populate;
     query->temporary = is_temporary;
     query->replace_view = replace_view;
@@ -543,6 +633,7 @@ bool ParserCreateQuery::parseImpl(Pos & pos, ASTPtr & node, Expected & expected)
 
     query->set(query->columns_list, columns_list);
     query->set(query->storage, storage);
+    query->set(query->tables, tables);
 
     getIdentifierName(as_database, query->as_database);
     getIdentifierName(as_table, query->as_table);
diff --git a/dbms/src/Parsers/ParserCreateQuery.h b/dbms/src/Parsers/ParserCreateQuery.h
index bd3c8f671f0..2a6dc44e2db 100644
--- a/dbms/src/Parsers/ParserCreateQuery.h
+++ b/dbms/src/Parsers/ParserCreateQuery.h
@@ -91,6 +91,14 @@ protected:
     bool parseImpl(Pos & pos, ASTPtr & node, Expected & expected);
 };
 
+/** List of table names. */
+class ParserNameList : public IParserBase
+{
+protected:
+    const char * getName() const { return "name list"; }
+    bool parseImpl(Pos & pos, ASTPtr & node, Expected & expected);
+};
+
 
 template <typename NameParser>
 class IParserColumnDeclaration : public IParserBase
@@ -300,7 +308,7 @@ protected:
   * CREATE|ATTACH DATABASE db [ENGINE = engine]
   *
   * Or:
-  * CREATE [OR REPLACE]|ATTACH [MATERIALIZED] VIEW [IF NOT EXISTS] [db.]name [TO [db.]name] [ENGINE = engine] [POPULATE] AS SELECT ...
+  * CREATE[OR REPLACE]|ATTACH [[MATERIALIZED] VIEW] | [[TEMPORARY] LIVE [CHANNEL] | [VIEW]] [IF NOT EXISTS] [db.]name [TO [db.]name] [ENGINE = engine] [POPULATE] AS SELECT ...
   */
 class ParserCreateQuery : public IParserBase
 {
diff --git a/dbms/src/Parsers/ParserQueryWithOutput.cpp b/dbms/src/Parsers/ParserQueryWithOutput.cpp
index c41e0946a96..1c44c639848 100644
--- a/dbms/src/Parsers/ParserQueryWithOutput.cpp
+++ b/dbms/src/Parsers/ParserQueryWithOutput.cpp
@@ -11,6 +11,7 @@
 #include <Parsers/ParserDropQuery.h>
 #include <Parsers/ParserKillQueryQuery.h>
 #include <Parsers/ParserOptimizeQuery.h>
+#include <Parsers/ParserWatchQuery.h>
 #include <Parsers/ParserSetQuery.h>
 #include <Parsers/ASTExplainQuery.h>
 
@@ -32,6 +33,7 @@ bool ParserQueryWithOutput::parseImpl(Pos & pos, ASTPtr & node, Expected & expec
     ParserCheckQuery check_p;
     ParserOptimizeQuery optimize_p;
     ParserKillQueryQuery kill_query_p;
+    ParserWatchQuery watch_p;
 
     ASTPtr query;
 
@@ -57,7 +59,8 @@ bool ParserQueryWithOutput::parseImpl(Pos & pos, ASTPtr & node, Expected & expec
         || drop_p.parse(pos, query, expected)
         || check_p.parse(pos, query, expected)
         || kill_query_p.parse(pos, query, expected)
-        || optimize_p.parse(pos, query, expected);
+        || optimize_p.parse(pos, query, expected)
+        || watch_p.parse(pos, query, expected);
 
     if (!parsed)
         return false;
diff --git a/dbms/src/Storages/IStorage.h b/dbms/src/Storages/IStorage.h
index f18592ebce5..96b0dbd63ab 100644
--- a/dbms/src/Storages/IStorage.h
+++ b/dbms/src/Storages/IStorage.h
@@ -144,6 +144,36 @@ public:
       */
     virtual QueryProcessingStage::Enum getQueryProcessingStage(const Context &) const { return QueryProcessingStage::FetchColumns; }
 
+    /** Watch live changes to the table.
+     * Accepts a list of columns to read, as well as a description of the query,
+     *  from which information can be extracted about how to retrieve data
+     *  (indexes, locks, etc.)
+     * Returns a stream with which you can read data sequentially
+     *  or multiple streams for parallel data reading.
+     * The `processed_stage` info is also written to what stage the request was processed.
+     * (Normally, the function only reads the columns from the list, but in other cases,
+     *  for example, the request can be partially processed on a remote server.)
+     *
+     * context contains settings for one query.
+     * Usually Storage does not care about these settings, since they are used in the interpreter.
+     * But, for example, for distributed query processing, the settings are passed to the remote server.
+     *
+     * num_streams - a recommendation, how many streams to return,
+     *  if the storage can return a different number of streams.
+     *
+     * It is guaranteed that the structure of the table will not change over the lifetime of the returned streams (that is, there will not be ALTER, RENAME and DROP).
+     */
+    virtual BlockInputStreams watch(
+        const Names & /*column_names*/,
+        const SelectQueryInfo & /*query_info*/,
+        const Context & /*context*/,
+        QueryProcessingStage::Enum & /*processed_stage*/,
+        size_t /*max_block_size*/,
+        unsigned /*num_streams*/)
+    {
+        throw Exception("Method watch is not supported by storage " + getName(), ErrorCodes::NOT_IMPLEMENTED);
+    }
+
     /** Read a set of columns from the table.
       * Accepts a list of columns to read, as well as a description of the query,
       *  from which information can be extracted about how to retrieve data
diff --git a/dbms/src/Storages/StorageFactory.cpp b/dbms/src/Storages/StorageFactory.cpp
index 1dd49e5c99b..7d92ce0ea2c 100644
--- a/dbms/src/Storages/StorageFactory.cpp
+++ b/dbms/src/Storages/StorageFactory.cpp
@@ -60,6 +60,22 @@ StoragePtr StorageFactory::get(
 
         name = "View";
     }
+    else if (query.is_live_view)
+    {
+
+        if (query.storage)
+            throw Exception("Specifying ENGINE is not allowed for a LiveView", ErrorCodes::INCORRECT_QUERY);
+
+        name = "LiveView";
+    }
+    else if (query.is_live_channel)
+    {
+
+        if (query.storage)
+            throw Exception("Specifying ENGINE is not allowed for a LiveChannel", ErrorCodes::INCORRECT_QUERY);
+
+        name = "LiveChannel";
+    }
     else
     {
         /// Check for some special types, that are not allowed to be stored in tables. Example: NULL data type.
@@ -115,6 +131,18 @@ StoragePtr StorageFactory::get(
                     "Direct creation of tables with ENGINE MaterializedView is not supported, use CREATE MATERIALIZED VIEW statement",
                     ErrorCodes::INCORRECT_QUERY);
             }
+            else if (name == "LiveView")
+            {
+                throw Exception(
+                    "Direct creation of tables with ENGINE LiveView is not supported, use CREATE LIVE VIEW statement",
+                    ErrorCodes::INCORRECT_QUERY);
+            }
+            else if (name == "LiveChannel")
+            {
+                throw Exception(
+                    "Direct creation of tables with ENGINE LiveChannel is not supported, use CREATE LIVE CHANNEL statement",
+                    ErrorCodes::INCORRECT_QUERY);
+            }
         }
     }
 
diff --git a/dbms/src/Storages/StorageLiveView.cpp b/dbms/src/Storages/StorageLiveView.cpp
index 5a4e225e52c..f7012c1d007 100644
--- a/dbms/src/Storages/StorageLiveView.cpp
+++ b/dbms/src/Storages/StorageLiveView.cpp
@@ -19,6 +19,7 @@ limitations under the License. */
 #include <Interpreters/InterpreterDropQuery.h>
 #include <DataStreams/NullBlockInputStream.h>
 #include <DataStreams/LiveViewBlockInputStream.h>
+#include <DataStreams/LiveViewEventsBlockInputStream.h>
 #include <DataStreams/MaterializingBlockInputStream.h>
 #include <Common/typeid_cast.h>
 
@@ -133,6 +134,7 @@ StorageLiveView::StorageLiveView(
     is_temporary = query.temporary;
 
     blocks_ptr = std::make_shared<BlocksPtr>();
+    blocks_metadata_ptr = std::make_shared<BlocksMetadataPtr>();
     active_ptr = std::make_shared<bool>(true);
 }
 
@@ -153,6 +155,7 @@ bool StorageLiveView::getNewBlocks()
     SipHash hash;
     UInt128 key;
     BlocksPtr new_blocks = std::make_shared<Blocks>();
+    BlocksMetadataPtr new_blocks_metadata = std::make_shared<BlocksMetadata>();
     BlocksPtr new_mergeable_blocks = std::make_shared<Blocks>();
 
     InterpreterSelectQuery interpreter(inner_query->clone(), global_context, SelectQueryOptions(QueryProcessingStage::WithMergeableState), Names());
@@ -180,14 +183,16 @@ bool StorageLiveView::getNewBlocks()
     ///       if blocks are not in the same order
     bool updated = false;
     {
-        if (hash_key != key.toHexString())
+        if (getBlocksHashKey() != key.toHexString())
         {
             if (new_blocks->empty())
             {
                 new_blocks->push_back(getHeader());
             }
+            new_blocks_metadata->hash = key.toHexString();
+            new_blocks_metadata->version = getBlocksVersion() + 1;
             (*blocks_ptr) = new_blocks;
-            hash_key = key.toHexString();
+            (*blocks_metadata_ptr) = new_blocks_metadata;
             updated = true;
         }
     }
@@ -366,27 +371,54 @@ BlockInputStreams StorageLiveView::watch(
     if (query.limit_length)
         length = (int64_t)safeGet<UInt64>(typeid_cast<ASTLiteral &>(*query.limit_length).value);
 
-    auto reader = std::make_shared<LiveViewBlockInputStream>(*this, blocks_ptr, active_ptr, condition, mutex, length, context.getSettingsRef().heartbeat_delay);
-
-    if (no_users_thread.joinable())
+    if (query.is_watch_events)
     {
-        Poco::FastMutex::ScopedLock lock(noUsersThreadMutex);
-        noUsersThreadWakeUp = true;
-        noUsersThreadCondition.signal();
-    }
+        auto reader = std::make_shared<LiveViewEventsBlockInputStream>(*this, blocks_ptr, blocks_metadata_ptr, active_ptr, condition, mutex, length, context.getSettingsRef().heartbeat_delay);
 
-    {
-        Poco::FastMutex::ScopedLock lock(mutex);
-        if (!(*blocks_ptr))
+        if (no_users_thread.joinable())
         {
-           if (getNewBlocks())
-               condition.broadcast();
+            Poco::FastMutex::ScopedLock lock(noUsersThreadMutex);
+            noUsersThreadWakeUp = true;
+            noUsersThreadCondition.signal();
         }
+
+        {
+            Poco::FastMutex::ScopedLock lock(mutex);
+            if (!(*blocks_ptr))
+            {
+            if (getNewBlocks())
+                condition.broadcast();
+            }
+        }
+
+        processed_stage = QueryProcessingStage::Complete;
+
+        return { reader };
     }
+    else
+    {
+        auto reader = std::make_shared<LiveViewBlockInputStream>(*this, blocks_ptr, blocks_metadata_ptr, active_ptr, condition, mutex, length, context.getSettingsRef().heartbeat_delay);
 
-    processed_stage = QueryProcessingStage::Complete;
+        if (no_users_thread.joinable())
+        {
+            Poco::FastMutex::ScopedLock lock(noUsersThreadMutex);
+            noUsersThreadWakeUp = true;
+            noUsersThreadCondition.signal();
+        }
 
-    return { reader };
+        {
+            Poco::FastMutex::ScopedLock lock(mutex);
+            if (!(*blocks_ptr))
+            {
+            if (getNewBlocks())
+                condition.broadcast();
+            }
+        }
+
+        processed_stage = QueryProcessingStage::Complete;
+
+        return { reader };
+    }
 }
 
 BlockOutputStreamPtr StorageLiveView::write(const ASTPtr & /*query*/, const Context & /*context*/)
diff --git a/dbms/src/Storages/StorageLiveView.h b/dbms/src/Storages/StorageLiveView.h
index cb90e2b3e71..9f54f19cffb 100644
--- a/dbms/src/Storages/StorageLiveView.h
+++ b/dbms/src/Storages/StorageLiveView.h
@@ -29,6 +29,14 @@ namespace DB
 class IAST;
 using ASTPtr = std::shared_ptr<IAST>;
 
+struct BlocksMetadata {
+    String hash;
+    UInt64 version;
+};
+
+using BlocksMetadataPtr = std::shared_ptr<BlocksMetadata>;
+using SipHashPtr = std::shared_ptr<SipHash>;
+
 class StorageLiveView : public ext::shared_ptr_helper<StorageLiveView>, public IStorage
 {
 friend struct ext::shared_ptr_helper<StorageLiveView>;
@@ -79,7 +87,16 @@ public:
 
     String getBlocksHashKey()
     {
-        return hash_key;
+        if (*blocks_metadata_ptr)
+            return (*blocks_metadata_ptr)->hash;
+        return "";
+    }
+
+    UInt64 getBlocksVersion()
+    {
+        if (*blocks_metadata_ptr)
+            return (*blocks_metadata_ptr)->version;
+        return -1;
     }
 
     /// Reset blocks
@@ -87,8 +104,8 @@ public:
     void reset()
     {
         (*blocks_ptr).reset();
+        (*blocks_metadata_ptr).reset();
         mergeable_blocks.reset();
-        hash_key = "";
     }
 
     void checkTableCanBeDropped() const override;
@@ -246,12 +263,11 @@ private:
     /// Current data blocks that store query result
     std::shared_ptr<BlocksPtr> blocks_ptr;
     BlocksPtr new_blocks;
+    /// Current data blocks metadata
+    std::shared_ptr<BlocksMetadataPtr> blocks_metadata_ptr;
+    BlocksMetadataPtr new_blocks_metadata;
     BlocksPtrs mergeable_blocks;
 
-    /// Current blocks hash key
-    String hash_key;
-    String new_hash_key;
-
     void noUsersThread();
     std::thread no_users_thread;
     std::atomic<bool> shutdown_called{false};
@@ -273,13 +289,27 @@ public:
 
     void write(const Block & block) override
     {
+        UInt128 key;
+
         if (!new_blocks)
+        {
             new_blocks = std::make_shared<Blocks>();
+            new_blocks_metadata = std::make_shared<BlocksMetadata>();
+            new_hash = std::make_shared<SipHash>();
+        }
 
         new_blocks->push_back(block);
-        // FIXME: do I need to calculate block hash?
+        block.updateHash(*new_hash);
+        new_hash->get128(key.low, key.high);
+        new_blocks_metadata->hash = key.toHexString();
+        new_blocks_metadata->version = storage.getBlocksVersion() + 1;
+
         (*storage.blocks_ptr) = new_blocks;
+        (*storage.blocks_metadata_ptr) = new_blocks_metadata;
+
         new_blocks.reset();
+        new_blocks_metadata.reset();
+        new_hash.reset();
         storage.condition.broadcast();
     }
 
@@ -287,7 +317,8 @@ public:
 
 private:
     BlocksPtr new_blocks;
-    String new_hash_key;
+    BlocksMetadataPtr new_blocks_metadata;
+    SipHashPtr new_hash;
     StorageLiveView & storage;
 };
 
diff --git a/dbms/src/Storages/registerStorages.cpp b/dbms/src/Storages/registerStorages.cpp
index 4bd2d995104..fa90bb44817 100644
--- a/dbms/src/Storages/registerStorages.cpp
+++ b/dbms/src/Storages/registerStorages.cpp
@@ -23,6 +23,8 @@ void registerStorageSet(StorageFactory & factory);
 void registerStorageJoin(StorageFactory & factory);
 void registerStorageView(StorageFactory & factory);
 void registerStorageMaterializedView(StorageFactory & factory);
+void registerStorageLiveView(StorageFactory & factory);
+//void registerStorageLiveChannel(StorageFactory & factory);
 
 #if USE_HDFS
 void registerStorageHDFS(StorageFactory & factory);
@@ -63,6 +65,8 @@ void registerStorages()
     registerStorageJoin(factory);
     registerStorageView(factory);
     registerStorageMaterializedView(factory);
+    registerStorageLiveView(factory);
+    //registerStorageLiveChannel(factory);
 
     #if USE_HDFS
     registerStorageHDFS(factory);

From 673d1a46a05cf36a80051ad60c090410ffb51c9f Mon Sep 17 00:00:00 2001
From: Vitaliy Zakaznikov <vzakaznikov@protonmail.com>
Date: Wed, 29 May 2019 17:52:13 -0400
Subject: [PATCH 020/107] * Adding support for _version virtual column to LIVE
 VIEWs when using SELECT * Adding support for _version column to LIVE VIEWS
 when using WATCH query * Adding initial support for WATCH query on LIVE VIEWs

---
 .../PushingToViewsBlockOutputStream.cpp       | 35 ++++++++++++----
 .../Interpreters/InterpreterCreateQuery.cpp   |  9 +++-
 dbms/src/Storages/StorageLiveView.cpp         | 25 +++++++++++
 dbms/src/Storages/StorageLiveView.h           | 41 ++++++++++++-------
 4 files changed, 85 insertions(+), 25 deletions(-)

diff --git a/dbms/src/DataStreams/PushingToViewsBlockOutputStream.cpp b/dbms/src/DataStreams/PushingToViewsBlockOutputStream.cpp
index 9ac8fd2ce50..c826835b007 100644
--- a/dbms/src/DataStreams/PushingToViewsBlockOutputStream.cpp
+++ b/dbms/src/DataStreams/PushingToViewsBlockOutputStream.cpp
@@ -43,14 +43,25 @@ PushingToViewsBlockOutputStream::PushingToViewsBlockOutputStream(
         for (const auto & database_table : dependencies)
         {
             auto dependent_table = context.getTable(database_table.first, database_table.second);
-            auto & materialized_view = dynamic_cast<const StorageMaterializedView &>(*dependent_table);
 
-            if (StoragePtr inner_table = materialized_view.tryGetTargetTable())
-                addTableLock(inner_table->lockStructureForShare(true, context.getCurrentQueryId()));
+            ASTPtr query;
+            BlockOutputStreamPtr out;
+
+            if (auto * materialized_view = dynamic_cast<const StorageMaterializedView *>(dependent_table.get()))
+            {
+                if (StoragePtr inner_table = materialized_view->tryGetTargetTable())
+                    addTableLock(inner_table->lockStructureForShare(true, context.getCurrentQueryId()));
+
+                query = materialized_view->getInnerQuery();
+            }
+
+            if (dynamic_cast<const StorageLiveView *>(dependent_table.get()))
+                out = std::make_shared<PushingToViewsBlockOutputStream>(
+                    database_table.first, database_table.second, dependent_table, *views_context, ASTPtr(), true);
+            else
+                out = std::make_shared<PushingToViewsBlockOutputStream>(
+                    database_table.first, database_table.second, dependent_table, *views_context, ASTPtr());
 
-            auto query = materialized_view.getInnerQuery();
-            BlockOutputStreamPtr out = std::make_shared<PushingToViewsBlockOutputStream>(
-                database_table.first, database_table.second, dependent_table, *views_context, ASTPtr());
             views.emplace_back(ViewInfo{std::move(query), database_table.first, database_table.second, std::move(out)});
         }
     }
@@ -75,7 +86,8 @@ void PushingToViewsBlockOutputStream::write(const Block & block)
 
     if (auto * live_view = dynamic_cast<StorageLiveView *>(storage.get()))
     {
-	    StorageLiveView::writeIntoLiveView(*live_view, block, context, output);
+        BlockOutputStreamPtr output = storage->write(query_ptr, context);
+        StorageLiveView::writeIntoLiveView(*live_view, block, context, output);
     }
     else
     {
@@ -169,8 +181,13 @@ void PushingToViewsBlockOutputStream::process(const Block & block, size_t view_n
     try
     {
         BlockInputStreamPtr from = std::make_shared<OneBlockInputStream>(block);
-        InterpreterSelectQuery select(view.query, *views_context, from);
-        BlockInputStreamPtr in = std::make_shared<MaterializingBlockInputStream>(select.execute().in);
+        BlockInputStreamPtr in = from;
+
+        if (view.query)
+        {
+            InterpreterSelectQuery select(view.query, *views_context, from);
+            in = std::make_shared<MaterializingBlockInputStream>(select.execute().in);
+        }
         /// Squashing is needed here because the materialized view query can generate a lot of blocks
         /// even when only one block is inserted into the parent table (e.g. if the query is a GROUP BY
         /// and two-level aggregation is triggered).
diff --git a/dbms/src/Interpreters/InterpreterCreateQuery.cpp b/dbms/src/Interpreters/InterpreterCreateQuery.cpp
index 035b299ac5e..92b1eccb952 100644
--- a/dbms/src/Interpreters/InterpreterCreateQuery.cpp
+++ b/dbms/src/Interpreters/InterpreterCreateQuery.cpp
@@ -459,6 +459,11 @@ void InterpreterCreateQuery::setEngine(ASTCreateQuery & create) const
                 "Cannot CREATE a table AS " + as_database_name + "." + as_table_name + ", it is a View",
                 ErrorCodes::INCORRECT_QUERY);
 
+        if (as_create.is_live_view)
+            throw Exception(
+                "Cannot CREATE a table AS " + as_database_name + "." + as_table_name + ", it is a Live View",
+                ErrorCodes::INCORRECT_QUERY);
+
         create.set(create.storage, as_create.storage->ptr());
     }
 }
@@ -499,7 +504,7 @@ BlockIO InterpreterCreateQuery::createTable(ASTCreateQuery & create)
     if (create.to_database.empty())
         create.to_database = current_database;
 
-    if (create.select && (create.is_view || create.is_materialized_view))
+    if (create.select && (create.is_view || create.is_materialized_view || create.is_live_view))
     {
         AddDefaultDatabaseVisitor visitor(current_database);
         visitor.visit(*create.select);
@@ -596,7 +601,7 @@ BlockIO InterpreterCreateQuery::createTable(ASTCreateQuery & create)
 
     /// If the query is a CREATE SELECT, insert the data into the table.
     if (create.select && !create.attach
-        && !create.is_view && (!create.is_materialized_view || create.is_populate))
+        && !create.is_view && !create.is_live_view && (!create.is_materialized_view || create.is_populate))
     {
         auto insert = std::make_shared<ASTInsertQuery>();
 
diff --git a/dbms/src/Storages/StorageLiveView.cpp b/dbms/src/Storages/StorageLiveView.cpp
index f7012c1d007..7f010c2b3de 100644
--- a/dbms/src/Storages/StorageLiveView.cpp
+++ b/dbms/src/Storages/StorageLiveView.cpp
@@ -138,12 +138,32 @@ StorageLiveView::StorageLiveView(
     active_ptr = std::make_shared<bool>(true);
 }
 
+NameAndTypePair StorageLiveView::getColumn(const String & column_name) const
+{
+    if ( column_name == "_version" )
+        return NameAndTypePair("_version", std::make_shared<DataTypeUInt64>());
+
+    return IStorage::getColumn(column_name);
+}
+
+bool StorageLiveView::hasColumn(const String & column_name) const
+{
+    if ( column_name == "_version" )
+        return true;
+
+    return IStorage::hasColumn(column_name);
+}
+
 Block StorageLiveView::getHeader() const
 {
     if (!sample_block)
     {
         auto storage = global_context.getTable(select_database_name, select_table_name);
         sample_block = InterpreterSelectQuery(inner_query, global_context, storage).getSampleBlock();
+        sample_block.insert({DataTypeUInt64().createColumnConst(
+            sample_block.rows(), 0)->convertToFullColumnIfConst(),
+            std::make_shared<DataTypeUInt64>(),
+            "_version"});
     }
 
     return sample_block;
@@ -172,6 +192,11 @@ bool StorageLiveView::getNewBlocks()
     BlockInputStreamPtr data = std::make_shared<MaterializingBlockInputStream>(select.execute().in);
     while (Block block = data->read())
     {
+        /// add result version meta column
+        block.insert({DataTypeUInt64().createColumnConst(
+            block.rows(), getBlocksVersion() + 1)->convertToFullColumnIfConst(),
+            std::make_shared<DataTypeUInt64>(),
+            "_version"});
         block.updateHash(hash);
         new_blocks->push_back(block);
     }
diff --git a/dbms/src/Storages/StorageLiveView.h b/dbms/src/Storages/StorageLiveView.h
index 9f54f19cffb..0c6801f9f61 100644
--- a/dbms/src/Storages/StorageLiveView.h
+++ b/dbms/src/Storages/StorageLiveView.h
@@ -18,6 +18,7 @@ limitations under the License. */
 #include <DataStreams/BlocksBlockInputStream.h>
 #include <DataStreams/MaterializingBlockInputStream.h>
 #include <DataStreams/copyData.h>
+#include <DataTypes/DataTypesNumber.h>
 #include <ext/shared_ptr_helper.h>
 #include <Common/SipHash.h>
 #include <Storages/IStorage.h>
@@ -50,6 +51,9 @@ public:
     String getSelectDatabaseName() const { return select_database_name; }
     String getSelectTableName() const { return select_table_name; }
 
+    NameAndTypePair getColumn(const String & column_name) const override;
+    bool hasColumn(const String & column_name) const override;
+
     // const NamesAndTypesList & getColumnsListImpl() const override { return *columns; }
     ASTPtr getInnerQuery() const { return inner_query->clone(); };
 
@@ -96,7 +100,7 @@ public:
     {
         if (*blocks_metadata_ptr)
             return (*blocks_metadata_ptr)->version;
-        return -1;
+        return 0;
     }
 
     /// Reset blocks
@@ -167,7 +171,6 @@ public:
         BlocksPtr blocks = std::make_shared<Blocks>();
         BlocksPtrs mergeable_blocks;
         BlocksPtr new_mergeable_blocks = std::make_shared<Blocks>();
-
         {
             auto parent_storage = context.getTable(live_view.getSelectDatabaseName(), live_view.getSelectTableName());
             BlockInputStreams streams = {std::make_shared<OneBlockInputStream>(block)};
@@ -227,6 +230,7 @@ public:
         auto proxy_storage = std::make_shared<ProxyStorage>(parent_storage, std::move(from), QueryProcessingStage::WithMergeableState);
         InterpreterSelectQuery select(live_view.getInnerQuery(), context, proxy_storage, QueryProcessingStage::Complete);
         BlockInputStreamPtr data = std::make_shared<MaterializingBlockInputStream>(select.execute().in);
+
         while (Block this_block = data->read())
         {
             this_block.updateHash(hash);
@@ -242,7 +246,6 @@ public:
             auto sample_block = blocks->front().cloneEmpty();
             BlockInputStreamPtr new_data = std::make_shared<BlocksBlockInputStream>(std::make_shared<BlocksPtr>(blocks), sample_block);
             {
-                Poco::FastMutex::ScopedLock lock(live_view.mutex);
                 copyData(*new_data, *output);
             }
         }
@@ -287,22 +290,21 @@ class LiveViewBlockOutputStream : public IBlockOutputStream
 public:
     explicit LiveViewBlockOutputStream(StorageLiveView & storage_) : storage(storage_) {}
 
-    void write(const Block & block) override
+    void writePrefix() override
     {
+        new_blocks = std::make_shared<Blocks>();
+        new_blocks_metadata = std::make_shared<BlocksMetadata>();
+        new_hash = std::make_shared<SipHash>();
+        new_blocks_metadata->version = storage.getBlocksVersion() + 1;
+    }
+
+    void writeSuffix() override
+    {
+        Poco::FastMutex::ScopedLock lock(storage.mutex);
         UInt128 key;
 
-        if (!new_blocks)
-        {
-            new_blocks = std::make_shared<Blocks>();
-            new_blocks_metadata = std::make_shared<BlocksMetadata>();
-            new_hash = std::make_shared<SipHash>();
-        }
-
-        new_blocks->push_back(block);
-        block.updateHash(*new_hash);
         new_hash->get128(key.low, key.high);
         new_blocks_metadata->hash = key.toHexString();
-        new_blocks_metadata->version = storage.getBlocksVersion() + 1;
 
         (*storage.blocks_ptr) = new_blocks;
         (*storage.blocks_metadata_ptr) = new_blocks_metadata;
@@ -310,9 +312,20 @@ public:
         new_blocks.reset();
         new_blocks_metadata.reset();
         new_hash.reset();
+
         storage.condition.broadcast();
     }
 
+    void write(const Block & block) override
+    {
+        new_blocks->push_back(block);
+        new_blocks->back().insert({DataTypeUInt64().createColumnConst(
+            block.rows(), new_blocks_metadata->version)->convertToFullColumnIfConst(),
+            std::make_shared<DataTypeUInt64>(),
+            "_version"});
+        block.updateHash(*new_hash);
+    }
+
     Block getHeader() const override { return storage.getHeader(); }
 
 private:

From f06f0e3947a94782d8dedb0f7305941149731fb4 Mon Sep 17 00:00:00 2001
From: Vitaliy Zakaznikov <vzakaznikov@protonmail.com>
Date: Thu, 30 May 2019 17:29:30 -0400
Subject: [PATCH 021/107] * Adding support for CREATE TEMPORARY LIVE VIEW *
 Fixing issue with setting _version virtual column

---
 .../Interpreters/InterpreterCreateQuery.cpp   |  2 +-
 .../Interpreters/InterpreterWatchQuery.cpp    |  6 ++++++
 dbms/src/Storages/StorageLiveView.cpp         | 11 +++++-----
 dbms/src/Storages/StorageLiveView.h           | 20 ++++++++++++-------
 4 files changed, 26 insertions(+), 13 deletions(-)

diff --git a/dbms/src/Interpreters/InterpreterCreateQuery.cpp b/dbms/src/Interpreters/InterpreterCreateQuery.cpp
index 92b1eccb952..aed7a60b805 100644
--- a/dbms/src/Interpreters/InterpreterCreateQuery.cpp
+++ b/dbms/src/Interpreters/InterpreterCreateQuery.cpp
@@ -436,7 +436,7 @@ void InterpreterCreateQuery::setEngine(ASTCreateQuery & create) const
         return;
     }
 
-    if (create.temporary)
+    if (create.temporary && !create.is_live_view)
     {
         auto engine_ast = std::make_shared<ASTFunction>();
         engine_ast->name = "Memory";
diff --git a/dbms/src/Interpreters/InterpreterWatchQuery.cpp b/dbms/src/Interpreters/InterpreterWatchQuery.cpp
index 4672a42a304..3ba8e2eadaa 100644
--- a/dbms/src/Interpreters/InterpreterWatchQuery.cpp
+++ b/dbms/src/Interpreters/InterpreterWatchQuery.cpp
@@ -23,6 +23,7 @@ namespace DB
 namespace ErrorCodes
 {
     extern const int UNKNOWN_STORAGE;
+    extern const int UNKNOWN_TABLE;
     extern const int TOO_MANY_COLUMNS;
 }
 
@@ -49,6 +50,11 @@ BlockIO InterpreterWatchQuery::execute()
     /// Get storage
     storage = context.tryGetTable(database, table);
 
+    if (!storage)
+        throw Exception("Table " + backQuoteIfNeed(database) + "." +
+        backQuoteIfNeed(table) + " doesn't exist.",
+        ErrorCodes::UNKNOWN_TABLE);
+
     /// List of columns to read to execute the query.
     Names required_columns = storage->getColumns().getNamesOfPhysical();
 
diff --git a/dbms/src/Storages/StorageLiveView.cpp b/dbms/src/Storages/StorageLiveView.cpp
index 7f010c2b3de..799a2193932 100644
--- a/dbms/src/Storages/StorageLiveView.cpp
+++ b/dbms/src/Storages/StorageLiveView.cpp
@@ -192,12 +192,13 @@ bool StorageLiveView::getNewBlocks()
     BlockInputStreamPtr data = std::make_shared<MaterializingBlockInputStream>(select.execute().in);
     while (Block block = data->read())
     {
+        /// calculate hash before virtual column is added
+        block.updateHash(hash);
         /// add result version meta column
         block.insert({DataTypeUInt64().createColumnConst(
             block.rows(), getBlocksVersion() + 1)->convertToFullColumnIfConst(),
             std::make_shared<DataTypeUInt64>(),
             "_version"});
-        block.updateHash(hash);
         new_blocks->push_back(block);
     }
 
@@ -411,8 +412,8 @@ BlockInputStreams StorageLiveView::watch(
             Poco::FastMutex::ScopedLock lock(mutex);
             if (!(*blocks_ptr))
             {
-            if (getNewBlocks())
-                condition.broadcast();
+                if (getNewBlocks())
+                    condition.broadcast();
             }
         }
 
@@ -435,8 +436,8 @@ BlockInputStreams StorageLiveView::watch(
             Poco::FastMutex::ScopedLock lock(mutex);
             if (!(*blocks_ptr))
             {
-            if (getNewBlocks())
-                condition.broadcast();
+                if (getNewBlocks())
+                    condition.broadcast();
             }
         }
 
diff --git a/dbms/src/Storages/StorageLiveView.h b/dbms/src/Storages/StorageLiveView.h
index 0c6801f9f61..d16a80ee888 100644
--- a/dbms/src/Storages/StorageLiveView.h
+++ b/dbms/src/Storages/StorageLiveView.h
@@ -88,14 +88,16 @@ public:
     Poco::FastMutex noUsersThreadMutex;
     bool noUsersThreadWakeUp{false};
     Poco::Condition noUsersThreadCondition;
-
+    /// Get blocks hash
+    /// must be called with mutex locked
     String getBlocksHashKey()
     {
         if (*blocks_metadata_ptr)
             return (*blocks_metadata_ptr)->hash;
         return "";
     }
-
+    /// Get blocks version
+    /// must be called with mutex locked
     UInt64 getBlocksVersion()
     {
         if (*blocks_metadata_ptr)
@@ -295,7 +297,6 @@ public:
         new_blocks = std::make_shared<Blocks>();
         new_blocks_metadata = std::make_shared<BlocksMetadata>();
         new_hash = std::make_shared<SipHash>();
-        new_blocks_metadata->version = storage.getBlocksVersion() + 1;
     }
 
     void writeSuffix() override
@@ -305,6 +306,15 @@ public:
 
         new_hash->get128(key.low, key.high);
         new_blocks_metadata->hash = key.toHexString();
+        new_blocks_metadata->version = storage.getBlocksVersion() + 1;
+
+        for (auto & block : *new_blocks)
+        {
+            block.insert({DataTypeUInt64().createColumnConst(
+                block.rows(), new_blocks_metadata->version)->convertToFullColumnIfConst(),
+                std::make_shared<DataTypeUInt64>(),
+                "_version"});
+        }
 
         (*storage.blocks_ptr) = new_blocks;
         (*storage.blocks_metadata_ptr) = new_blocks_metadata;
@@ -319,10 +329,6 @@ public:
     void write(const Block & block) override
     {
         new_blocks->push_back(block);
-        new_blocks->back().insert({DataTypeUInt64().createColumnConst(
-            block.rows(), new_blocks_metadata->version)->convertToFullColumnIfConst(),
-            std::make_shared<DataTypeUInt64>(),
-            "_version"});
         block.updateHash(*new_hash);
     }
 

From fc21200bddafd553d75ea64c2debb202254f4ab4 Mon Sep 17 00:00:00 2001
From: Vitaliy Zakaznikov <vzakaznikov@protonmail.com>
Date: Mon, 3 Jun 2019 15:53:11 -0400
Subject: [PATCH 022/107] * Started to add LIVE VIEW table tests * Added
 uexpect.py module * Fixed support for CREATE TEMPORARY LIVE VIEW

---
 .../Interpreters/InterpreterCreateQuery.cpp   |   6 +-
 dbms/src/Storages/StorageLiveView.cpp         |   3 +-
 dbms/tests/clickhouse-test                    |   2 +-
 .../00952_live_view_create.reference          |   1 +
 .../0_stateless/00952_live_view_create.sql    |   9 +
 .../00953_live_view_select.reference          |   4 +
 .../0_stateless/00953_live_view_select.sql    |  14 ++
 .../00954_live_view_select_version.reference  |   4 +
 .../00954_live_view_select_version.sql        |  14 ++
 ...ive_view_select_with_aggregation.reference |   3 +
 ...0955_live_view_select_with_aggregation.sql |  18 ++
 .../00956_live_view_watch_events.reference    |   4 +
 .../00956_live_view_watch_events.sql          |  20 ++
 .../00957_live_view_watch.reference           |   4 +
 .../0_stateless/00957_live_view_watch.sql     |  20 ++
 .../0_stateless/00958_live_view_watch_live.py |  46 +++++
 .../00958_live_view_watch_live.reference      |   0
 ...00959_create_temporary_live_view.reference |   4 +
 .../00959_create_temporary_live_view.sql      |  14 ++
 .../00960_temporary_live_view_watch.reference |   4 +
 .../00960_temporary_live_view_watch.sql       |  20 ++
 .../00961_temporary_live_view_watch_live.py   |  46 +++++
 ...1_temporary_live_view_watch_live.reference |   0
 ..._temporary_live_view_watch_live_timeout.py |  57 ++++++
 ...ary_live_view_watch_live_timeout.reference |   0
 dbms/tests/queries/0_stateless/uexpect.py     | 187 ++++++++++++++++++
 26 files changed, 499 insertions(+), 5 deletions(-)
 create mode 100644 dbms/tests/queries/0_stateless/00952_live_view_create.reference
 create mode 100644 dbms/tests/queries/0_stateless/00952_live_view_create.sql
 create mode 100644 dbms/tests/queries/0_stateless/00953_live_view_select.reference
 create mode 100644 dbms/tests/queries/0_stateless/00953_live_view_select.sql
 create mode 100644 dbms/tests/queries/0_stateless/00954_live_view_select_version.reference
 create mode 100644 dbms/tests/queries/0_stateless/00954_live_view_select_version.sql
 create mode 100644 dbms/tests/queries/0_stateless/00955_live_view_select_with_aggregation.reference
 create mode 100644 dbms/tests/queries/0_stateless/00955_live_view_select_with_aggregation.sql
 create mode 100644 dbms/tests/queries/0_stateless/00956_live_view_watch_events.reference
 create mode 100644 dbms/tests/queries/0_stateless/00956_live_view_watch_events.sql
 create mode 100644 dbms/tests/queries/0_stateless/00957_live_view_watch.reference
 create mode 100644 dbms/tests/queries/0_stateless/00957_live_view_watch.sql
 create mode 100755 dbms/tests/queries/0_stateless/00958_live_view_watch_live.py
 create mode 100644 dbms/tests/queries/0_stateless/00958_live_view_watch_live.reference
 create mode 100644 dbms/tests/queries/0_stateless/00959_create_temporary_live_view.reference
 create mode 100644 dbms/tests/queries/0_stateless/00959_create_temporary_live_view.sql
 create mode 100644 dbms/tests/queries/0_stateless/00960_temporary_live_view_watch.reference
 create mode 100644 dbms/tests/queries/0_stateless/00960_temporary_live_view_watch.sql
 create mode 100755 dbms/tests/queries/0_stateless/00961_temporary_live_view_watch_live.py
 create mode 100644 dbms/tests/queries/0_stateless/00961_temporary_live_view_watch_live.reference
 create mode 100755 dbms/tests/queries/0_stateless/00962_temporary_live_view_watch_live_timeout.py
 create mode 100644 dbms/tests/queries/0_stateless/00962_temporary_live_view_watch_live_timeout.reference
 create mode 100644 dbms/tests/queries/0_stateless/uexpect.py

diff --git a/dbms/src/Interpreters/InterpreterCreateQuery.cpp b/dbms/src/Interpreters/InterpreterCreateQuery.cpp
index aed7a60b805..5ce9af7f936 100644
--- a/dbms/src/Interpreters/InterpreterCreateQuery.cpp
+++ b/dbms/src/Interpreters/InterpreterCreateQuery.cpp
@@ -481,7 +481,7 @@ BlockIO InterpreterCreateQuery::createTable(ASTCreateQuery & create)
     }
 
     /// Temporary tables are created out of databases.
-    if (create.temporary && !create.database.empty())
+    if (create.temporary && !create.database.empty() && !create.is_live_view)
         throw Exception("Temporary tables cannot be inside a database. You should not specify a database for a temporary table.",
             ErrorCodes::BAD_DATABASE_FOR_TEMPORARY_TABLE);
 
@@ -539,7 +539,7 @@ BlockIO InterpreterCreateQuery::createTable(ASTCreateQuery & create)
         String data_path;
         DatabasePtr database;
 
-        if (!create.temporary)
+        if (!create.temporary || create.is_live_view)
         {
             database = context.getDatabase(database_name);
             data_path = database->getDataPath();
@@ -582,7 +582,7 @@ BlockIO InterpreterCreateQuery::createTable(ASTCreateQuery & create)
             create.attach,
             false);
 
-        if (create.temporary)
+        if (create.temporary && !create.is_live_view)
             context.getSessionContext().addExternalTable(table_name, res, query_ptr);
         else
             database->createTable(context, table_name, res, query_ptr);
diff --git a/dbms/src/Storages/StorageLiveView.cpp b/dbms/src/Storages/StorageLiveView.cpp
index 799a2193932..57e4695706b 100644
--- a/dbms/src/Storages/StorageLiveView.cpp
+++ b/dbms/src/Storages/StorageLiveView.cpp
@@ -243,9 +243,9 @@ void StorageLiveView::noUsersThread()
     bool drop_table = false;
 
     {
-        Poco::FastMutex::ScopedLock lock(noUsersThreadMutex);
         while (1)
         {
+            Poco::FastMutex::ScopedLock lock(noUsersThreadMutex);
             if (!noUsersThreadWakeUp && !noUsersThreadCondition.tryWait(noUsersThreadMutex, global_context.getSettingsRef().temporary_live_view_timeout.totalSeconds() * 1000))
             {
                 noUsersThreadWakeUp = false;
@@ -271,6 +271,7 @@ void StorageLiveView::noUsersThread()
                 auto drop_query = std::make_shared<ASTDropQuery>();
                 drop_query->database = database_name;
                 drop_query->table = table_name;
+                drop_query->kind = ASTDropQuery::Kind::Drop;
                 ASTPtr ast_drop_query = drop_query;
                 InterpreterDropQuery drop_interpreter(ast_drop_query, global_context);
                 drop_interpreter.execute();
diff --git a/dbms/tests/clickhouse-test b/dbms/tests/clickhouse-test
index fe7d45415bd..ba6f738b81c 100755
--- a/dbms/tests/clickhouse-test
+++ b/dbms/tests/clickhouse-test
@@ -258,7 +258,7 @@ def main(args):
 
     # Keep same default values as in queries/shell_config.sh
     os.environ.setdefault("CLICKHOUSE_BINARY", args.binary)
-    #os.environ.setdefault("CLICKHOUSE_CLIENT", args.client)
+    os.environ.setdefault("CLICKHOUSE_CLIENT", args.client)
     os.environ.setdefault("CLICKHOUSE_CONFIG", args.configserver)
     if args.configclient:
         os.environ.setdefault("CLICKHOUSE_CONFIG_CLIENT", args.configclient)
diff --git a/dbms/tests/queries/0_stateless/00952_live_view_create.reference b/dbms/tests/queries/0_stateless/00952_live_view_create.reference
new file mode 100644
index 00000000000..c39f21eaf5e
--- /dev/null
+++ b/dbms/tests/queries/0_stateless/00952_live_view_create.reference
@@ -0,0 +1 @@
+lv
diff --git a/dbms/tests/queries/0_stateless/00952_live_view_create.sql b/dbms/tests/queries/0_stateless/00952_live_view_create.sql
new file mode 100644
index 00000000000..0b64ed3a876
--- /dev/null
+++ b/dbms/tests/queries/0_stateless/00952_live_view_create.sql
@@ -0,0 +1,9 @@
+DROP TABLE IF EXISTS test.mt;
+
+CREATE TABLE test.mt (a Int32) Engine=MergeTree order by tuple();
+CREATE LIVE VIEW test.lv AS SELECT * FROM test.mt;
+
+SHOW TABLES LIKE 'lv';
+
+DROP TABLE test.lv;
+DROP TABLE test.mt;
diff --git a/dbms/tests/queries/0_stateless/00953_live_view_select.reference b/dbms/tests/queries/0_stateless/00953_live_view_select.reference
new file mode 100644
index 00000000000..9c44fe02ff1
--- /dev/null
+++ b/dbms/tests/queries/0_stateless/00953_live_view_select.reference
@@ -0,0 +1,4 @@
+lv
+1
+2
+3
diff --git a/dbms/tests/queries/0_stateless/00953_live_view_select.sql b/dbms/tests/queries/0_stateless/00953_live_view_select.sql
new file mode 100644
index 00000000000..a51dfb112c1
--- /dev/null
+++ b/dbms/tests/queries/0_stateless/00953_live_view_select.sql
@@ -0,0 +1,14 @@
+DROP TABLE IF EXISTS test.lv;
+DROP TABLE IF EXISTS test.mt;
+
+CREATE TABLE test.mt (a Int32) Engine=MergeTree order by tuple();
+CREATE LIVE VIEW test.lv AS SELECT * FROM test.mt;
+
+SHOW TABLES LIKE 'lv';
+
+INSERT INTO test.mt VALUES (1),(2),(3);
+
+SELECT * FROM test.lv;
+
+DROP TABLE test.lv;
+DROP TABLE test.mt;
diff --git a/dbms/tests/queries/0_stateless/00954_live_view_select_version.reference b/dbms/tests/queries/0_stateless/00954_live_view_select_version.reference
new file mode 100644
index 00000000000..07b5ce41af1
--- /dev/null
+++ b/dbms/tests/queries/0_stateless/00954_live_view_select_version.reference
@@ -0,0 +1,4 @@
+lv
+1	1
+2	1
+3	1
diff --git a/dbms/tests/queries/0_stateless/00954_live_view_select_version.sql b/dbms/tests/queries/0_stateless/00954_live_view_select_version.sql
new file mode 100644
index 00000000000..569cf5b0ab2
--- /dev/null
+++ b/dbms/tests/queries/0_stateless/00954_live_view_select_version.sql
@@ -0,0 +1,14 @@
+DROP TABLE IF EXISTS test.lv;
+DROP TABLE IF EXISTS test.mt;
+
+CREATE TABLE test.mt (a Int32) Engine=MergeTree order by tuple();
+CREATE LIVE VIEW test.lv AS SELECT * FROM test.mt;
+
+SHOW TABLES LIKE 'lv';
+
+INSERT INTO test.mt VALUES (1),(2),(3);
+
+SELECT *,_version FROM test.lv;
+
+DROP TABLE test.lv;
+DROP TABLE test.mt;
diff --git a/dbms/tests/queries/0_stateless/00955_live_view_select_with_aggregation.reference b/dbms/tests/queries/0_stateless/00955_live_view_select_with_aggregation.reference
new file mode 100644
index 00000000000..cb865431ffd
--- /dev/null
+++ b/dbms/tests/queries/0_stateless/00955_live_view_select_with_aggregation.reference
@@ -0,0 +1,3 @@
+lv
+6
+21
diff --git a/dbms/tests/queries/0_stateless/00955_live_view_select_with_aggregation.sql b/dbms/tests/queries/0_stateless/00955_live_view_select_with_aggregation.sql
new file mode 100644
index 00000000000..cdac382cae2
--- /dev/null
+++ b/dbms/tests/queries/0_stateless/00955_live_view_select_with_aggregation.sql
@@ -0,0 +1,18 @@
+DROP TABLE IF EXISTS test.lv;
+DROP TABLE IF EXISTS test.mt;
+
+CREATE TABLE test.mt (a Int32) Engine=MergeTree order by tuple();
+CREATE LIVE VIEW test.lv AS SELECT * FROM test.mt;
+
+SHOW TABLES LIKE 'lv';
+
+INSERT INTO test.mt VALUES (1),(2),(3);
+
+SELECT sum(a) FROM test.lv;
+
+INSERT INTO test.mt VALUES (4),(5),(6);
+
+SELECT sum(a) FROM test.lv;
+
+DROP TABLE test.lv;
+DROP TABLE test.mt;
diff --git a/dbms/tests/queries/0_stateless/00956_live_view_watch_events.reference b/dbms/tests/queries/0_stateless/00956_live_view_watch_events.reference
new file mode 100644
index 00000000000..86a72083821
--- /dev/null
+++ b/dbms/tests/queries/0_stateless/00956_live_view_watch_events.reference
@@ -0,0 +1,4 @@
+lv
+1	c9d39b11cce79112219a73aaa319b475
+1	4cd0592103888d4682de9a32a23602e3
+1	2186dbea325ee4c56b67e9b792e993a3
diff --git a/dbms/tests/queries/0_stateless/00956_live_view_watch_events.sql b/dbms/tests/queries/0_stateless/00956_live_view_watch_events.sql
new file mode 100644
index 00000000000..1dbc201bdca
--- /dev/null
+++ b/dbms/tests/queries/0_stateless/00956_live_view_watch_events.sql
@@ -0,0 +1,20 @@
+DROP TABLE IF EXISTS test.lv;
+DROP TABLE IF EXISTS test.mt;
+
+CREATE TABLE test.mt (a Int32) Engine=MergeTree order by tuple();
+CREATE LIVE VIEW test.lv AS SELECT sum(a) FROM test.mt;
+
+SHOW TABLES LIKE 'lv';
+
+WATCH test.lv EVENTS LIMIT 0;
+
+INSERT INTO test.mt VALUES (1),(2),(3);
+
+WATCH test.lv EVENTS LIMIT 0;
+
+INSERT INTO test.mt VALUES (4),(5),(6);
+
+WATCH test.lv EVENTS LIMIT 0;
+
+DROP TABLE test.lv;
+DROP TABLE test.mt;
diff --git a/dbms/tests/queries/0_stateless/00957_live_view_watch.reference b/dbms/tests/queries/0_stateless/00957_live_view_watch.reference
new file mode 100644
index 00000000000..69a461b3fc4
--- /dev/null
+++ b/dbms/tests/queries/0_stateless/00957_live_view_watch.reference
@@ -0,0 +1,4 @@
+lv
+0	1
+6	1
+21	1
diff --git a/dbms/tests/queries/0_stateless/00957_live_view_watch.sql b/dbms/tests/queries/0_stateless/00957_live_view_watch.sql
new file mode 100644
index 00000000000..ac304fec0b9
--- /dev/null
+++ b/dbms/tests/queries/0_stateless/00957_live_view_watch.sql
@@ -0,0 +1,20 @@
+DROP TABLE IF EXISTS test.lv;
+DROP TABLE IF EXISTS test.mt;
+
+CREATE TABLE test.mt (a Int32) Engine=MergeTree order by tuple();
+CREATE LIVE VIEW test.lv AS SELECT sum(a) FROM test.mt;
+
+SHOW TABLES LIKE 'lv';
+
+WATCH test.lv LIMIT 0;
+
+INSERT INTO test.mt VALUES (1),(2),(3);
+
+WATCH test.lv LIMIT 0;
+
+INSERT INTO test.mt VALUES (4),(5),(6);
+
+WATCH test.lv LIMIT 0;
+
+DROP TABLE test.lv;
+DROP TABLE test.mt;
diff --git a/dbms/tests/queries/0_stateless/00958_live_view_watch_live.py b/dbms/tests/queries/0_stateless/00958_live_view_watch_live.py
new file mode 100755
index 00000000000..9fb58cb556c
--- /dev/null
+++ b/dbms/tests/queries/0_stateless/00958_live_view_watch_live.py
@@ -0,0 +1,46 @@
+#!/usr/bin/env python
+import imp
+import os
+import sys
+import signal
+
+CURDIR = os.path.dirname(os.path.realpath(__file__))
+
+uexpect = imp.load_source('uexpect', os.path.join(CURDIR, 'uexpect.py'))
+
+def client(name=''):
+    client = uexpect.spawn(os.environ.get('CLICKHOUSE_CLIENT'))
+    client.eol('\r')
+    # Note: uncomment this line for debugging
+    #client.logger(sys.stdout, prefix=name)
+    client.timeout(2)
+    return client
+
+prompt = ':\) '
+end_of_block = r'.*\xe2\x94\x82\r\n.*\xe2\x94\x98\r\n'
+client1 = client('client1>')
+client2 = client('client2>')
+
+client1.expect(prompt)
+client2.expect(prompt)
+
+client1.send('DROP TABLE IF EXISTS test.lv')
+client1.expect(prompt)
+client1.send(' DROP TABLE IF EXISTS test.mt')
+client1.expect(prompt)
+client1.send('CREATE TABLE test.mt (a Int32) Engine=MergeTree order by tuple()')
+client1.expect(prompt)
+client1.send('CREATE LIVE VIEW test.lv AS SELECT sum(a) FROM test.mt')
+client1.expect(prompt)
+client1.send('WATCH test.lv')
+client2.send('INSERT INTO test.mt VALUES (1),(2),(3)')
+client1.expect(r'6.*2' + end_of_block)
+client2.send('INSERT INTO test.mt VALUES (4),(5),(6)')
+client1.expect(r'21.*3' + end_of_block)
+# send Ctrl-C
+os.kill(client1.process.pid,signal.SIGINT)
+client1.expect(prompt)
+client1.send('DROP TABLE test.lv')
+client1.expect(prompt)
+client1.send('DROP TABLE test.mt')
+client1.expect(prompt)
diff --git a/dbms/tests/queries/0_stateless/00958_live_view_watch_live.reference b/dbms/tests/queries/0_stateless/00958_live_view_watch_live.reference
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/dbms/tests/queries/0_stateless/00959_create_temporary_live_view.reference b/dbms/tests/queries/0_stateless/00959_create_temporary_live_view.reference
new file mode 100644
index 00000000000..4bd209d4424
--- /dev/null
+++ b/dbms/tests/queries/0_stateless/00959_create_temporary_live_view.reference
@@ -0,0 +1,4 @@
+temporary_live_view_timeout	5
+lv
+0
+0
diff --git a/dbms/tests/queries/0_stateless/00959_create_temporary_live_view.sql b/dbms/tests/queries/0_stateless/00959_create_temporary_live_view.sql
new file mode 100644
index 00000000000..4a4a7ae5eed
--- /dev/null
+++ b/dbms/tests/queries/0_stateless/00959_create_temporary_live_view.sql
@@ -0,0 +1,14 @@
+DROP TABLE IF EXISTS test.lv;
+DROP TABLE IF EXISTS test.mt;
+
+SELECT name, value from system.settings WHERE name = 'temporary_live_view_timeout';
+
+CREATE TABLE test.mt (a Int32) Engine=MergeTree order by tuple();
+CREATE TEMPORARY LIVE VIEW test.lv AS SELECT sum(a) FROM test.mt;
+
+SHOW TABLES LIKE 'lv';
+SELECT sleep(3);
+SELECT sleep(2);
+SHOW TABLES LIKE 'lv';
+
+DROP TABLE test.mt;
diff --git a/dbms/tests/queries/0_stateless/00960_temporary_live_view_watch.reference b/dbms/tests/queries/0_stateless/00960_temporary_live_view_watch.reference
new file mode 100644
index 00000000000..69a461b3fc4
--- /dev/null
+++ b/dbms/tests/queries/0_stateless/00960_temporary_live_view_watch.reference
@@ -0,0 +1,4 @@
+lv
+0	1
+6	1
+21	1
diff --git a/dbms/tests/queries/0_stateless/00960_temporary_live_view_watch.sql b/dbms/tests/queries/0_stateless/00960_temporary_live_view_watch.sql
new file mode 100644
index 00000000000..eb99e054514
--- /dev/null
+++ b/dbms/tests/queries/0_stateless/00960_temporary_live_view_watch.sql
@@ -0,0 +1,20 @@
+DROP TABLE IF EXISTS test.lv;
+DROP TABLE IF EXISTS test.mt;
+
+CREATE TABLE test.mt (a Int32) Engine=MergeTree order by tuple();
+CREATE TEMPORARY LIVE VIEW test.lv AS SELECT sum(a) FROM test.mt;
+
+SHOW TABLES LIKE 'lv';
+
+WATCH test.lv LIMIT 0;
+
+INSERT INTO test.mt VALUES (1),(2),(3);
+
+WATCH test.lv LIMIT 0;
+
+INSERT INTO test.mt VALUES (4),(5),(6);
+
+WATCH test.lv LIMIT 0;
+
+DROP TABLE test.lv;
+DROP TABLE test.mt;
diff --git a/dbms/tests/queries/0_stateless/00961_temporary_live_view_watch_live.py b/dbms/tests/queries/0_stateless/00961_temporary_live_view_watch_live.py
new file mode 100755
index 00000000000..0b0260adeed
--- /dev/null
+++ b/dbms/tests/queries/0_stateless/00961_temporary_live_view_watch_live.py
@@ -0,0 +1,46 @@
+#!/usr/bin/env python
+import imp
+import os
+import sys
+import signal
+
+CURDIR = os.path.dirname(os.path.realpath(__file__))
+
+uexpect = imp.load_source('uexpect', os.path.join(CURDIR, 'uexpect.py'))
+
+def client(name=''):
+    client = uexpect.spawn(os.environ.get('CLICKHOUSE_CLIENT'))
+    client.eol('\r')
+    # Note: uncomment this line for debugging
+    #client.logger(sys.stdout, prefix=name)
+    client.timeout(2)
+    return client
+
+prompt = ':\) '
+end_of_block = r'.*\xe2\x94\x82\r\n.*\xe2\x94\x98\r\n'
+client1 = client('client1>')
+client2 = client('client2>')
+
+client1.expect(prompt)
+client2.expect(prompt)
+
+client1.send('DROP TABLE IF EXISTS test.lv')
+client1.expect(prompt)
+client1.send(' DROP TABLE IF EXISTS test.mt')
+client1.expect(prompt)
+client1.send('CREATE TABLE test.mt (a Int32) Engine=MergeTree order by tuple()')
+client1.expect(prompt)
+client1.send('CREATE TEMPORARY LIVE VIEW test.lv AS SELECT sum(a) FROM test.mt')
+client1.expect(prompt)
+client1.send('WATCH test.lv')
+client2.send('INSERT INTO test.mt VALUES (1),(2),(3)')
+client1.expect(r'6.*2' + end_of_block)
+client2.send('INSERT INTO test.mt VALUES (4),(5),(6)')
+client1.expect(r'21.*3' + end_of_block)
+# send Ctrl-C
+os.kill(client1.process.pid,signal.SIGINT)
+client1.expect(prompt)
+client1.send('DROP TABLE test.lv')
+client1.expect(prompt)
+client1.send('DROP TABLE test.mt')
+client1.expect(prompt)
diff --git a/dbms/tests/queries/0_stateless/00961_temporary_live_view_watch_live.reference b/dbms/tests/queries/0_stateless/00961_temporary_live_view_watch_live.reference
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/dbms/tests/queries/0_stateless/00962_temporary_live_view_watch_live_timeout.py b/dbms/tests/queries/0_stateless/00962_temporary_live_view_watch_live_timeout.py
new file mode 100755
index 00000000000..43bf748dc2b
--- /dev/null
+++ b/dbms/tests/queries/0_stateless/00962_temporary_live_view_watch_live_timeout.py
@@ -0,0 +1,57 @@
+#!/usr/bin/env python
+import imp
+import os
+import sys
+import signal
+
+CURDIR = os.path.dirname(os.path.realpath(__file__))
+
+uexpect = imp.load_source('uexpect', os.path.join(CURDIR, 'uexpect.py'))
+
+def client(name=''):
+    client = uexpect.spawn(os.environ.get('CLICKHOUSE_CLIENT'))
+    client.eol('\r')
+    # Note: uncomment this line for debugging
+    #client.logger(sys.stdout, prefix=name)
+    client.timeout(2)
+    return client
+
+prompt = ':\) '
+end_of_block = r'.*\xe2\x94\x82\r\n.*\xe2\x94\x98\r\n'
+client1 = client('client1>')
+client2 = client('client2>')
+
+client1.expect(prompt)
+client2.expect(prompt)
+
+client1.send('DROP TABLE IF EXISTS test.lv')
+client1.expect(prompt)
+client1.send(' DROP TABLE IF EXISTS test.mt')
+client1.expect(prompt)
+client1.send('CREATE TABLE test.mt (a Int32) Engine=MergeTree order by tuple()')
+client1.expect(prompt)
+client1.send('CREATE TEMPORARY LIVE VIEW test.lv AS SELECT sum(a) FROM test.mt')
+client1.expect(prompt)
+client1.send('SELECT 4')
+client1.expect(prompt, timeout=4)
+client1.send('WATCH test.lv')
+client2.send('INSERT INTO test.mt VALUES (1),(2),(3)')
+client2.expect(prompt)
+client1.expect(r'6.*2' + end_of_block)
+client2.send('SELECT sleep(3)')
+client2.expect(prompt, timeout=4)
+client2.send('INSERT INTO test.mt VALUES (4),(5),(6)')
+client2.expect(prompt)
+client1.expect(r'21.*3' + end_of_block)
+# send Ctrl-C
+os.kill(client1.process.pid,signal.SIGINT)
+client1.expect(prompt)
+client1.send('SELECT sleep(3)')
+client1.expect(prompt, timeout=4)
+client1.send('SELECT sleep(3)')
+client1.expect(prompt, timeout=4)
+client1.send('DROP TABLE test.lv')
+client1.expect('Table test.lv doesn\'t exist')
+client1.expect(prompt)
+client1.send('DROP TABLE test.mt')
+client1.expect(prompt)
diff --git a/dbms/tests/queries/0_stateless/00962_temporary_live_view_watch_live_timeout.reference b/dbms/tests/queries/0_stateless/00962_temporary_live_view_watch_live_timeout.reference
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/dbms/tests/queries/0_stateless/uexpect.py b/dbms/tests/queries/0_stateless/uexpect.py
new file mode 100644
index 00000000000..0b57890b593
--- /dev/null
+++ b/dbms/tests/queries/0_stateless/uexpect.py
@@ -0,0 +1,187 @@
+# Copyright (c) 2019 Vitaliy Zakaznikov
+#
+# 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.
+import os
+import pty
+import time
+import sys
+import re
+
+from threading import Thread
+from subprocess import Popen
+from Queue import Queue, Empty
+
+class TimeoutError(Exception):
+    def __init__(self, timeout):
+        self.timeout = timeout
+
+    def __str__(self):
+        return 'Timeout %.3fs' % float(self.timeout)
+
+class ExpectTimeoutError(Exception):
+    def __init__(self, pattern, timeout, buffer):
+        self.pattern = pattern
+        self.timeout = timeout
+        self.buffer = buffer
+
+    def __str__(self):
+        return ('Timeout %.3fs ' % float(self.timeout) +
+            'for %s ' % repr(self.pattern.pattern) +
+            'buffer ends with %s ' % repr(self.buffer[-80:]) +
+            'or \'%s\'' % ','.join(['%x' % ord(c) for c in self.buffer[-80:]]))
+
+class IO(object):
+    class EOF(object):
+        pass
+
+    class Timeout(object):
+        pass
+
+    EOF = EOF
+    TIMEOUT = Timeout
+
+    class Logger(object):
+        def __init__(self, logger, prefix=''):
+            self._logger = logger
+            self._prefix = prefix
+
+        def write(self, data):
+            self._logger.write(('\n' + data).replace('\n','\n' + self._prefix))
+
+        def flush(self):
+            self._logger.flush()
+
+    def __init__(self, process, master, queue):
+        self.process = process
+        self.master = master
+        self.queue = queue
+        self.buffer = None
+        self.before = None
+        self.after = None
+        self.match = None
+        self.pattern = None
+        self._timeout = None
+        self._logger = None
+        self._eol = ''
+
+    def logger(self, logger=None, prefix=''):
+        if logger:
+            self._logger = self.Logger(logger, prefix=prefix)
+        return self._logger
+
+    def timeout(self, timeout=None):
+        if timeout:
+            self._timeout = timeout
+        return self._timeout
+
+    def eol(self, eol=None):
+        if eol:
+            self._eol = eol
+        return self._eol
+
+    def close(self):
+        if self._logger:
+            self._logger.write('\n')
+            self._logger.flush()
+
+    def send(self, data, eol=None):
+        if eol is None:
+            eol = self._eol
+        return self.write(data + eol)
+
+    def write(self, data):
+        return os.write(self.master, data)
+
+    def expect(self, pattern, timeout=None):
+        self.match = None
+        self.before = None
+        self.after = None
+        pattern = re.compile(pattern)
+        if timeout is None:
+            timeout = self._timeout
+        while timeout >= 0:
+            start_time = time.time()
+            try:
+                data = self.read(timeout=timeout, raise_exception=True)
+            except TimeoutError:
+                if self._logger:
+                    self._logger.write(self.buffer + '\n')
+                    self._logger.flush()
+                exception = ExpectTimeoutError(pattern, timeout, self.buffer)
+                self.buffer = None
+                raise exception
+            timeout -= (time.time() - start_time)
+            if data:
+                self.buffer = self.buffer + data if self.buffer else data
+            self.match = pattern.search(self.buffer, 0)
+            if self.match:
+                self.after = self.buffer[self.match.start():self.match.end()]
+                self.before = self.buffer[:self.match.start()]
+                self.buffer = self.buffer[self.match.end():]
+                break
+        if self._logger:
+            self._logger.write(self.before + self.after)
+            self._logger.flush()
+        return self.match
+
+    def read(self, timeout=0, raise_exception=False):
+        data = ''
+        try:
+            while timeout >= 0 :
+                start_time = time.time()
+                data += self.queue.get(timeout=timeout)
+                if data:
+                    break
+                timeout -= (time.time() - start_time)
+        except Empty:
+            if data:
+                return data
+            if raise_exception:
+                raise TimeoutError(timeout)
+            pass
+        return data
+
+def spawn(*command):
+    master, slave = pty.openpty()
+    process = Popen(command, preexec_fn=os.setsid, stdout=slave, stdin=slave, stderr=slave, bufsize=1)
+    os.close(slave)
+
+    queue = Queue()
+    thread = Thread(target=reader, args=(master, queue))
+    thread.daemon = True
+    thread.start()
+
+    return IO(process, master, queue)
+
+def reader(out, queue):
+    while True:
+        data = os.read(out, 65536)
+        queue.put(data)
+
+if __name__ == '__main__':
+   io = spawn('/bin/bash')
+   prompt = '\$ '
+   io.logger(sys.stdout)
+   io.timeout(2)
+   io.eol('\r')
+
+   io.expect(prompt)
+   io.send('clickhouse-client')
+   prompt = ':\) '
+   io.expect(prompt)
+   io.send('SELECT 1')
+   io.expect(prompt)
+   io.send('SHOW TABLES')
+   io.expect('test')
+   io.expect(prompt)
+   io.close()

From 5f3be8134dcaded078e266f6c5a2165be569f43e Mon Sep 17 00:00:00 2001
From: Vitaliy Zakaznikov <vzakaznikov@protonmail.com>
Date: Wed, 5 Jun 2019 07:30:29 -0400
Subject: [PATCH 023/107] * Disallowing writes into LIVE VIEW tables * Adding
 support for watching live views via HTTPHandler * Small fix to
 WriteBufferValidUTF8.cpp to propagate next() call * Updated copyData.cpp to
 treat block with no rows as   "flush block" * Updated
 PushingToViewsBlockOutputStream.cpp to directly use   LIVE VIEW output stream
 instead of calling its write method

---
 .../DataStreams/LiveViewBlockInputStream.h    | 11 +++-
 .../LiveViewEventsBlockInputStream.h          | 56 +++++++++++++------
 .../PushingToViewsBlockOutputStream.cpp       |  2 +-
 dbms/src/DataStreams/copyData.cpp             |  2 +
 dbms/src/IO/WriteBufferValidUTF8.cpp          |  3 +
 dbms/src/Storages/StorageLiveView.cpp         |  5 --
 dbms/src/Storages/StorageLiveView.h           | 15 +++--
 7 files changed, 61 insertions(+), 33 deletions(-)

diff --git a/dbms/src/DataStreams/LiveViewBlockInputStream.h b/dbms/src/DataStreams/LiveViewBlockInputStream.h
index 62ab983aad1..a6c9c3533ee 100644
--- a/dbms/src/DataStreams/LiveViewBlockInputStream.h
+++ b/dbms/src/DataStreams/LiveViewBlockInputStream.h
@@ -151,6 +151,11 @@ protected:
                     {
                         return { Block(), false };
                     }
+                    if (!end_of_blocks)
+                    {
+                        end_of_blocks = true;
+                        return { getHeader(), true };
+                    }
                     while (true)
                     {
                         bool signaled = condition.tryWait(mutex, std::max((UInt64)0, heartbeat_delay - ((UInt64)timestamp.epochMicroseconds() - last_event_timestamp)) / 1000);
@@ -165,9 +170,9 @@ protected:
                         }
                         else
                         {
-                            //hashmap["blocks"] = blocks_hash;
+                            // heartbeat
                             last_event_timestamp = (UInt64)timestamp.epochMicroseconds();
-                            //heartbeat(Heartbeat(last_event_timestamp, std::move(hashmap)));
+                            return { getHeader(), true };
                         }
                     }
                 }
@@ -181,6 +186,7 @@ protected:
 
         if (it == end)
         {
+            end_of_blocks = false;
             if (length > 0)
                 --length;
         }
@@ -204,6 +210,7 @@ private:
     Poco::FastMutex & mutex;
     /// Length specifies number of updates to send, default -1 (no limit)
     int64_t length;
+    bool end_of_blocks{0};
     UInt64 heartbeat_delay;
     String blocks_hash;
     UInt64 last_event_timestamp{0};
diff --git a/dbms/src/DataStreams/LiveViewEventsBlockInputStream.h b/dbms/src/DataStreams/LiveViewEventsBlockInputStream.h
index d9fdda97d21..32290c3333b 100644
--- a/dbms/src/DataStreams/LiveViewEventsBlockInputStream.h
+++ b/dbms/src/DataStreams/LiveViewEventsBlockInputStream.h
@@ -17,6 +17,8 @@ limitations under the License. */
 #include <Poco/Condition.h>
 #include <DataTypes/DataTypesNumber.h>
 #include <DataTypes/DataTypeString.h>
+#include <Columns/ColumnString.h>
+#include <Columns/ColumnsNumber.h>
 #include <DataStreams/OneBlockInputStream.h>
 #include <DataStreams/IBlockInputStream.h>
 #include <Storages/StorageLiveView.h>
@@ -62,7 +64,18 @@ public:
         condition.broadcast();
     }
 
-    Block getHeader() const override { return storage.getHeader(); }
+    Block getHeader() const override {
+        return {
+            ColumnWithTypeAndName(
+                ColumnUInt64::create(),
+                std::make_shared<DataTypeUInt64>(),
+                "version"),
+            ColumnWithTypeAndName(
+                ColumnString::create(),
+                std::make_shared<DataTypeString>(),
+                "hash")
+        };
+    }
 
     void refresh()
     {
@@ -94,6 +107,21 @@ public:
         return tryRead_(false);
     }
 
+    Block getEventBlock()
+    {
+        Block res{
+            ColumnWithTypeAndName(
+                DataTypeUInt64().createColumnConst(1, blocks_metadata->version)->convertToFullColumnIfConst(),
+                std::make_shared<DataTypeUInt64>(),
+                "version"),
+            ColumnWithTypeAndName(
+                DataTypeString().createColumnConst(1, blocks_metadata->hash)->convertToFullColumnIfConst(),
+                std::make_shared<DataTypeString>(),
+                "hash"),
+
+        };
+        return res;
+    }
 protected:
     Block readImpl() override
     {
@@ -153,6 +181,11 @@ protected:
                     {
                         return { Block(), false };
                     }
+                    if (!end_of_blocks)
+                    {
+                        end_of_blocks = true;
+                        return { getHeader(), true };
+                    }
                     while (true)
                     {
                         bool signaled = condition.tryWait(mutex, std::max((UInt64)0, heartbeat_delay - ((UInt64)timestamp.epochMicroseconds() - last_event_timestamp)) / 1000);
@@ -167,10 +200,9 @@ protected:
                         }
                         else
                         {
-                            // return Block(version, hash)
-                            //hashmap["blocks"] = blocks_hash;
+                            // repeat the event block as a heartbeat
                             last_event_timestamp = (UInt64)timestamp.epochMicroseconds();
-                            //heartbeat(Heartbeat(last_event_timestamp, std::move(hashmap)));
+                            return { getHeader(), true };
                         }
                     }
                 }
@@ -183,25 +215,14 @@ protected:
 
         if (it == end)
         {
+            end_of_blocks = false;
             if (length > 0)
                 --length;
         }
 
         last_event_timestamp = (UInt64)timestamp.epochMicroseconds();
 
-        Block res{
-            ColumnWithTypeAndName(
-                DataTypeUInt64().createColumnConst(1, blocks_metadata->version)->convertToFullColumnIfConst(),
-                std::make_shared<DataTypeUInt64>(),
-                "version"),
-            ColumnWithTypeAndName(
-                DataTypeString().createColumnConst(1, blocks_metadata->hash)->convertToFullColumnIfConst(),
-                std::make_shared<DataTypeString>(),
-                "hash"),
-
-        };
-
-        return { res, true };
+        return { getEventBlock(), true };
     }
 
 private:
@@ -219,6 +240,7 @@ private:
     Poco::FastMutex & mutex;
     /// Length specifies number of updates to send, default -1 (no limit)
     int64_t length;
+    bool end_of_blocks{0};
     UInt64 heartbeat_delay;
     UInt64 last_event_timestamp{0};
     Poco::Timestamp timestamp;
diff --git a/dbms/src/DataStreams/PushingToViewsBlockOutputStream.cpp b/dbms/src/DataStreams/PushingToViewsBlockOutputStream.cpp
index c826835b007..06f9a1edacf 100644
--- a/dbms/src/DataStreams/PushingToViewsBlockOutputStream.cpp
+++ b/dbms/src/DataStreams/PushingToViewsBlockOutputStream.cpp
@@ -86,7 +86,7 @@ void PushingToViewsBlockOutputStream::write(const Block & block)
 
     if (auto * live_view = dynamic_cast<StorageLiveView *>(storage.get()))
     {
-        BlockOutputStreamPtr output = storage->write(query_ptr, context);
+        BlockOutputStreamPtr output = std::make_shared<LiveViewBlockOutputStream>(*live_view);
         StorageLiveView::writeIntoLiveView(*live_view, block, context, output);
     }
     else
diff --git a/dbms/src/DataStreams/copyData.cpp b/dbms/src/DataStreams/copyData.cpp
index 9d17596fc8d..5000c87be7c 100644
--- a/dbms/src/DataStreams/copyData.cpp
+++ b/dbms/src/DataStreams/copyData.cpp
@@ -28,6 +28,8 @@ void copyDataImpl(IBlockInputStream & from, IBlockOutputStream & to, TCancelCall
             break;
 
         to.write(block);
+        if (!block.rows())
+            to.flush();
         progress(block);
     }
 
diff --git a/dbms/src/IO/WriteBufferValidUTF8.cpp b/dbms/src/IO/WriteBufferValidUTF8.cpp
index 01e011982cd..14d713de574 100644
--- a/dbms/src/IO/WriteBufferValidUTF8.cpp
+++ b/dbms/src/IO/WriteBufferValidUTF8.cpp
@@ -117,6 +117,9 @@ void WriteBufferValidUTF8::nextImpl()
         memory[i] = p[i];
 
     working_buffer = Buffer(&memory[cnt], memory.data() + memory.size());
+
+    /// Propagate next() to the output buffer
+    output_buffer.next();
 }
 
 
diff --git a/dbms/src/Storages/StorageLiveView.cpp b/dbms/src/Storages/StorageLiveView.cpp
index 57e4695706b..77578bc386d 100644
--- a/dbms/src/Storages/StorageLiveView.cpp
+++ b/dbms/src/Storages/StorageLiveView.cpp
@@ -448,11 +448,6 @@ BlockInputStreams StorageLiveView::watch(
     }
 }
 
-BlockOutputStreamPtr StorageLiveView::write(const ASTPtr & /*query*/, const Context & /*context*/)
-{
-    return std::make_shared<LiveViewBlockOutputStream>(*this);
-}
-
 void registerStorageLiveView(StorageFactory & factory)
 {
     factory.registerStorage("LiveView", [](const StorageFactory::Arguments & args)
diff --git a/dbms/src/Storages/StorageLiveView.h b/dbms/src/Storages/StorageLiveView.h
index d16a80ee888..bb4377fbed6 100644
--- a/dbms/src/Storages/StorageLiveView.h
+++ b/dbms/src/Storages/StorageLiveView.h
@@ -121,10 +121,6 @@ public:
 
     void refresh(const Context & context);
 
-    BlockOutputStreamPtr write(
-        const ASTPtr &,
-        const Context &) override;
-
     BlockInputStreams read(
         const Names & column_names,
         const SelectQueryInfo & query_info,
@@ -177,9 +173,11 @@ public:
             auto parent_storage = context.getTable(live_view.getSelectDatabaseName(), live_view.getSelectTableName());
             BlockInputStreams streams = {std::make_shared<OneBlockInputStream>(block)};
             auto proxy_storage = std::make_shared<ProxyStorage>(parent_storage, std::move(streams), QueryProcessingStage::FetchColumns);
-            InterpreterSelectQuery select_block(live_view.getInnerQuery(), context, proxy_storage,
-                                                QueryProcessingStage::WithMergeableState);
-            auto data_mergeable_stream = std::make_shared<MaterializingBlockInputStream>(select_block.execute().in);
+            InterpreterSelectQuery select_block(live_view.getInnerQuery(),
+                context, proxy_storage,
+                QueryProcessingStage::WithMergeableState);
+            auto data_mergeable_stream = std::make_shared<MaterializingBlockInputStream>(
+                select_block.execute().in);
             while (Block this_block = data_mergeable_stream->read())
                 new_mergeable_blocks->push_back(this_block);
         }
@@ -196,7 +194,8 @@ public:
                 mergeable_blocks = std::make_shared<std::vector<BlocksPtr>>();
                 BlocksPtr base_mergeable_blocks = std::make_shared<Blocks>();
                 InterpreterSelectQuery interpreter(live_view.getInnerQuery(), context, SelectQueryOptions(QueryProcessingStage::WithMergeableState), Names{});
-                auto view_mergeable_stream = std::make_shared<MaterializingBlockInputStream>(interpreter.execute().in);
+                auto view_mergeable_stream = std::make_shared<MaterializingBlockInputStream>(
+                    interpreter.execute().in);
                 while (Block this_block = view_mergeable_stream->read())
                     base_mergeable_blocks->push_back(this_block);
                 mergeable_blocks->push_back(base_mergeable_blocks);

From 7d69496fbbf056da254560717a5e28383a2b7052 Mon Sep 17 00:00:00 2001
From: Vitaliy Zakaznikov <vzakaznikov@protonmail.com>
Date: Wed, 5 Jun 2019 08:10:34 -0400
Subject: [PATCH 024/107] * Adding a NOTICE file to include the original header
 that   was inside some of the files.

---
 NOTICE | 41 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 41 insertions(+)
 create mode 100644 NOTICE

diff --git a/NOTICE b/NOTICE
new file mode 100644
index 00000000000..59c6923e66a
--- /dev/null
+++ b/NOTICE
@@ -0,0 +1,41 @@
+--
+The following notice shall be applied to the files listed below.
+
+Some modifications Copyright (c) 2018 BlackBerry Limited
+
+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.
+
+dbms/src/Common/ErrorCodes.cpp
+dbms/src/Common/UInt128.h
+dbms/src/Core/Block.h
+dbms/src/Core/Defines.h
+dbms/src/Core/Settings.h
+dbms/src/DataStreams/PushingToViewsBlockOutputStream.cpp
+dbms/src/DataStreams/PushingToViewsBlockOutputStream.h
+dbms/src/DataStreams/copyData.cpp
+dbms/src/Databases/DatabasesCommon.cpp
+dbms/src/IO/WriteBufferValidUTF8.cpp
+dbms/src/Interpreters/InterpreterAlterQuery.cpp
+dbms/src/Interpreters/InterpreterCreateQuery.cpp
+dbms/src/Interpreters/InterpreterFactory.cpp
+dbms/src/Parsers/ASTAlterQuery.cpp
+dbms/src/Parsers/ASTAlterQuery.h
+dbms/src/Parsers/ASTCreateQuery.cpp
+dbms/src/Parsers/ASTCreateQuery.h
+dbms/src/Parsers/ParserAlterQuery.cpp
+dbms/src/Parsers/ParserAlterQuery.h
+dbms/src/Parsers/ParserCreateQuery.cpp
+dbms/src/Parsers/ParserCreateQuery.h
+dbms/src/Parsers/ParserQueryWithOutput.cpp
+dbms/src/Storages/IStorage.h
+dbms/src/Storages/StorageFactory.cpp
+dbms/src/Storages/registerStorages.cpp
+--

From a946d09f1b73efa1d04d9287da9e340a94520ac3 Mon Sep 17 00:00:00 2001
From: Vitaliy Zakaznikov <vzakaznikov@protonmail.com>
Date: Wed, 5 Jun 2019 18:27:36 -0400
Subject: [PATCH 025/107] * Adding more LIVE VIEW tests

---
 .../00960_live_view_watch_events_live.py      | 46 +++++++++++++++++
 ...960_live_view_watch_events_live.reference} |  0
 ...00961_temporary_live_view_watch.reference} |  0
 ...ql => 00961_temporary_live_view_watch.sql} |  0
 ...> 00962_temporary_live_view_watch_live.py} |  0
 ..._temporary_live_view_watch_live.reference} |  0
 ...temporary_live_view_watch_live_timeout.py} |  0
 ...ary_live_view_watch_live_timeout.reference |  0
 .../00964_live_view_watch_events_heartbeat.py | 47 +++++++++++++++++
 ...live_view_watch_events_heartbeat.reference |  0
 .../00965_live_view_watch_heartbeat.py        | 47 +++++++++++++++++
 .../00965_live_view_watch_heartbeat.reference |  0
 .../00966_live_view_watch_events_http.py      | 51 +++++++++++++++++++
 ...0966_live_view_watch_events_http.reference |  0
 .../0_stateless/00967_live_view_watch_http.py | 51 +++++++++++++++++++
 .../00967_live_view_watch_http.reference      |  0
 dbms/tests/queries/0_stateless/uexpect.py     | 10 ++--
 17 files changed, 248 insertions(+), 4 deletions(-)
 create mode 100755 dbms/tests/queries/0_stateless/00960_live_view_watch_events_live.py
 rename dbms/tests/queries/0_stateless/{00961_temporary_live_view_watch_live.reference => 00960_live_view_watch_events_live.reference} (100%)
 rename dbms/tests/queries/0_stateless/{00960_temporary_live_view_watch.reference => 00961_temporary_live_view_watch.reference} (100%)
 rename dbms/tests/queries/0_stateless/{00960_temporary_live_view_watch.sql => 00961_temporary_live_view_watch.sql} (100%)
 rename dbms/tests/queries/0_stateless/{00961_temporary_live_view_watch_live.py => 00962_temporary_live_view_watch_live.py} (100%)
 rename dbms/tests/queries/0_stateless/{00962_temporary_live_view_watch_live_timeout.reference => 00962_temporary_live_view_watch_live.reference} (100%)
 rename dbms/tests/queries/0_stateless/{00962_temporary_live_view_watch_live_timeout.py => 00963_temporary_live_view_watch_live_timeout.py} (100%)
 create mode 100644 dbms/tests/queries/0_stateless/00963_temporary_live_view_watch_live_timeout.reference
 create mode 100755 dbms/tests/queries/0_stateless/00964_live_view_watch_events_heartbeat.py
 create mode 100644 dbms/tests/queries/0_stateless/00964_live_view_watch_events_heartbeat.reference
 create mode 100755 dbms/tests/queries/0_stateless/00965_live_view_watch_heartbeat.py
 create mode 100644 dbms/tests/queries/0_stateless/00965_live_view_watch_heartbeat.reference
 create mode 100755 dbms/tests/queries/0_stateless/00966_live_view_watch_events_http.py
 create mode 100644 dbms/tests/queries/0_stateless/00966_live_view_watch_events_http.reference
 create mode 100755 dbms/tests/queries/0_stateless/00967_live_view_watch_http.py
 create mode 100644 dbms/tests/queries/0_stateless/00967_live_view_watch_http.reference

diff --git a/dbms/tests/queries/0_stateless/00960_live_view_watch_events_live.py b/dbms/tests/queries/0_stateless/00960_live_view_watch_events_live.py
new file mode 100755
index 00000000000..fa96331e3fb
--- /dev/null
+++ b/dbms/tests/queries/0_stateless/00960_live_view_watch_events_live.py
@@ -0,0 +1,46 @@
+#!/usr/bin/env python
+import imp
+import os
+import sys
+import signal
+
+CURDIR = os.path.dirname(os.path.realpath(__file__))
+
+uexpect = imp.load_source('uexpect', os.path.join(CURDIR, 'uexpect.py'))
+
+def client(name=''):
+    client = uexpect.spawn(os.environ.get('CLICKHOUSE_CLIENT'))
+    client.eol('\r')
+    # Note: uncomment this line for debugging
+    #client.logger(sys.stdout, prefix=name)
+    client.timeout(2)
+    return client
+
+prompt = ':\) '
+end_of_block = r'.*\xe2\x94\x82\r\n.*\xe2\x94\x98\r\n'
+client1 = client('client1>')
+client2 = client('client2>')
+
+client1.expect(prompt)
+client2.expect(prompt)
+
+client1.send('DROP TABLE IF EXISTS test.lv')
+client1.expect(prompt)
+client1.send(' DROP TABLE IF EXISTS test.mt')
+client1.expect(prompt)
+client1.send('CREATE TABLE test.mt (a Int32) Engine=MergeTree order by tuple()')
+client1.expect(prompt)
+client1.send('CREATE LIVE VIEW test.lv AS SELECT sum(a) FROM test.mt')
+client1.expect(prompt)
+client1.send('WATCH test.lv EVENTS')
+client2.send('INSERT INTO test.mt VALUES (1),(2),(3)')
+client1.expect('2.*4cd0592103888d4682de9a32a23602e3' + end_of_block)
+client2.send('INSERT INTO test.mt VALUES (4),(5),(6)')
+client1.expect('3.*2186dbea325ee4c56b67e9b792e993a3' + end_of_block)
+# send Ctrl-C
+os.kill(client1.process.pid,signal.SIGINT)
+client1.expect(prompt)
+client1.send('DROP TABLE test.lv')
+client1.expect(prompt)
+client1.send('DROP TABLE test.mt')
+client1.expect(prompt)
diff --git a/dbms/tests/queries/0_stateless/00961_temporary_live_view_watch_live.reference b/dbms/tests/queries/0_stateless/00960_live_view_watch_events_live.reference
similarity index 100%
rename from dbms/tests/queries/0_stateless/00961_temporary_live_view_watch_live.reference
rename to dbms/tests/queries/0_stateless/00960_live_view_watch_events_live.reference
diff --git a/dbms/tests/queries/0_stateless/00960_temporary_live_view_watch.reference b/dbms/tests/queries/0_stateless/00961_temporary_live_view_watch.reference
similarity index 100%
rename from dbms/tests/queries/0_stateless/00960_temporary_live_view_watch.reference
rename to dbms/tests/queries/0_stateless/00961_temporary_live_view_watch.reference
diff --git a/dbms/tests/queries/0_stateless/00960_temporary_live_view_watch.sql b/dbms/tests/queries/0_stateless/00961_temporary_live_view_watch.sql
similarity index 100%
rename from dbms/tests/queries/0_stateless/00960_temporary_live_view_watch.sql
rename to dbms/tests/queries/0_stateless/00961_temporary_live_view_watch.sql
diff --git a/dbms/tests/queries/0_stateless/00961_temporary_live_view_watch_live.py b/dbms/tests/queries/0_stateless/00962_temporary_live_view_watch_live.py
similarity index 100%
rename from dbms/tests/queries/0_stateless/00961_temporary_live_view_watch_live.py
rename to dbms/tests/queries/0_stateless/00962_temporary_live_view_watch_live.py
diff --git a/dbms/tests/queries/0_stateless/00962_temporary_live_view_watch_live_timeout.reference b/dbms/tests/queries/0_stateless/00962_temporary_live_view_watch_live.reference
similarity index 100%
rename from dbms/tests/queries/0_stateless/00962_temporary_live_view_watch_live_timeout.reference
rename to dbms/tests/queries/0_stateless/00962_temporary_live_view_watch_live.reference
diff --git a/dbms/tests/queries/0_stateless/00962_temporary_live_view_watch_live_timeout.py b/dbms/tests/queries/0_stateless/00963_temporary_live_view_watch_live_timeout.py
similarity index 100%
rename from dbms/tests/queries/0_stateless/00962_temporary_live_view_watch_live_timeout.py
rename to dbms/tests/queries/0_stateless/00963_temporary_live_view_watch_live_timeout.py
diff --git a/dbms/tests/queries/0_stateless/00963_temporary_live_view_watch_live_timeout.reference b/dbms/tests/queries/0_stateless/00963_temporary_live_view_watch_live_timeout.reference
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/dbms/tests/queries/0_stateless/00964_live_view_watch_events_heartbeat.py b/dbms/tests/queries/0_stateless/00964_live_view_watch_events_heartbeat.py
new file mode 100755
index 00000000000..9d4f1d0716c
--- /dev/null
+++ b/dbms/tests/queries/0_stateless/00964_live_view_watch_events_heartbeat.py
@@ -0,0 +1,47 @@
+#!/usr/bin/env python
+import imp
+import os
+import sys
+import signal
+
+CURDIR = os.path.dirname(os.path.realpath(__file__))
+
+uexpect = imp.load_source('uexpect', os.path.join(CURDIR, 'uexpect.py'))
+
+def client(name=''):
+    client = uexpect.spawn(os.environ.get('CLICKHOUSE_CLIENT'))
+    client.eol('\r')
+    # Note: uncomment this line for debugging
+    #client.logger(sys.stdout, prefix=name)
+    client.timeout(2)
+    return client
+
+prompt = ':\) '
+end_of_block = r'.*\xe2\x94\x82\r\n.*\xe2\x94\x98\r\n'
+client1 = client('client1>')
+client2 = client('client2>')
+
+client1.expect(prompt)
+client2.expect(prompt)
+
+client1.send('DROP TABLE IF EXISTS test.lv')
+client1.expect(prompt)
+client1.send(' DROP TABLE IF EXISTS test.mt')
+client1.expect(prompt)
+client1.send('CREATE TABLE test.mt (a Int32) Engine=MergeTree order by tuple()')
+client1.expect(prompt)
+client1.send('CREATE TEMPORARY LIVE VIEW test.lv AS SELECT sum(a) FROM test.mt')
+client1.expect(prompt)
+client1.send('WATCH test.lv EVENTS')
+client2.send('INSERT INTO test.mt VALUES (1),(2),(3)')
+client1.expect('2.*4cd0592103888d4682de9a32a23602e3' + end_of_block)
+client1.expect('Progress: 2.00 rows.*\)')
+# wait for heartbeat
+client1.expect('Progress: 2.00 rows.*\)', timeout=15)
+# send Ctrl-C
+os.kill(client1.process.pid,signal.SIGINT)
+client1.expect(prompt)
+client1.send('DROP TABLE test.lv')
+client1.expect(prompt)
+client1.send('DROP TABLE test.mt')
+client1.expect(prompt)
diff --git a/dbms/tests/queries/0_stateless/00964_live_view_watch_events_heartbeat.reference b/dbms/tests/queries/0_stateless/00964_live_view_watch_events_heartbeat.reference
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/dbms/tests/queries/0_stateless/00965_live_view_watch_heartbeat.py b/dbms/tests/queries/0_stateless/00965_live_view_watch_heartbeat.py
new file mode 100755
index 00000000000..cafbcd833b1
--- /dev/null
+++ b/dbms/tests/queries/0_stateless/00965_live_view_watch_heartbeat.py
@@ -0,0 +1,47 @@
+#!/usr/bin/env python
+import imp
+import os
+import sys
+import signal
+
+CURDIR = os.path.dirname(os.path.realpath(__file__))
+
+uexpect = imp.load_source('uexpect', os.path.join(CURDIR, 'uexpect.py'))
+
+def client(name=''):
+    client = uexpect.spawn(os.environ.get('CLICKHOUSE_CLIENT'))
+    client.eol('\r')
+    # Note: uncomment this line for debugging
+    #client.logger(sys.stdout, prefix=name)
+    client.timeout(2)
+    return client
+
+prompt = ':\) '
+end_of_block = r'.*\xe2\x94\x82\r\n.*\xe2\x94\x98\r\n'
+client1 = client('client1>')
+client2 = client('client2>')
+
+client1.expect(prompt)
+client2.expect(prompt)
+
+client1.send('DROP TABLE IF EXISTS test.lv')
+client1.expect(prompt)
+client1.send(' DROP TABLE IF EXISTS test.mt')
+client1.expect(prompt)
+client1.send('CREATE TABLE test.mt (a Int32) Engine=MergeTree order by tuple()')
+client1.expect(prompt)
+client1.send('CREATE TEMPORARY LIVE VIEW test.lv AS SELECT sum(a) FROM test.mt')
+client1.expect(prompt)
+client1.send('WATCH test.lv')
+client2.send('INSERT INTO test.mt VALUES (1),(2),(3)')
+client1.expect(r'6.*2' + end_of_block)
+client1.expect('Progress: 2.00 rows.*\)')
+# wait for heartbeat
+client1.expect('Progress: 2.00 rows.*\)', timeout=15)
+# send Ctrl-C
+os.kill(client1.process.pid,signal.SIGINT)
+client1.expect(prompt)
+client1.send('DROP TABLE test.lv')
+client1.expect(prompt)
+client1.send('DROP TABLE test.mt')
+client1.expect(prompt)
diff --git a/dbms/tests/queries/0_stateless/00965_live_view_watch_heartbeat.reference b/dbms/tests/queries/0_stateless/00965_live_view_watch_heartbeat.reference
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/dbms/tests/queries/0_stateless/00966_live_view_watch_events_http.py b/dbms/tests/queries/0_stateless/00966_live_view_watch_events_http.py
new file mode 100755
index 00000000000..be1cd220679
--- /dev/null
+++ b/dbms/tests/queries/0_stateless/00966_live_view_watch_events_http.py
@@ -0,0 +1,51 @@
+#!/usr/bin/env python
+import imp
+import os
+import sys
+import signal
+
+CURDIR = os.path.dirname(os.path.realpath(__file__))
+
+uexpect = imp.load_source('uexpect', os.path.join(CURDIR, 'uexpect.py'))
+
+def client(name='', command=None):
+    if command is None:
+        client = uexpect.spawn(os.environ.get('CLICKHOUSE_CLIENT'))
+    else:
+        client = uexpect.spawn(command)
+    client.eol('\r')
+    # Note: uncomment this line for debugging
+    #client.logger(sys.stdout, prefix=name)
+    client.timeout(2)
+    return client
+
+prompt = ':\) '
+end_of_block = r'.*\xe2\x94\x82\r\n.*\xe2\x94\x98\r\n'
+client1 = client('client1>')
+client1.expect(prompt)
+
+client1.send('DROP TABLE IF EXISTS test.lv')
+client1.expect(prompt)
+client1.send(' DROP TABLE IF EXISTS test.mt')
+client1.expect(prompt)
+client1.send('CREATE TABLE test.mt (a Int32) Engine=MergeTree order by tuple()')
+client1.expect(prompt)
+client1.send('CREATE LIVE VIEW test.lv AS SELECT sum(a) FROM test.mt')
+client1.expect(prompt)
+
+client2 = client('client2>', ['bash', '--noediting'])
+client2.expect('\$ ')
+client2.send('wget -O- -q "http://localhost:8123/?query=WATCH test.lv EVENTS"')
+client2.expect('.*1\tc9d39b11cce79112219a73aaa319b475\r\n')
+
+client1.send('INSERT INTO test.mt VALUES (1),(2),(3)')
+client1.expect(prompt)
+
+client2.expect('.*2\t.*\r\n')
+## send Ctrl-C
+os.kill(client2.process.pid,signal.SIGINT)
+
+client1.send('DROP TABLE test.lv')
+client1.expect(prompt)
+client1.send('DROP TABLE test.mt')
+client1.expect(prompt)
diff --git a/dbms/tests/queries/0_stateless/00966_live_view_watch_events_http.reference b/dbms/tests/queries/0_stateless/00966_live_view_watch_events_http.reference
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/dbms/tests/queries/0_stateless/00967_live_view_watch_http.py b/dbms/tests/queries/0_stateless/00967_live_view_watch_http.py
new file mode 100755
index 00000000000..0a844579f5d
--- /dev/null
+++ b/dbms/tests/queries/0_stateless/00967_live_view_watch_http.py
@@ -0,0 +1,51 @@
+#!/usr/bin/env python
+import imp
+import os
+import sys
+import signal
+
+CURDIR = os.path.dirname(os.path.realpath(__file__))
+
+uexpect = imp.load_source('uexpect', os.path.join(CURDIR, 'uexpect.py'))
+
+def client(name='', command=None):
+    if command is None:
+        client = uexpect.spawn(os.environ.get('CLICKHOUSE_CLIENT'))
+    else:
+        client = uexpect.spawn(command)
+    client.eol('\r')
+    # Note: uncomment this line for debugging
+    #client.logger(sys.stdout, prefix=name)
+    client.timeout(2)
+    return client
+
+prompt = ':\) '
+end_of_block = r'.*\xe2\x94\x82\r\n.*\xe2\x94\x98\r\n'
+client1 = client('client1>')
+client1.expect(prompt)
+
+client1.send('DROP TABLE IF EXISTS test.lv')
+client1.expect(prompt)
+client1.send(' DROP TABLE IF EXISTS test.mt')
+client1.expect(prompt)
+client1.send('CREATE TABLE test.mt (a Int32) Engine=MergeTree order by tuple()')
+client1.expect(prompt)
+client1.send('CREATE LIVE VIEW test.lv AS SELECT sum(a) FROM test.mt')
+client1.expect(prompt)
+
+client2 = client('client2>', ['bash', '--noediting'])
+client2.expect('\$ ')
+client2.send('wget -O- -q "http://localhost:8123/?query=WATCH test.lv"')
+client2.expect('.*0\t1\r\n')
+
+client1.send('INSERT INTO test.mt VALUES (1),(2),(3)')
+client1.expect(prompt)
+
+client2.expect('.*6\t2\r\n')
+## send Ctrl-C
+os.kill(client2.process.pid,signal.SIGINT)
+
+client1.send('DROP TABLE test.lv')
+client1.expect(prompt)
+client1.send('DROP TABLE test.mt')
+client1.expect(prompt)
diff --git a/dbms/tests/queries/0_stateless/00967_live_view_watch_http.reference b/dbms/tests/queries/0_stateless/00967_live_view_watch_http.reference
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/dbms/tests/queries/0_stateless/uexpect.py b/dbms/tests/queries/0_stateless/uexpect.py
index 0b57890b593..412facb8389 100644
--- a/dbms/tests/queries/0_stateless/uexpect.py
+++ b/dbms/tests/queries/0_stateless/uexpect.py
@@ -102,10 +102,12 @@ class IO(object):
     def write(self, data):
         return os.write(self.master, data)
 
-    def expect(self, pattern, timeout=None):
+    def expect(self, pattern, timeout=None, escape=False):
         self.match = None
         self.before = None
         self.after = None
+        if escape:
+            pattern = re.escape(pattern)
         pattern = re.compile(pattern)
         if timeout is None:
             timeout = self._timeout
@@ -151,7 +153,7 @@ class IO(object):
             pass
         return data
 
-def spawn(*command):
+def spawn(command):
     master, slave = pty.openpty()
     process = Popen(command, preexec_fn=os.setsid, stdout=slave, stdin=slave, stderr=slave, bufsize=1)
     os.close(slave)
@@ -169,7 +171,7 @@ def reader(out, queue):
         queue.put(data)
 
 if __name__ == '__main__':
-   io = spawn('/bin/bash')
+   io = spawn(['/bin/bash','--noediting'])
    prompt = '\$ '
    io.logger(sys.stdout)
    io.timeout(2)
@@ -182,6 +184,6 @@ if __name__ == '__main__':
    io.send('SELECT 1')
    io.expect(prompt)
    io.send('SHOW TABLES')
-   io.expect('test')
+   io.expect('.*\r\n.*')
    io.expect(prompt)
    io.close()

From e51f2c1dd189159a48f733884e4c155b80c7f0e9 Mon Sep 17 00:00:00 2001
From: Vitaliy Zakaznikov <vzakaznikov@protonmail.com>
Date: Wed, 5 Jun 2019 18:52:31 -0400
Subject: [PATCH 026/107] Revert "Merge branch 'master' of
 https://github.com/vzakaznikov/ClickHouse into liveview"

This reverts commit 160ff4d519cdebf3816694534e19a47485193f24, reversing
changes made to a946d09f1b73efa1d04d9287da9e340a94520ac3.
---
 .gitmodules                                   |    9 +
 contrib/googletest                            |    1 +
 .../boost/archive/archive_exception.hpp       |  100 -
 .../boost/archive/basic_archive.hpp           |  304 ---
 .../boost/archive/basic_binary_iarchive.hpp   |  204 --
 .../boost/archive/basic_binary_iprimitive.hpp |  198 --
 .../boost/archive/basic_binary_oarchive.hpp   |  185 --
 .../boost/archive/basic_binary_oprimitive.hpp |  188 --
 .../archive/basic_streambuf_locale_saver.hpp  |  108 --
 .../boost/archive/basic_text_iarchive.hpp     |   96 -
 .../boost/archive/basic_text_iprimitive.hpp   |  142 --
 .../boost/archive/basic_text_oarchive.hpp     |  119 --
 .../boost/archive/basic_text_oprimitive.hpp   |  209 --
 .../boost/archive/basic_xml_archive.hpp       |   67 -
 .../boost/archive/basic_xml_iarchive.hpp      |  119 --
 .../boost/archive/basic_xml_oarchive.hpp      |  138 --
 .../boost/archive/binary_iarchive.hpp         |   64 -
 .../boost/archive/binary_iarchive_impl.hpp    |  105 -
 .../boost/archive/binary_oarchive.hpp         |   64 -
 .../boost/archive/binary_oarchive_impl.hpp    |  106 -
 .../boost/archive/binary_wiarchive.hpp        |   56 -
 .../boost/archive/binary_woarchive.hpp        |   59 -
 .../boost/archive/codecvt_null.hpp            |  109 --
 .../boost/archive/detail/abi_prefix.hpp       |   16 -
 .../boost/archive/detail/abi_suffix.hpp       |   15 -
 .../archive/detail/archive_serializer_map.hpp |   54 -
 .../archive/detail/auto_link_archive.hpp      |   48 -
 .../archive/detail/auto_link_warchive.hpp     |   47 -
 .../boost/archive/detail/basic_iarchive.hpp   |  105 -
 .../archive/detail/basic_iserializer.hpp      |   91 -
 .../boost/archive/detail/basic_oarchive.hpp   |   94 -
 .../archive/detail/basic_oserializer.hpp      |   89 -
 .../detail/basic_pointer_iserializer.hpp      |   70 -
 .../detail/basic_pointer_oserializer.hpp      |   68 -
 .../boost/archive/detail/basic_serializer.hpp |   77 -
 .../archive/detail/basic_serializer_map.hpp   |   69 -
 .../boost/archive/detail/check.hpp            |  169 --
 .../boost/archive/detail/common_iarchive.hpp  |   88 -
 .../boost/archive/detail/common_oarchive.hpp  |   88 -
 .../boost/archive/detail/decl.hpp             |   57 -
 .../archive/detail/helper_collection.hpp      |   99 -
 .../archive/detail/interface_iarchive.hpp     |   85 -
 .../archive/detail/interface_oarchive.hpp     |   87 -
 .../boost/archive/detail/iserializer.hpp      |  631 ------
 .../boost/archive/detail/oserializer.hpp      |  540 ------
 .../detail/polymorphic_iarchive_route.hpp     |  218 ---
 .../detail/polymorphic_oarchive_route.hpp     |  209 --
 .../boost/archive/detail/register_archive.hpp |   91 -
 .../archive/detail/utf8_codecvt_facet.hpp     |   39 -
 .../boost_1_65_0/boost/archive/dinkumware.hpp |  224 ---
 .../archive/impl/archive_serializer_map.ipp   |   75 -
 .../archive/impl/basic_binary_iarchive.ipp    |  134 --
 .../archive/impl/basic_binary_iprimitive.ipp  |  171 --
 .../archive/impl/basic_binary_oarchive.ipp    |   42 -
 .../archive/impl/basic_binary_oprimitive.ipp  |  126 --
 .../archive/impl/basic_text_iarchive.ipp      |   76 -
 .../archive/impl/basic_text_iprimitive.ipp    |  137 --
 .../archive/impl/basic_text_oarchive.ipp      |   62 -
 .../archive/impl/basic_text_oprimitive.ipp    |  115 --
 .../boost/archive/impl/basic_xml_grammar.hpp  |  173 --
 .../boost/archive/impl/basic_xml_iarchive.ipp |  115 --
 .../boost/archive/impl/basic_xml_oarchive.ipp |  272 ---
 .../boost/archive/impl/text_iarchive_impl.ipp |  128 --
 .../boost/archive/impl/text_oarchive_impl.ipp |  122 --
 .../archive/impl/text_wiarchive_impl.ipp      |  118 --
 .../archive/impl/text_woarchive_impl.ipp      |   85 -
 .../boost/archive/impl/xml_iarchive_impl.ipp  |  199 --
 .../boost/archive/impl/xml_oarchive_impl.ipp  |  142 --
 .../boost/archive/impl/xml_wiarchive_impl.ipp |  189 --
 .../boost/archive/impl/xml_woarchive_impl.ipp |  171 --
 .../archive/iterators/base64_exception.hpp    |   68 -
 .../archive/iterators/base64_from_binary.hpp  |  109 --
 .../archive/iterators/binary_from_base64.hpp  |  118 --
 .../boost/archive/iterators/dataflow.hpp      |  102 -
 .../archive/iterators/dataflow_exception.hpp  |   80 -
 .../boost/archive/iterators/escape.hpp        |  115 --
 .../archive/iterators/insert_linebreaks.hpp   |   99 -
 .../archive/iterators/istream_iterator.hpp    |   92 -
 .../boost/archive/iterators/mb_from_wchar.hpp |  139 --
 .../archive/iterators/ostream_iterator.hpp    |   83 -
 .../archive/iterators/remove_whitespace.hpp   |  167 --
 .../archive/iterators/transform_width.hpp     |  177 --
 .../boost/archive/iterators/unescape.hpp      |   89 -
 .../boost/archive/iterators/wchar_from_mb.hpp |  194 --
 .../boost/archive/iterators/xml_escape.hpp    |  121 --
 .../boost/archive/iterators/xml_unescape.hpp  |  125 --
 .../iterators/xml_unescape_exception.hpp      |   49 -
 .../archive/polymorphic_binary_iarchive.hpp   |   54 -
 .../archive/polymorphic_binary_oarchive.hpp   |   43 -
 .../boost/archive/polymorphic_iarchive.hpp    |  168 --
 .../boost/archive/polymorphic_oarchive.hpp    |  154 --
 .../archive/polymorphic_text_iarchive.hpp     |   54 -
 .../archive/polymorphic_text_oarchive.hpp     |   39 -
 .../archive/polymorphic_text_wiarchive.hpp    |   59 -
 .../archive/polymorphic_text_woarchive.hpp    |   44 -
 .../archive/polymorphic_xml_iarchive.hpp      |   54 -
 .../archive/polymorphic_xml_oarchive.hpp      |   39 -
 .../archive/polymorphic_xml_wiarchive.hpp     |   50 -
 .../archive/polymorphic_xml_woarchive.hpp     |   44 -
 .../boost/archive/text_iarchive.hpp           |  132 --
 .../boost/archive/text_oarchive.hpp           |  121 --
 .../boost/archive/text_wiarchive.hpp          |  137 --
 .../boost/archive/text_woarchive.hpp          |  155 --
 .../boost_1_65_0/boost/archive/tmpdir.hpp     |   50 -
 .../boost_1_65_0/boost/archive/wcslen.hpp     |   58 -
 .../boost/archive/xml_archive_exception.hpp   |   57 -
 .../boost/archive/xml_iarchive.hpp            |  142 --
 .../boost/archive/xml_oarchive.hpp            |  137 --
 .../boost/archive/xml_wiarchive.hpp           |  149 --
 .../boost/archive/xml_woarchive.hpp           |  134 --
 .../boost_1_65_0/boost/foreach_fwd.hpp        |   51 -
 .../boost/multi_index/composite_key.hpp       | 1513 ---------------
 .../multi_index/detail/access_specifier.hpp   |   54 -
 .../boost/multi_index/detail/adl_swap.hpp     |   44 -
 .../detail/archive_constructed.hpp            |   83 -
 .../boost/multi_index/detail/auto_space.hpp   |   91 -
 .../boost/multi_index/detail/base_type.hpp    |   74 -
 .../detail/bidir_node_iterator.hpp            |  114 --
 .../boost/multi_index/detail/bucket_array.hpp |  243 ---
 .../multi_index/detail/cons_stdtuple.hpp      |   93 -
 .../boost/multi_index/detail/converter.hpp    |   52 -
 .../boost/multi_index/detail/copy_map.hpp     |  142 --
 .../detail/do_not_copy_elements_tag.hpp       |   34 -
 .../detail/duplicates_iterator.hpp            |  120 --
 .../boost/multi_index/detail/has_tag.hpp      |   42 -
 .../multi_index/detail/hash_index_args.hpp    |  105 -
 .../detail/hash_index_iterator.hpp            |  166 --
 .../multi_index/detail/hash_index_node.hpp    |  778 --------
 .../multi_index/detail/header_holder.hpp      |   50 -
 .../detail/ignore_wstrict_aliasing.hpp        |   18 -
 .../boost/multi_index/detail/index_base.hpp   |  293 ---
 .../boost/multi_index/detail/index_loader.hpp |  139 --
 .../multi_index/detail/index_matcher.hpp      |  249 ---
 .../multi_index/detail/index_node_base.hpp    |  135 --
 .../boost/multi_index/detail/index_saver.hpp  |  135 --
 .../multi_index/detail/invariant_assert.hpp   |   21 -
 .../multi_index/detail/is_index_list.hpp      |   40 -
 .../multi_index/detail/is_transparent.hpp     |  135 --
 .../boost/multi_index/detail/iter_adaptor.hpp |  321 ---
 .../multi_index/detail/modify_key_adaptor.hpp |   49 -
 .../multi_index/detail/no_duplicate_tags.hpp  |   97 -
 .../boost/multi_index/detail/node_type.hpp    |   66 -
 .../multi_index/detail/ord_index_args.hpp     |   83 -
 .../multi_index/detail/ord_index_impl.hpp     | 1567 ---------------
 .../multi_index/detail/ord_index_impl_fwd.hpp |  128 --
 .../multi_index/detail/ord_index_node.hpp     |  658 -------
 .../multi_index/detail/ord_index_ops.hpp      |  266 ---
 .../boost/multi_index/detail/promotes_arg.hpp |   83 -
 .../boost/multi_index/detail/raw_ptr.hpp      |   52 -
 .../detail/restore_wstrict_aliasing.hpp       |   11 -
 .../multi_index/detail/rnd_index_loader.hpp   |  173 --
 .../multi_index/detail/rnd_index_node.hpp     |  273 ---
 .../multi_index/detail/rnd_index_ops.hpp      |  203 --
 .../detail/rnd_index_ptr_array.hpp            |  144 --
 .../multi_index/detail/rnd_node_iterator.hpp  |  140 --
 .../multi_index/detail/rnk_index_ops.hpp      |  300 ---
 .../boost/multi_index/detail/safe_mode.hpp    |  588 ------
 .../boost/multi_index/detail/scope_guard.hpp  |  453 -----
 .../multi_index/detail/seq_index_node.hpp     |  217 ---
 .../multi_index/detail/seq_index_ops.hpp      |  203 --
 .../detail/serialization_version.hpp          |   73 -
 .../boost/multi_index/detail/uintptr_type.hpp |   76 -
 .../boost/multi_index/detail/unbounded.hpp    |   66 -
 .../multi_index/detail/value_compare.hpp      |   56 -
 .../multi_index/detail/vartempl_support.hpp   |  247 ---
 .../boost/multi_index/global_fun.hpp          |  185 --
 .../boost/multi_index/hashed_index.hpp        | 1725 -----------------
 .../boost/multi_index/hashed_index_fwd.hpp    |   74 -
 .../boost/multi_index/identity.hpp            |  145 --
 .../boost/multi_index/identity_fwd.hpp        |   26 -
 .../boost/multi_index/indexed_by.hpp          |   68 -
 .../boost/multi_index/key_extractors.hpp      |   22 -
 .../boost/multi_index/mem_fun.hpp             |  205 --
 .../boost_1_65_0/boost/multi_index/member.hpp |  262 ---
 .../boost/multi_index/ordered_index.hpp       |  114 --
 .../boost/multi_index/ordered_index_fwd.hpp   |   35 -
 .../boost/multi_index/random_access_index.hpp | 1167 -----------
 .../multi_index/random_access_index_fwd.hpp   |   91 -
 .../boost/multi_index/ranked_index.hpp        |  382 ----
 .../boost/multi_index/ranked_index_fwd.hpp    |   35 -
 .../boost/multi_index/safe_mode_errors.hpp    |   48 -
 .../boost/multi_index/sequenced_index.hpp     | 1062 ----------
 .../boost/multi_index/sequenced_index_fwd.hpp |   91 -
 .../boost_1_65_0/boost/multi_index/tag.hpp    |   88 -
 .../boost/multi_index_container.hpp           | 1362 -------------
 .../boost/multi_index_container_fwd.hpp       |  121 --
 .../boost/serialization/access.hpp            |  145 --
 .../archive_input_unordered_map.hpp           |   85 -
 .../archive_input_unordered_set.hpp           |   72 -
 .../boost/serialization/array.hpp             |   48 -
 .../serialization/array_optimization.hpp      |   37 -
 .../boost/serialization/array_wrapper.hpp     |  121 --
 .../boost/serialization/assume_abstract.hpp   |   60 -
 .../boost/serialization/base_object.hpp       |  100 -
 .../boost/serialization/binary_object.hpp     |   79 -
 .../boost/serialization/bitset.hpp            |   75 -
 .../boost/serialization/boost_array.hpp       |   33 -
 .../serialization/boost_unordered_map.hpp     |  154 --
 .../serialization/boost_unordered_set.hpp     |  150 --
 .../serialization/collection_size_type.hpp    |   62 -
 .../boost/serialization/collection_traits.hpp |   79 -
 .../serialization/collections_load_imp.hpp    |  106 -
 .../serialization/collections_save_imp.hpp    |   82 -
 .../boost/serialization/complex.hpp           |   81 -
 .../boost/serialization/config.hpp            |   74 -
 .../boost/serialization/deque.hpp             |   80 -
 .../detail/is_default_constructible.hpp       |   54 -
 .../serialization/detail/shared_count_132.hpp |  551 ------
 .../serialization/detail/shared_ptr_132.hpp   |  443 -----
 .../detail/shared_ptr_nmt_132.hpp             |  182 --
 .../detail/stack_constructor.hpp              |   66 -
 .../boost/serialization/ephemeral.hpp         |   72 -
 .../boost/serialization/export.hpp            |  225 ---
 .../serialization/extended_type_info.hpp      |  116 --
 .../extended_type_info_no_rtti.hpp            |  182 --
 .../extended_type_info_typeid.hpp             |  167 --
 .../boost/serialization/factory.hpp           |  102 -
 .../boost/serialization/force_include.hpp     |   55 -
 .../boost/serialization/forward_list.hpp      |  124 --
 .../hash_collections_load_imp.hpp             |   77 -
 .../hash_collections_save_imp.hpp             |   97 -
 .../boost/serialization/hash_map.hpp          |  232 ---
 .../boost/serialization/hash_set.hpp          |  222 ---
 .../serialization/is_bitwise_serializable.hpp |   46 -
 .../boost/serialization/item_version_type.hpp |   68 -
 .../boost/serialization/level.hpp             |  116 --
 .../boost/serialization/level_enum.hpp        |   55 -
 .../boost_1_65_0/boost/serialization/list.hpp |   85 -
 .../boost_1_65_0/boost/serialization/map.hpp  |  139 --
 .../boost_1_65_0/boost/serialization/nvp.hpp  |  123 --
 .../boost/serialization/optional.hpp          |  107 -
 .../boost/serialization/priority_queue.hpp    |   76 -
 .../boost/serialization/queue.hpp             |   76 -
 .../boost/serialization/scoped_ptr.hpp        |   58 -
 .../boost/serialization/serialization.hpp     |  154 --
 .../boost_1_65_0/boost/serialization/set.hpp  |  137 --
 .../boost/serialization/shared_ptr.hpp        |  281 ---
 .../boost/serialization/shared_ptr_132.hpp    |  222 ---
 .../boost/serialization/shared_ptr_helper.hpp |  209 --
 .../boost/serialization/singleton.hpp         |  166 --
 .../boost/serialization/slist.hpp             |  145 --
 .../boost/serialization/smart_cast.hpp        |  275 ---
 .../boost/serialization/split_free.hpp        |   93 -
 .../boost/serialization/split_member.hpp      |   86 -
 .../boost/serialization/stack.hpp             |   76 -
 .../boost/serialization/state_saver.hpp       |   96 -
 .../boost/serialization/static_warning.hpp    |  103 -
 .../boost/serialization/string.hpp            |   30 -
 .../boost/serialization/strong_typedef.hpp    |   50 -
 .../boost/serialization/throw_exception.hpp   |   44 -
 .../boost/serialization/tracking.hpp          |  118 --
 .../boost/serialization/tracking_enum.hpp     |   41 -
 .../boost/serialization/traits.hpp            |   65 -
 .../type_info_implementation.hpp              |   73 -
 .../boost/serialization/unique_ptr.hpp        |   68 -
 .../unordered_collections_load_imp.hpp        |   73 -
 .../unordered_collections_save_imp.hpp        |   86 -
 .../boost/serialization/unordered_map.hpp     |  160 --
 .../boost/serialization/unordered_set.hpp     |  162 --
 .../boost/serialization/utility.hpp           |   56 -
 .../boost/serialization/valarray.hpp          |   86 -
 .../boost/serialization/variant.hpp           |  158 --
 .../boost/serialization/vector.hpp            |  233 ---
 .../boost/serialization/vector_135.hpp        |   26 -
 .../boost/serialization/version.hpp           |  107 -
 .../boost/serialization/void_cast.hpp         |  298 ---
 .../boost/serialization/void_cast_fwd.hpp     |   37 -
 .../boost/serialization/weak_ptr.hpp          |   99 -
 .../boost/serialization/wrapper.hpp           |   60 -
 contrib/poco                                  |    1 +
 contrib/zlib-ng                               |    1 +
 dbms/src/Storages/MergeTree/MergeTreeData.cpp |    3 -
 272 files changed, 12 insertions(+), 41591 deletions(-)
 create mode 160000 contrib/googletest
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/archive_exception.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/basic_archive.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/basic_binary_iarchive.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/basic_binary_iprimitive.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/basic_binary_oarchive.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/basic_binary_oprimitive.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/basic_streambuf_locale_saver.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/basic_text_iarchive.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/basic_text_iprimitive.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/basic_text_oarchive.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/basic_text_oprimitive.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/basic_xml_archive.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/basic_xml_iarchive.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/basic_xml_oarchive.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/binary_iarchive.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/binary_iarchive_impl.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/binary_oarchive.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/binary_oarchive_impl.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/binary_wiarchive.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/binary_woarchive.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/codecvt_null.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/detail/abi_prefix.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/detail/abi_suffix.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/detail/archive_serializer_map.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/detail/auto_link_archive.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/detail/auto_link_warchive.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/detail/basic_iarchive.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/detail/basic_iserializer.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/detail/basic_oarchive.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/detail/basic_oserializer.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/detail/basic_pointer_iserializer.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/detail/basic_pointer_oserializer.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/detail/basic_serializer.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/detail/basic_serializer_map.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/detail/check.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/detail/common_iarchive.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/detail/common_oarchive.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/detail/decl.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/detail/helper_collection.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/detail/interface_iarchive.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/detail/interface_oarchive.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/detail/iserializer.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/detail/oserializer.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/detail/polymorphic_iarchive_route.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/detail/polymorphic_oarchive_route.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/detail/register_archive.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/detail/utf8_codecvt_facet.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/dinkumware.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/impl/archive_serializer_map.ipp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/impl/basic_binary_iarchive.ipp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/impl/basic_binary_iprimitive.ipp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/impl/basic_binary_oarchive.ipp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/impl/basic_binary_oprimitive.ipp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/impl/basic_text_iarchive.ipp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/impl/basic_text_iprimitive.ipp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/impl/basic_text_oarchive.ipp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/impl/basic_text_oprimitive.ipp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/impl/basic_xml_grammar.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/impl/basic_xml_iarchive.ipp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/impl/basic_xml_oarchive.ipp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/impl/text_iarchive_impl.ipp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/impl/text_oarchive_impl.ipp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/impl/text_wiarchive_impl.ipp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/impl/text_woarchive_impl.ipp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/impl/xml_iarchive_impl.ipp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/impl/xml_oarchive_impl.ipp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/impl/xml_wiarchive_impl.ipp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/impl/xml_woarchive_impl.ipp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/iterators/base64_exception.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/iterators/base64_from_binary.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/iterators/binary_from_base64.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/iterators/dataflow.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/iterators/dataflow_exception.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/iterators/escape.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/iterators/insert_linebreaks.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/iterators/istream_iterator.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/iterators/mb_from_wchar.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/iterators/ostream_iterator.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/iterators/remove_whitespace.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/iterators/transform_width.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/iterators/unescape.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/iterators/wchar_from_mb.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/iterators/xml_escape.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/iterators/xml_unescape.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/iterators/xml_unescape_exception.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/polymorphic_binary_iarchive.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/polymorphic_binary_oarchive.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/polymorphic_iarchive.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/polymorphic_oarchive.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/polymorphic_text_iarchive.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/polymorphic_text_oarchive.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/polymorphic_text_wiarchive.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/polymorphic_text_woarchive.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/polymorphic_xml_iarchive.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/polymorphic_xml_oarchive.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/polymorphic_xml_wiarchive.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/polymorphic_xml_woarchive.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/text_iarchive.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/text_oarchive.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/text_wiarchive.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/text_woarchive.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/tmpdir.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/wcslen.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/xml_archive_exception.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/xml_iarchive.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/xml_oarchive.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/xml_wiarchive.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/xml_woarchive.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/foreach_fwd.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/composite_key.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/access_specifier.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/adl_swap.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/archive_constructed.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/auto_space.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/base_type.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/bidir_node_iterator.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/bucket_array.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/cons_stdtuple.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/converter.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/copy_map.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/do_not_copy_elements_tag.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/duplicates_iterator.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/has_tag.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/hash_index_args.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/hash_index_iterator.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/hash_index_node.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/header_holder.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/ignore_wstrict_aliasing.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/index_base.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/index_loader.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/index_matcher.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/index_node_base.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/index_saver.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/invariant_assert.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/is_index_list.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/is_transparent.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/iter_adaptor.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/modify_key_adaptor.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/no_duplicate_tags.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/node_type.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/ord_index_args.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/ord_index_impl.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/ord_index_impl_fwd.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/ord_index_node.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/ord_index_ops.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/promotes_arg.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/raw_ptr.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/restore_wstrict_aliasing.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/rnd_index_loader.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/rnd_index_node.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/rnd_index_ops.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/rnd_index_ptr_array.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/rnd_node_iterator.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/rnk_index_ops.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/safe_mode.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/scope_guard.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/seq_index_node.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/seq_index_ops.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/serialization_version.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/uintptr_type.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/unbounded.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/value_compare.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/vartempl_support.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/global_fun.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/hashed_index.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/hashed_index_fwd.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/identity.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/identity_fwd.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/indexed_by.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/key_extractors.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/mem_fun.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/member.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/ordered_index.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/ordered_index_fwd.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/random_access_index.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/random_access_index_fwd.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/ranked_index.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/ranked_index_fwd.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/safe_mode_errors.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/sequenced_index.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/sequenced_index_fwd.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/tag.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index_container.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index_container_fwd.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/access.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/archive_input_unordered_map.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/archive_input_unordered_set.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/array.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/array_optimization.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/array_wrapper.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/assume_abstract.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/base_object.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/binary_object.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/bitset.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/boost_array.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/boost_unordered_map.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/boost_unordered_set.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/collection_size_type.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/collection_traits.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/collections_load_imp.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/collections_save_imp.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/complex.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/config.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/deque.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/detail/is_default_constructible.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/detail/shared_count_132.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/detail/shared_ptr_132.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/detail/shared_ptr_nmt_132.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/detail/stack_constructor.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/ephemeral.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/export.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/extended_type_info.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/extended_type_info_no_rtti.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/extended_type_info_typeid.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/factory.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/force_include.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/forward_list.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/hash_collections_load_imp.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/hash_collections_save_imp.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/hash_map.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/hash_set.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/is_bitwise_serializable.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/item_version_type.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/level.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/level_enum.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/list.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/map.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/nvp.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/optional.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/priority_queue.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/queue.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/scoped_ptr.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/serialization.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/set.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/shared_ptr.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/shared_ptr_132.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/shared_ptr_helper.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/singleton.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/slist.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/smart_cast.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/split_free.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/split_member.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/stack.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/state_saver.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/static_warning.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/string.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/strong_typedef.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/throw_exception.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/tracking.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/tracking_enum.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/traits.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/type_info_implementation.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/unique_ptr.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/unordered_collections_load_imp.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/unordered_collections_save_imp.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/unordered_map.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/unordered_set.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/utility.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/valarray.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/variant.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/vector.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/vector_135.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/version.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/void_cast.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/void_cast_fwd.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/weak_ptr.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/wrapper.hpp
 create mode 160000 contrib/poco
 create mode 160000 contrib/zlib-ng

diff --git a/.gitmodules b/.gitmodules
index 336c2a892e2..0fda654f07c 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -1,3 +1,6 @@
+[submodule "contrib/poco"]
+	path = contrib/poco
+	url = https://github.com/ClickHouse-Extras/poco
 [submodule "contrib/zstd"]
 	path = contrib/zstd
 	url = https://github.com/facebook/zstd.git
@@ -10,6 +13,12 @@
 [submodule "contrib/cctz"]
 	path = contrib/cctz
 	url = https://github.com/google/cctz.git
+[submodule "contrib/zlib-ng"]
+	path = contrib/zlib-ng
+	url = https://github.com/ClickHouse-Extras/zlib-ng.git
+[submodule "contrib/googletest"]
+	path = contrib/googletest
+	url = https://github.com/google/googletest.git
 [submodule "contrib/capnproto"]
 	path = contrib/capnproto
 	url = https://github.com/capnproto/capnproto.git
diff --git a/contrib/googletest b/contrib/googletest
new file mode 160000
index 00000000000..d175c8bf823
--- /dev/null
+++ b/contrib/googletest
@@ -0,0 +1 @@
+Subproject commit d175c8bf823e709d570772b038757fadf63bc632
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/archive_exception.hpp b/contrib/libboost/boost_1_65_0/boost/archive/archive_exception.hpp
deleted file mode 100644
index fabcdb5fa71..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/archive_exception.hpp
+++ /dev/null
@@ -1,100 +0,0 @@
-#ifndef BOOST_ARCHIVE_ARCHIVE_EXCEPTION_HPP
-#define BOOST_ARCHIVE_ARCHIVE_EXCEPTION_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// archive/archive_exception.hpp:
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <exception>
-#include <boost/assert.hpp>
-#include <string>
-
-#include <boost/config.hpp> 
-#include <boost/archive/detail/decl.hpp>
-
-// note: the only reason this is in here is that windows header
-// includes #define exception_code _exception_code (arrrgghhhh!).
-// the most expedient way to address this is be sure that this
-// header is always included whenever this header file is included.
-#if defined(BOOST_WINDOWS) 
-#include <excpt.h> 
-#endif 
-
-#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
-
-namespace boost {
-namespace archive {
-
-//////////////////////////////////////////////////////////////////////
-// exceptions thrown by archives
-//
-class BOOST_SYMBOL_VISIBLE archive_exception : 
-    public virtual std::exception
-{
-private:
-    char m_buffer[128];
-protected:
-    BOOST_ARCHIVE_DECL unsigned int
-    append(unsigned int l, const char * a);
-    BOOST_ARCHIVE_DECL
-    archive_exception() BOOST_NOEXCEPT;
-public:
-    typedef enum {
-        no_exception,       // initialized without code
-        other_exception,    // any excepton not listed below
-        unregistered_class, // attempt to serialize a pointer of
-                            // an unregistered class
-        invalid_signature,  // first line of archive does not contain
-                            // expected string
-        unsupported_version,// archive created with library version
-                            // subsequent to this one
-        pointer_conflict,   // an attempt has been made to directly
-                            // serialize an object which has
-                            // already been serialized through a pointer.  
-                            // Were this permitted, the archive load would result 
-                            // in the creation of an extra copy of the obect.
-        incompatible_native_format, // attempt to read native binary format
-                            // on incompatible platform
-        array_size_too_short,// array being loaded doesn't fit in array allocated
-        input_stream_error, // error on input stream
-        invalid_class_name, // class name greater than the maximum permitted.
-                            // most likely a corrupted archive or an attempt
-                            // to insert virus via buffer overrun method.
-        unregistered_cast,   // base - derived relationship not registered with 
-                            // void_cast_register
-        unsupported_class_version, // type saved with a version # greater than the 
-                            // one used by the program.  This indicates that the program
-                            // needs to be rebuilt.
-        multiple_code_instantiation, // code for implementing serialization for some
-                            // type has been instantiated in more than one module.
-        output_stream_error // error on input stream
-    } exception_code;
-    exception_code code;
-
-    BOOST_ARCHIVE_DECL archive_exception(
-        exception_code c, 
-        const char * e1 = NULL,
-        const char * e2 = NULL
-    ) BOOST_NOEXCEPT;
-    BOOST_ARCHIVE_DECL archive_exception(archive_exception const &) BOOST_NOEXCEPT ;
-    virtual BOOST_ARCHIVE_DECL ~archive_exception() BOOST_NOEXCEPT_OR_NOTHROW ;
-    virtual BOOST_ARCHIVE_DECL const char * what() const BOOST_NOEXCEPT_OR_NOTHROW ;
-};
-
-}// namespace archive
-}// namespace boost
-
-#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
-
-#endif //BOOST_ARCHIVE_ARCHIVE_EXCEPTION_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/basic_archive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/basic_archive.hpp
deleted file mode 100644
index ce7ac99a6dd..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/basic_archive.hpp
+++ /dev/null
@@ -1,304 +0,0 @@
-#ifndef BOOST_ARCHIVE_BASIC_ARCHIVE_HPP
-#define BOOST_ARCHIVE_BASIC_ARCHIVE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// basic_archive.hpp:
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-#include <cstring> // count
-#include <boost/assert.hpp>
-#include <boost/config.hpp>
-#include <boost/cstdint.hpp> // size_t
-#include <boost/noncopyable.hpp>
-#include <boost/integer_traits.hpp>
-
-#include <boost/archive/detail/auto_link_archive.hpp>
-#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
-
-namespace boost {
-namespace archive {
-
-#if defined(_MSC_VER)
-#pragma warning( push )
-#pragma warning( disable : 4244 4267 )
-#endif
-
-/* NOTE : Warning  : Warning : Warning : Warning : Warning
- * Don't ever changes this.  If you do, they previously created
- * binary archives won't be readable !!!
- */
-class library_version_type {
-private:
-    typedef uint_least16_t base_type;
-    base_type t;
-public:
-    library_version_type(): t(0) {};
-    explicit library_version_type(const unsigned int & t_) : t(t_){
-        BOOST_ASSERT(t_ <= boost::integer_traits<base_type>::const_max);
-    }
-    library_version_type(const library_version_type & t_) : 
-        t(t_.t)
-    {}
-    library_version_type & operator=(const library_version_type & rhs){
-        t = rhs.t; 
-        return *this;
-    }
-    // used for text output
-    operator base_type () const {
-        return t;
-    }                
-    // used for text input
-    operator base_type & (){
-        return t;
-    }                
-    bool operator==(const library_version_type & rhs) const {
-        return t == rhs.t;
-    } 
-    bool operator<(const library_version_type & rhs) const {
-        return t < rhs.t;
-    }   
-};
-
-BOOST_ARCHIVE_DECL library_version_type
-BOOST_ARCHIVE_VERSION();
-
-class version_type {
-private:
-    typedef uint_least32_t base_type;
-    base_type t;
-public:
-    // should be private - but MPI fails if it's not!!!
-    version_type(): t(0) {};
-    explicit version_type(const unsigned int & t_) : t(t_){
-        BOOST_ASSERT(t_ <= boost::integer_traits<base_type>::const_max);
-    }
-    version_type(const version_type & t_) : 
-        t(t_.t)
-    {}
-    version_type & operator=(const version_type & rhs){
-        t = rhs.t; 
-        return *this;
-    }
-    // used for text output
-    operator base_type () const {
-        return t;
-    }                
-    // used for text intput
-    operator base_type  & (){
-        return t;
-    }                
-    bool operator==(const version_type & rhs) const {
-        return t == rhs.t;
-    } 
-    bool operator<(const version_type & rhs) const {
-        return t < rhs.t;
-    }   
-};
-
-class class_id_type {
-private:
-    typedef int_least16_t base_type;
-    base_type t;
-public:
-    // should be private - but then can't use BOOST_STRONG_TYPE below
-    class_id_type() : t(0) {};
-    explicit class_id_type(const int t_) : t(t_){
-        BOOST_ASSERT(t_ <= boost::integer_traits<base_type>::const_max);
-    }
-    explicit class_id_type(const std::size_t t_) : t(t_){
- //       BOOST_ASSERT(t_ <= boost::integer_traits<base_type>::const_max);
-    }
-    class_id_type(const class_id_type & t_) : 
-        t(t_.t)
-    {}
-    class_id_type & operator=(const class_id_type & rhs){
-        t = rhs.t; 
-        return *this;
-    }
-
-    // used for text output
-    operator int () const {
-        return t;
-    }                
-    // used for text input
-    operator int_least16_t &() {
-        return t;
-    }                
-    bool operator==(const class_id_type & rhs) const {
-        return t == rhs.t;
-    } 
-    bool operator<(const class_id_type & rhs) const {
-        return t < rhs.t;
-    }   
-};
-
-#define NULL_POINTER_TAG boost::archive::class_id_type(-1)
-
-class object_id_type {
-private:
-    typedef uint_least32_t base_type;
-    base_type t;
-public:
-    object_id_type(): t(0) {};
-    // note: presumes that size_t >= unsigned int.
-    explicit object_id_type(const std::size_t & t_) : t(t_){
-        BOOST_ASSERT(t_ <= boost::integer_traits<base_type>::const_max);
-    }
-    object_id_type(const object_id_type & t_) : 
-        t(t_.t)
-    {}
-    object_id_type & operator=(const object_id_type & rhs){
-        t = rhs.t; 
-        return *this;
-    }
-    // used for text output
-    operator uint_least32_t () const {
-        return t;
-    }                
-    // used for text input
-    operator uint_least32_t & () {
-        return t;
-    }                
-    bool operator==(const object_id_type & rhs) const {
-        return t == rhs.t;
-    } 
-    bool operator<(const object_id_type & rhs) const {
-        return t < rhs.t;
-    }   
-};
-
-#if defined(_MSC_VER)
-#pragma warning( pop )
-#endif
-
-struct tracking_type {
-    bool t;
-    explicit tracking_type(const bool t_ = false)
-        : t(t_)
-    {};
-    tracking_type(const tracking_type & t_)
-        : t(t_.t)
-    {}
-    operator bool () const {
-        return t;
-    };
-    operator bool & () {
-        return t;
-    };
-    tracking_type & operator=(const bool t_){
-        t = t_;
-        return *this;
-    }
-    bool operator==(const tracking_type & rhs) const {
-        return t == rhs.t;
-    }
-    bool operator==(const bool & rhs) const {
-        return t == rhs;
-    }
-    tracking_type & operator=(const tracking_type & rhs){
-        t = rhs.t;
-        return *this;
-    }
-};
-
-struct class_name_type : 
-    private boost::noncopyable 
-{
-    char *t;
-    operator const char * & () const {
-        return const_cast<const char * &>(t);
-    }
-    operator char * () {
-        return t;
-    }
-    std::size_t size() const {
-        return std::strlen(t);
-    }
-    explicit class_name_type(const char *key_) 
-    : t(const_cast<char *>(key_)){}
-    explicit class_name_type(char *key_) 
-    : t(key_){}
-    class_name_type & operator=(const class_name_type & rhs){
-        t = rhs.t;
-        return *this;
-    }
-};
-
-enum archive_flags {
-    no_header = 1,  // suppress archive header info
-    no_codecvt = 2,  // suppress alteration of codecvt facet
-    no_xml_tag_checking = 4,   // suppress checking of xml tags
-    no_tracking = 8,           // suppress ALL tracking
-    flags_last = 8
-};
-
-BOOST_ARCHIVE_DECL const char *
-BOOST_ARCHIVE_SIGNATURE();
-
-/* NOTE : Warning  : Warning : Warning : Warning : Warning
- * If any of these are changed to different sized types, 
- * binary_iarchive won't be able to read older archives
- * unless you rev the library version and include conditional
- * code based on the library version.  There is nothing
- * inherently wrong in doing this - but you have to be super
- * careful because it's easy to get wrong and start breaking
- * old archives !!!
- */
-
-#define BOOST_ARCHIVE_STRONG_TYPEDEF(T, D)         \
-    class D : public T {                           \
-    public:                                        \
-        explicit D(const T tt) : T(tt){}           \
-    };                                             \
-/**/
-
-BOOST_ARCHIVE_STRONG_TYPEDEF(class_id_type, class_id_reference_type)
-BOOST_ARCHIVE_STRONG_TYPEDEF(class_id_type, class_id_optional_type)
-BOOST_ARCHIVE_STRONG_TYPEDEF(object_id_type, object_reference_type)
-
-}// namespace archive
-}// namespace boost
-
-#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
-
-#include <boost/serialization/level.hpp>
-
-// set implementation level to primitive for all types
-// used internally by the serialization library
-
-BOOST_CLASS_IMPLEMENTATION(boost::archive::library_version_type, primitive_type)
-BOOST_CLASS_IMPLEMENTATION(boost::archive::version_type, primitive_type)
-BOOST_CLASS_IMPLEMENTATION(boost::archive::class_id_type, primitive_type)
-BOOST_CLASS_IMPLEMENTATION(boost::archive::class_id_reference_type, primitive_type)
-BOOST_CLASS_IMPLEMENTATION(boost::archive::class_id_optional_type, primitive_type)
-BOOST_CLASS_IMPLEMENTATION(boost::archive::class_name_type, primitive_type)
-BOOST_CLASS_IMPLEMENTATION(boost::archive::object_id_type, primitive_type)
-BOOST_CLASS_IMPLEMENTATION(boost::archive::object_reference_type, primitive_type)
-BOOST_CLASS_IMPLEMENTATION(boost::archive::tracking_type, primitive_type)
-
-#include <boost/serialization/is_bitwise_serializable.hpp>
-
-// set types used internally by the serialization library 
-// to be bitwise serializable
-
-BOOST_IS_BITWISE_SERIALIZABLE(boost::archive::library_version_type)
-BOOST_IS_BITWISE_SERIALIZABLE(boost::archive::version_type)
-BOOST_IS_BITWISE_SERIALIZABLE(boost::archive::class_id_type)
-BOOST_IS_BITWISE_SERIALIZABLE(boost::archive::class_id_reference_type)
-BOOST_IS_BITWISE_SERIALIZABLE(boost::archive::class_id_optional_type)
-BOOST_IS_BITWISE_SERIALIZABLE(boost::archive::class_name_type)
-BOOST_IS_BITWISE_SERIALIZABLE(boost::archive::object_id_type)
-BOOST_IS_BITWISE_SERIALIZABLE(boost::archive::object_reference_type)
-BOOST_IS_BITWISE_SERIALIZABLE(boost::archive::tracking_type)
-
-#endif //BOOST_ARCHIVE_BASIC_ARCHIVE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/basic_binary_iarchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/basic_binary_iarchive.hpp
deleted file mode 100644
index c0cc655c997..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/basic_binary_iarchive.hpp
+++ /dev/null
@@ -1,204 +0,0 @@
-#ifndef BOOST_ARCHIVE_BASIC_BINARY_IARCHIVE_HPP
-#define BOOST_ARCHIVE_BASIC_BINARY_IARCHIVE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// basic_binary_iarchive.hpp
-//
-// archives stored as native binary - this should be the fastest way
-// to archive the state of a group of obects.  It makes no attempt to
-// convert to any canonical form.
-
-// IN GENERAL, ARCHIVES CREATED WITH THIS CLASS WILL NOT BE READABLE
-// ON PLATFORM APART FROM THE ONE THEY ARE CREATED ON
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/config.hpp>
-#include <boost/detail/workaround.hpp>
-
-#include <boost/archive/basic_archive.hpp>
-#include <boost/archive/detail/common_iarchive.hpp>
-#include <boost/serialization/collection_size_type.hpp>
-#include <boost/serialization/string.hpp>
-#include <boost/serialization/item_version_type.hpp>
-#include <boost/integer_traits.hpp>
-
-#ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable : 4511 4512)
-#endif
-
-#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
-
-namespace boost { 
-namespace archive {
-
-namespace detail {
-    template<class Archive> class interface_iarchive;
-} // namespace detail
-
-/////////////////////////////////////////////////////////////////////////
-// class basic_binary_iarchive - read serialized objects from a input binary stream
-template<class Archive>
-class BOOST_SYMBOL_VISIBLE basic_binary_iarchive : 
-    public detail::common_iarchive<Archive>
-{
-#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
-public:
-#else
-protected:
-    #if BOOST_WORKAROUND(BOOST_MSVC, < 1500)
-        // for some inexplicable reason insertion of "class" generates compile erro
-        // on msvc 7.1
-        friend detail::interface_iarchive<Archive>;
-    #else
-        friend class detail::interface_iarchive<Archive>;
-    #endif
-#endif
-    // intermediate level to support override of operators
-    // fot templates in the absence of partial function 
-    // template ordering. If we get here pass to base class
-    // note extra nonsense to sneak it pass the borland compiers
-    typedef detail::common_iarchive<Archive> detail_common_iarchive;
-    template<class T>
-    void load_override(T & t){
-      this->detail_common_iarchive::load_override(t);
-    }
-
-    // include these to trap a change in binary format which
-    // isn't specifically handled
-    // upto 32K classes
-    BOOST_STATIC_ASSERT(sizeof(class_id_type) == sizeof(int_least16_t));
-    BOOST_STATIC_ASSERT(sizeof(class_id_reference_type) == sizeof(int_least16_t));
-    // upto 2G objects
-    BOOST_STATIC_ASSERT(sizeof(object_id_type) == sizeof(uint_least32_t));
-    BOOST_STATIC_ASSERT(sizeof(object_reference_type) == sizeof(uint_least32_t));
-
-    // binary files don't include the optional information 
-    void load_override(class_id_optional_type & /* t */){}
-
-    void load_override(tracking_type & t, int /*version*/){
-        library_version_type lvt = this->get_library_version();
-        if(boost::archive::library_version_type(6) < lvt){
-            int_least8_t x=0;
-            * this->This() >> x;
-            t = boost::archive::tracking_type(x);
-        }
-        else{
-            bool x=0;
-            * this->This() >> x;
-            t = boost::archive::tracking_type(x);
-        }
-    }
-    void load_override(class_id_type & t){
-        library_version_type lvt = this->get_library_version();
-        if(boost::archive::library_version_type(7) < lvt){
-            this->detail_common_iarchive::load_override(t);
-        }
-        else
-        if(boost::archive::library_version_type(6) < lvt){
-            int_least16_t x=0;
-            * this->This() >> x;
-            t = boost::archive::class_id_type(x);
-        }
-        else{
-            int x=0;
-            * this->This() >> x;
-            t = boost::archive::class_id_type(x);
-        }
-    }
-    void load_override(class_id_reference_type & t){
-        load_override(static_cast<class_id_type &>(t));
-    }
-
-    void load_override(version_type & t){
-        library_version_type lvt = this->get_library_version();
-        if(boost::archive::library_version_type(7) < lvt){
-            this->detail_common_iarchive::load_override(t);
-        }
-        else
-        if(boost::archive::library_version_type(6) < lvt){
-            uint_least8_t x=0;
-            * this->This() >> x;
-            t = boost::archive::version_type(x);
-        }
-        else
-        if(boost::archive::library_version_type(5) < lvt){
-            uint_least16_t x=0;
-            * this->This() >> x;
-            t = boost::archive::version_type(x);
-        }
-        else
-        if(boost::archive::library_version_type(2) < lvt){
-            // upto 255 versions
-            unsigned char x=0;
-            * this->This() >> x;
-            t = version_type(x);
-        }
-        else{
-            unsigned int x=0;
-            * this->This() >> x;
-            t = boost::archive::version_type(x);
-        }
-    }
-
-    void load_override(boost::serialization::item_version_type & t){
-        library_version_type lvt = this->get_library_version();
-//        if(boost::archive::library_version_type(7) < lvt){
-        if(boost::archive::library_version_type(6) < lvt){
-            this->detail_common_iarchive::load_override(t);
-        }
-        else
-        if(boost::archive::library_version_type(6) < lvt){
-            uint_least16_t x=0;
-            * this->This() >> x;
-            t = boost::serialization::item_version_type(x);
-        }
-        else{
-            unsigned int x=0;
-            * this->This() >> x;
-            t = boost::serialization::item_version_type(x);
-        }
-    }
-
-    void load_override(serialization::collection_size_type & t){
-        if(boost::archive::library_version_type(5) < this->get_library_version()){
-            this->detail_common_iarchive::load_override(t);
-        }
-        else{
-            unsigned int x=0;
-            * this->This() >> x;
-            t = serialization::collection_size_type(x);
-        } 
-    }
-
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-    load_override(class_name_type & t);
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-    init();
-   
-    basic_binary_iarchive(unsigned int flags) :
-        detail::common_iarchive<Archive>(flags)
-    {}
-};
-
-} // namespace archive
-} // namespace boost
-
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
-
-#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
-
-#endif // BOOST_ARCHIVE_BASIC_BINARY_IARCHIVE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/basic_binary_iprimitive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/basic_binary_iprimitive.hpp
deleted file mode 100644
index 665d3e81e1f..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/basic_binary_iprimitive.hpp
+++ /dev/null
@@ -1,198 +0,0 @@
-#ifndef BOOST_ARCHIVE_BINARY_IPRIMITIVE_HPP
-#define BOOST_ARCHIVE_BINARY_IPRIMITIVE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-#if defined(_MSC_VER)
-#pragma warning( disable : 4800 )
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// basic_binary_iprimitive.hpp
-//
-// archives stored as native binary - this should be the fastest way
-// to archive the state of a group of obects.  It makes no attempt to
-// convert to any canonical form.
-
-// IN GENERAL, ARCHIVES CREATED WITH THIS CLASS WILL NOT BE READABLE
-// ON PLATFORM APART FROM THE ONE THEY ARE CREATED ON
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <iosfwd>
-#include <boost/assert.hpp>
-#include <locale>
-#include <cstring> // std::memcpy
-#include <cstddef> // std::size_t
-#include <streambuf> // basic_streambuf
-#include <string>
-
-#include <boost/config.hpp>
-#if defined(BOOST_NO_STDC_NAMESPACE)
-namespace std{ 
-    using ::memcpy; 
-    using ::size_t;
-} // namespace std
-#endif
-
-#include <boost/cstdint.hpp>
-#include <boost/serialization/throw_exception.hpp>
-#include <boost/integer.hpp>
-#include <boost/integer_traits.hpp>
-
-//#include <boost/mpl/placeholders.hpp>
-#include <boost/serialization/is_bitwise_serializable.hpp>
-#include <boost/serialization/array_wrapper.hpp>
-
-#include <boost/archive/basic_streambuf_locale_saver.hpp>
-#include <boost/archive/codecvt_null.hpp>
-#include <boost/archive/archive_exception.hpp>
-#include <boost/archive/detail/auto_link_archive.hpp>
-#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
-
-namespace boost { 
-namespace archive {
-
-/////////////////////////////////////////////////////////////////////////////
-// class binary_iarchive - read serialized objects from a input binary stream
-template<class Archive, class Elem, class Tr>
-class BOOST_SYMBOL_VISIBLE basic_binary_iprimitive {
-#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
-    friend class load_access;
-protected:
-#else
-public:
-#endif
-    std::basic_streambuf<Elem, Tr> & m_sb;
-    // return a pointer to the most derived class
-    Archive * This(){
-        return static_cast<Archive *>(this);
-    }
-
-    #ifndef BOOST_NO_STD_LOCALE
-    // note order! - if you change this, libstd++ will fail!
-    // a) create new locale with new codecvt facet
-    // b) save current locale
-    // c) change locale to new one
-    // d) use stream buffer
-    // e) change locale back to original
-    // f) destroy new codecvt facet
-    boost::archive::codecvt_null<Elem> codecvt_null_facet;
-    basic_streambuf_locale_saver<Elem, Tr> locale_saver;
-    std::locale archive_locale;
-    #endif
-
-    // main template for serilization of primitive types
-    template<class T>
-    void load(T & t){
-        load_binary(& t, sizeof(T));
-    }
-
-    /////////////////////////////////////////////////////////
-    // fundamental types that need special treatment
-    
-    // trap usage of invalid uninitialized boolean 
-    void load(bool & t){
-        load_binary(& t, sizeof(t));
-        int i = t;
-        BOOST_ASSERT(0 == i || 1 == i);
-        (void)i; // warning suppression for release builds.
-    }
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-    load(std::string &s);
-    #ifndef BOOST_NO_STD_WSTRING
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-    load(std::wstring &ws);
-    #endif
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-    load(char * t);
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-    load(wchar_t * t);
-
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-    init();
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL 
-    basic_binary_iprimitive(
-        std::basic_streambuf<Elem, Tr> & sb, 
-        bool no_codecvt
-    );
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL 
-    ~basic_binary_iprimitive();
-public:
-    // we provide an optimized load for all fundamental types
-    // typedef serialization::is_bitwise_serializable<mpl::_1> 
-    // use_array_optimization;
-    struct use_array_optimization {  
-        template <class T>  
-        #if defined(BOOST_NO_DEPENDENT_NESTED_DERIVATIONS)  
-            struct apply {  
-                typedef typename boost::serialization::is_bitwise_serializable< T >::type type;  
-            };
-        #else
-            struct apply : public boost::serialization::is_bitwise_serializable< T > {};  
-        #endif
-    };
-
-    // the optimized load_array dispatches to load_binary 
-    template <class ValueType>
-    void load_array(serialization::array_wrapper<ValueType>& a, unsigned int)
-    {
-      load_binary(a.address(),a.count()*sizeof(ValueType));
-    }
-
-    void
-    load_binary(void *address, std::size_t count);
-};
-
-template<class Archive, class Elem, class Tr>
-inline void
-basic_binary_iprimitive<Archive, Elem, Tr>::load_binary(
-    void *address, 
-    std::size_t count
-){
-    // note: an optimizer should eliminate the following for char files
-    BOOST_ASSERT(
-        static_cast<std::streamsize>(count / sizeof(Elem)) 
-        <= boost::integer_traits<std::streamsize>::const_max
-    );
-    std::streamsize s = static_cast<std::streamsize>(count / sizeof(Elem));
-    std::streamsize scount = m_sb.sgetn(
-        static_cast<Elem *>(address), 
-        s
-    );
-    if(scount != s)
-        boost::serialization::throw_exception(
-            archive_exception(archive_exception::input_stream_error)
-        );
-    // note: an optimizer should eliminate the following for char files
-    BOOST_ASSERT(count % sizeof(Elem) <= boost::integer_traits<std::streamsize>::const_max);
-    s = static_cast<std::streamsize>(count % sizeof(Elem));
-    if(0 < s){
-//        if(is.fail())
-//            boost::serialization::throw_exception(
-//                archive_exception(archive_exception::stream_error)
-//        );
-        Elem t;
-        scount = m_sb.sgetn(& t, 1);
-        if(scount != 1)
-            boost::serialization::throw_exception(
-                archive_exception(archive_exception::input_stream_error)
-            );
-        std::memcpy(static_cast<char*>(address) + (count - s), &t, static_cast<std::size_t>(s));
-    }
-}
-
-} // namespace archive
-} // namespace boost
-
-#include <boost/archive/detail/abi_suffix.hpp> // pop pragmas
-
-#endif // BOOST_ARCHIVE_BINARY_IPRIMITIVE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/basic_binary_oarchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/basic_binary_oarchive.hpp
deleted file mode 100644
index f05f2f86d55..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/basic_binary_oarchive.hpp
+++ /dev/null
@@ -1,185 +0,0 @@
-#ifndef BOOST_ARCHIVE_BASIC_BINARY_OARCHIVE_HPP
-#define BOOST_ARCHIVE_BASIC_BINARY_OARCHIVE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// basic_binary_oarchive.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-// archives stored as native binary - this should be the fastest way
-// to archive the state of a group of obects.  It makes no attempt to
-// convert to any canonical form.
-
-// IN GENERAL, ARCHIVES CREATED WITH THIS CLASS WILL NOT BE READABLE
-// ON PLATFORM APART FROM THE ONE THEY ARE CREATE ON
-
-#include <boost/assert.hpp>
-#include <boost/config.hpp>
-#include <boost/detail/workaround.hpp>
-
-#include <boost/integer.hpp>
-#include <boost/integer_traits.hpp>
-
-#include <boost/archive/detail/common_oarchive.hpp>
-#include <boost/serialization/string.hpp>
-#include <boost/serialization/collection_size_type.hpp>
-#include <boost/serialization/item_version_type.hpp>
-
-#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
-
-#ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable : 4511 4512)
-#endif
-
-namespace boost {
-namespace archive {
-
-namespace detail {
-    template<class Archive> class interface_oarchive;
-} // namespace detail
-
-//////////////////////////////////////////////////////////////////////
-// class basic_binary_oarchive - write serialized objects to a binary output stream
-// note: this archive has no pretensions to portability.  Archive format
-// may vary across machine architectures and compilers.  About the only
-// guarentee is that an archive created with this code will be readable
-// by a program built with the same tools for the same machne.  This class
-// does have the virtue of buiding the smalles archive in the minimum amount
-// of time.  So under some circumstances it may be he right choice.
-template<class Archive>
-class BOOST_SYMBOL_VISIBLE basic_binary_oarchive : 
-    public detail::common_oarchive<Archive>
-{
-#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
-public:
-#else
-protected:
-    #if BOOST_WORKAROUND(BOOST_MSVC, < 1500)
-        // for some inexplicable reason insertion of "class" generates compile erro
-        // on msvc 7.1
-        friend detail::interface_oarchive<Archive>;
-    #else
-        friend class detail::interface_oarchive<Archive>;
-    #endif
-#endif
-    // any datatype not specifed below will be handled by base class
-    typedef detail::common_oarchive<Archive> detail_common_oarchive;
-    template<class T>
-    void save_override(const T & t){
-      this->detail_common_oarchive::save_override(t);
-    }
-
-    // include these to trap a change in binary format which
-    // isn't specifically handled
-    BOOST_STATIC_ASSERT(sizeof(tracking_type) == sizeof(bool));
-    // upto 32K classes
-    BOOST_STATIC_ASSERT(sizeof(class_id_type) == sizeof(int_least16_t));
-    BOOST_STATIC_ASSERT(sizeof(class_id_reference_type) == sizeof(int_least16_t));
-    // upto 2G objects
-    BOOST_STATIC_ASSERT(sizeof(object_id_type) == sizeof(uint_least32_t));
-    BOOST_STATIC_ASSERT(sizeof(object_reference_type) == sizeof(uint_least32_t));
-
-    // binary files don't include the optional information 
-    void save_override(const class_id_optional_type & /* t */){}
-
-    // enable this if we decide to support generation of previous versions
-    #if 0
-    void save_override(const boost::archive::version_type & t){
-        library_version_type lvt = this->get_library_version();
-        if(boost::archive::library_version_type(7) < lvt){
-            this->detail_common_oarchive::save_override(t);
-        }
-        else
-        if(boost::archive::library_version_type(6) < lvt){
-            const boost::uint_least16_t x = t;
-            * this->This() << x;
-        }
-        else{
-            const unsigned int x = t;
-            * this->This() << x;
-        }
-    }
-    void save_override(const boost::serialization::item_version_type & t){
-        library_version_type lvt = this->get_library_version();
-        if(boost::archive::library_version_type(7) < lvt){
-            this->detail_common_oarchive::save_override(t);
-        }
-        else
-        if(boost::archive::library_version_type(6) < lvt){
-            const boost::uint_least16_t x = t;
-            * this->This() << x;
-        }
-        else{
-            const unsigned int x = t;
-            * this->This() << x;
-        }
-    }
-
-    void save_override(class_id_type & t){
-        library_version_type lvt = this->get_library_version();
-        if(boost::archive::library_version_type(7) < lvt){
-            this->detail_common_oarchive::save_override(t);
-        }
-        else
-        if(boost::archive::library_version_type(6) < lvt){
-            const boost::int_least16_t x = t;
-            * this->This() << x;
-        }
-        else{
-            const int x = t;
-            * this->This() << x;
-        }
-    }
-    void save_override(class_id_reference_type & t){
-        save_override(static_cast<class_id_type &>(t));
-    }
-
-    #endif
-
-    // explicitly convert to char * to avoid compile ambiguities
-    void save_override(const class_name_type & t){
-        const std::string s(t);
-        * this->This() << s;
-    }
-
-    #if 0
-    void save_override(const serialization::collection_size_type & t){
-        if (get_library_version() < boost::archive::library_version_type(6)){
-            unsigned int x=0;
-            * this->This() >> x;
-            t = serialization::collection_size_type(x);
-        } 
-        else{
-            * this->This() >> t;
-        }
-    }
-    #endif
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-    init();
-
-    basic_binary_oarchive(unsigned int flags) :
-        detail::common_oarchive<Archive>(flags)
-    {}
-};
-
-} // namespace archive
-} // namespace boost
-
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
-
-#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
-
-#endif // BOOST_ARCHIVE_BASIC_BINARY_OARCHIVE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/basic_binary_oprimitive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/basic_binary_oprimitive.hpp
deleted file mode 100644
index 6dc770c60e8..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/basic_binary_oprimitive.hpp
+++ /dev/null
@@ -1,188 +0,0 @@
-#ifndef BOOST_ARCHIVE_BASIC_BINARY_OPRIMITIVE_HPP
-#define BOOST_ARCHIVE_BASIC_BINARY_OPRIMITIVE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// basic_binary_oprimitive.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-// archives stored as native binary - this should be the fastest way
-// to archive the state of a group of obects.  It makes no attempt to
-// convert to any canonical form.
-
-// IN GENERAL, ARCHIVES CREATED WITH THIS CLASS WILL NOT BE READABLE
-// ON PLATFORM APART FROM THE ONE THEY ARE CREATE ON
-
-#include <iosfwd>
-#include <boost/assert.hpp>
-#include <locale>
-#include <streambuf> // basic_streambuf
-#include <string>
-#include <cstddef> // size_t
-
-#include <boost/config.hpp>
-#if defined(BOOST_NO_STDC_NAMESPACE)
-namespace std{ 
-    using ::size_t; 
-} // namespace std
-#endif
-
-#include <boost/cstdint.hpp>
-#include <boost/integer.hpp>
-#include <boost/integer_traits.hpp>
-#include <boost/scoped_ptr.hpp>
-#include <boost/serialization/throw_exception.hpp>
-
-//#include <boost/mpl/placeholders.hpp>
-#include <boost/serialization/is_bitwise_serializable.hpp>
-#include <boost/serialization/array_wrapper.hpp>
-
-#include <boost/archive/basic_streambuf_locale_saver.hpp>
-#include <boost/archive/codecvt_null.hpp>
-#include <boost/archive/archive_exception.hpp>
-#include <boost/archive/detail/auto_link_archive.hpp>
-#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
-
-namespace boost {
-namespace archive {
-
-/////////////////////////////////////////////////////////////////////////
-// class basic_binary_oprimitive - binary output of prmitives
-
-template<class Archive, class Elem, class Tr>
-class BOOST_SYMBOL_VISIBLE basic_binary_oprimitive {
-#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
-    friend class save_access;
-protected:
-#else
-public:
-#endif
-    std::basic_streambuf<Elem, Tr> & m_sb;
-    // return a pointer to the most derived class
-    Archive * This(){
-        return static_cast<Archive *>(this);
-    }
-    #ifndef BOOST_NO_STD_LOCALE
-    // note order! - if you change this, libstd++ will fail!
-    // a) create new locale with new codecvt facet
-    // b) save current locale
-    // c) change locale to new one
-    // d) use stream buffer
-    // e) change locale back to original
-    // f) destroy new codecvt facet
-    boost::archive::codecvt_null<Elem> codecvt_null_facet;
-    basic_streambuf_locale_saver<Elem, Tr> locale_saver;
-    std::locale archive_locale;
-    #endif
-    // default saving of primitives.
-    template<class T>
-    void save(const T & t)
-    {
-        save_binary(& t, sizeof(T));
-    }
-
-    /////////////////////////////////////////////////////////
-    // fundamental types that need special treatment
-    
-    // trap usage of invalid uninitialized boolean which would
-    // otherwise crash on load.
-    void save(const bool t){
-        BOOST_ASSERT(0 == static_cast<int>(t) || 1 == static_cast<int>(t));
-        save_binary(& t, sizeof(t));
-    }
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-    save(const std::string &s);
-    #ifndef BOOST_NO_STD_WSTRING
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-    save(const std::wstring &ws);
-    #endif
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-    save(const char * t);
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-    save(const wchar_t * t);
-
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-    init();
-    
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL 
-    basic_binary_oprimitive(
-        std::basic_streambuf<Elem, Tr> & sb, 
-        bool no_codecvt
-    );
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL 
-    ~basic_binary_oprimitive();
-public:
-
-    // we provide an optimized save for all fundamental types
-    // typedef serialization::is_bitwise_serializable<mpl::_1> 
-    // use_array_optimization;
-    // workaround without using mpl lambdas
-    struct use_array_optimization {
-        template <class T>  
-        #if defined(BOOST_NO_DEPENDENT_NESTED_DERIVATIONS)  
-            struct apply {  
-                typedef typename boost::serialization::is_bitwise_serializable< T >::type type;  
-            };
-        #else
-            struct apply : public boost::serialization::is_bitwise_serializable< T > {};  
-        #endif
-    };
-
-    // the optimized save_array dispatches to save_binary 
-    template <class ValueType>
-    void save_array(boost::serialization::array_wrapper<ValueType> const& a, unsigned int)
-    {
-      save_binary(a.address(),a.count()*sizeof(ValueType));
-    }
-
-    void save_binary(const void *address, std::size_t count);
-};
-
-template<class Archive, class Elem, class Tr>
-inline void 
-basic_binary_oprimitive<Archive, Elem, Tr>::save_binary(
-    const void *address, 
-    std::size_t count
-){
-    // BOOST_ASSERT(count <= std::size_t(boost::integer_traits<std::streamsize>::const_max));
-    // note: if the following assertions fail
-    // a likely cause is that the output stream is set to "text"
-    // mode where by cr characters recieve special treatment.
-    // be sure that the output stream is opened with ios::binary
-    //if(os.fail())
-    //    boost::serialization::throw_exception(
-    //        archive_exception(archive_exception::output_stream_error)
-    //    );
-    // figure number of elements to output - round up
-    count = ( count + sizeof(Elem) - 1) / sizeof(Elem);
-    std::streamsize scount = m_sb.sputn(
-        static_cast<const Elem *>(address), 
-        static_cast<std::streamsize>(count)
-    );
-    if(count != static_cast<std::size_t>(scount))
-        boost::serialization::throw_exception(
-            archive_exception(archive_exception::output_stream_error)
-        );
-    //os.write(
-    //    static_cast<const typename OStream::char_type *>(address), 
-    //    count
-    //);
-    //BOOST_ASSERT(os.good());
-}
-
-} //namespace boost 
-} //namespace archive 
-
-#include <boost/archive/detail/abi_suffix.hpp> // pop pragmas
-
-#endif // BOOST_ARCHIVE_BASIC_BINARY_OPRIMITIVE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/basic_streambuf_locale_saver.hpp b/contrib/libboost/boost_1_65_0/boost/archive/basic_streambuf_locale_saver.hpp
deleted file mode 100644
index 5cd4b36f081..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/basic_streambuf_locale_saver.hpp
+++ /dev/null
@@ -1,108 +0,0 @@
-#ifndef BOOST_ARCHIVE_BASIC_STREAMBUF_LOCALE_SAVER_HPP
-#define BOOST_ARCHIVE_BASIC_STREAMBUF_LOCALE_SAVER_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// basic_streambuf_locale_saver.hpp
-
-// (C) Copyright 2005 Robert Ramey - http://www.rrsd.com
-
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-// note derived from boost/io/ios_state.hpp
-// Copyright 2002, 2005 Daryle Walker.  Use, modification, and distribution
-// are subject to the Boost Software License, Version 1.0.  (See accompanying
-// file LICENSE_1_0.txt or a copy at <http://www.boost.org/LICENSE_1_0.txt>.)
-
-//  See <http://www.boost.org/libs/io/> for the library's home page.
-
-#ifndef BOOST_NO_STD_LOCALE
-
-#include <locale>     // for std::locale
-#include <ios>
-#include <streambuf>  // for std::basic_streambuf
-
-#include <boost/config.hpp>
-#include <boost/noncopyable.hpp>
-
-#ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable : 4511 4512)
-#endif
-
-namespace boost{
-namespace archive{
-
-template < typename Ch, class Tr >
-class basic_streambuf_locale_saver :
-    private boost::noncopyable
-{
-public:
-    explicit basic_streambuf_locale_saver(std::basic_streambuf<Ch, Tr> &s) :
-        m_streambuf(s),
-        m_locale(s.getloc())
-    {}
-    ~basic_streambuf_locale_saver(){
-        m_streambuf.pubsync();
-        m_streambuf.pubimbue(m_locale);
-    }
-private:
-    std::basic_streambuf<Ch, Tr> &       m_streambuf;
-    std::locale const  m_locale;
-};
-
-template < typename Ch, class Tr >
-class basic_istream_locale_saver :
-    private boost::noncopyable
-{
-public:
-    explicit basic_istream_locale_saver(std::basic_istream<Ch, Tr> &s) :
-        m_istream(s),
-        m_locale(s.getloc())
-    {}
-    ~basic_istream_locale_saver(){
-        // libstdc++ crashes without this
-        m_istream.sync();
-        m_istream.imbue(m_locale);
-    }
-private:
-    std::basic_istream<Ch, Tr> & m_istream;
-    std::locale const  m_locale;
-};
-
-template < typename Ch, class Tr >
-class basic_ostream_locale_saver :
-    private boost::noncopyable
-{
-public:
-    explicit basic_ostream_locale_saver(std::basic_ostream<Ch, Tr> &s) :
-        m_ostream(s),
-        m_locale(s.getloc())
-    {}
-    ~basic_ostream_locale_saver(){
-        m_ostream.flush();
-        m_ostream.imbue(m_locale);
-    }
-private:
-    std::basic_ostream<Ch, Tr> & m_ostream;
-    std::locale const  m_locale;
-};
-
-
-} // archive
-} // boost
-
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
-
-#endif // BOOST_NO_STD_LOCALE
-#endif // BOOST_ARCHIVE_BASIC_STREAMBUF_LOCALE_SAVER_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/basic_text_iarchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/basic_text_iarchive.hpp
deleted file mode 100644
index 48a646cc1f7..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/basic_text_iarchive.hpp
+++ /dev/null
@@ -1,96 +0,0 @@
-#ifndef BOOST_ARCHIVE_BASIC_TEXT_IARCHIVE_HPP
-#define BOOST_ARCHIVE_BASIC_TEXT_IARCHIVE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// basic_text_iarchive.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-// archives stored as text - note these ar templated on the basic
-// stream templates to accommodate wide (and other?) kind of characters
-//
-// note the fact that on libraries without wide characters, ostream is
-// is not a specialization of basic_ostream which in fact is not defined
-// in such cases.   So we can't use basic_istream<IStream::char_type> but rather
-// use two template parameters
-
-#include <boost/config.hpp>
-#include <boost/detail/workaround.hpp>
-
-#include <boost/archive/detail/common_iarchive.hpp>
-
-#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
-
-#ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable : 4511 4512)
-#endif
-
-namespace boost {
-namespace archive {
-
-namespace detail {
-    template<class Archive> class interface_iarchive;
-} // namespace detail
-
-/////////////////////////////////////////////////////////////////////////
-// class basic_text_iarchive - read serialized objects from a input text stream
-template<class Archive>
-class BOOST_SYMBOL_VISIBLE basic_text_iarchive : 
-    public detail::common_iarchive<Archive>
-{
-#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
-public:
-#else
-protected:
-    #if BOOST_WORKAROUND(BOOST_MSVC, < 1500)
-        // for some inexplicable reason insertion of "class" generates compile erro
-        // on msvc 7.1
-        friend detail::interface_iarchive<Archive>;
-    #else
-        friend class detail::interface_iarchive<Archive>;
-    #endif
-#endif
-    // intermediate level to support override of operators
-    // fot templates in the absence of partial function 
-    // template ordering
-    typedef detail::common_iarchive<Archive> detail_common_iarchive;
-    template<class T>
-    void load_override(T & t){
-        this->detail_common_iarchive::load_override(t);
-    }
-    // text file don't include the optional information 
-    void load_override(class_id_optional_type & /*t*/){}
-
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-    load_override(class_name_type & t);
-
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-    init(void);
-
-    basic_text_iarchive(unsigned int flags) : 
-        detail::common_iarchive<Archive>(flags)
-    {}
-    ~basic_text_iarchive(){}
-};
-
-} // namespace archive
-} // namespace boost
-
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
-
-#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
-
-#endif // BOOST_ARCHIVE_BASIC_TEXT_IARCHIVE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/basic_text_iprimitive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/basic_text_iprimitive.hpp
deleted file mode 100644
index bf936b55546..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/basic_text_iprimitive.hpp
+++ /dev/null
@@ -1,142 +0,0 @@
-#ifndef BOOST_ARCHIVE_BASIC_TEXT_IPRIMITIVE_HPP
-#define BOOST_ARCHIVE_BASIC_TEXT_IPRIMITIVE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// basic_text_iprimitive.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-// archives stored as text - note these are templated on the basic
-// stream templates to accommodate wide (and other?) kind of characters
-//
-// Note the fact that on libraries without wide characters, ostream is
-// not a specialization of basic_ostream which in fact is not defined
-// in such cases.   So we can't use basic_ostream<IStream::char_type> but rather
-// use two template parameters
-
-#include <locale>
-#include <cstddef> // size_t
-
-#include <boost/config.hpp>
-#if defined(BOOST_NO_STDC_NAMESPACE)
-namespace std{ 
-    using ::size_t; 
-    #if ! defined(BOOST_DINKUMWARE_STDLIB) && ! defined(__SGI_STL_PORT)
-        using ::locale;
-    #endif
-} // namespace std
-#endif
-
-#include <boost/io/ios_state.hpp>
-#include <boost/static_assert.hpp>
-
-#include <boost/detail/workaround.hpp>
-#if BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, == 1)
-#include <boost/archive/dinkumware.hpp>
-#endif
-#include <boost/serialization/throw_exception.hpp>
-#include <boost/archive/codecvt_null.hpp>
-#include <boost/archive/archive_exception.hpp>
-#include <boost/archive/basic_streambuf_locale_saver.hpp>
-#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
-
-namespace boost {
-namespace archive {
-
-/////////////////////////////////////////////////////////////////////////
-// class basic_text_iarchive - load serialized objects from a input text stream
-#if defined(_MSC_VER)
-#pragma warning( push )
-#pragma warning( disable : 4244 4267 )
-#endif
-
-template<class IStream>
-class BOOST_SYMBOL_VISIBLE basic_text_iprimitive {
-protected:
-    IStream &is;
-    io::ios_flags_saver flags_saver;
-    io::ios_precision_saver precision_saver;
-
-    #ifndef BOOST_NO_STD_LOCALE
-    // note order! - if you change this, libstd++ will fail!
-    // a) create new locale with new codecvt facet
-    // b) save current locale
-    // c) change locale to new one
-    // d) use stream buffer
-    // e) change locale back to original
-    // f) destroy new codecvt facet
-    boost::archive::codecvt_null<typename IStream::char_type> codecvt_null_facet;
-    std::locale archive_locale;
-    basic_istream_locale_saver<
-        typename IStream::char_type,
-        typename IStream::traits_type
-    > locale_saver;
-    #endif
-
-    template<class T>
-    void load(T & t)
-    {
-        if(is >> t)
-            return;
-        boost::serialization::throw_exception(
-            archive_exception(archive_exception::input_stream_error)
-        );
-    }
-
-    void load(char & t)
-    {
-        short int i;
-        load(i);
-        t = i;
-    }
-    void load(signed char & t)
-    {
-        short int i;
-        load(i);
-        t = i;
-    }
-    void load(unsigned char & t)
-    {
-        unsigned short int i;
-        load(i);
-        t = i;
-    }
-
-    #ifndef BOOST_NO_INTRINSIC_WCHAR_T
-    void load(wchar_t & t)
-    {
-        BOOST_STATIC_ASSERT(sizeof(wchar_t) <= sizeof(int));
-        int i;
-        load(i);
-        t = i;
-    }
-    #endif
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL 
-    basic_text_iprimitive(IStream  &is, bool no_codecvt);
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL 
-    ~basic_text_iprimitive();
-public:
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-    load_binary(void *address, std::size_t count);
-};
-
-#if defined(_MSC_VER)
-#pragma warning( pop )
-#endif
-
-} // namespace archive
-} // namespace boost
-
-#include <boost/archive/detail/abi_suffix.hpp> // pop pragmas
-
-#endif // BOOST_ARCHIVE_BASIC_TEXT_IPRIMITIVE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/basic_text_oarchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/basic_text_oarchive.hpp
deleted file mode 100644
index 6f7f8fb167d..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/basic_text_oarchive.hpp
+++ /dev/null
@@ -1,119 +0,0 @@
-#ifndef BOOST_ARCHIVE_BASIC_TEXT_OARCHIVE_HPP
-#define BOOST_ARCHIVE_BASIC_TEXT_OARCHIVE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// basic_text_oarchive.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-// archives stored as text - note these ar templated on the basic
-// stream templates to accommodate wide (and other?) kind of characters
-//
-// note the fact that on libraries without wide characters, ostream is
-// is not a specialization of basic_ostream which in fact is not defined
-// in such cases.   So we can't use basic_ostream<OStream::char_type> but rather
-// use two template parameters
-
-#include <boost/config.hpp>
-#include <boost/detail/workaround.hpp>
-#include <boost/archive/detail/common_oarchive.hpp>
-#include <boost/serialization/string.hpp>
-
-#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
-
-#ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable : 4511 4512)
-#endif
-
-namespace boost {
-namespace archive {
-
-namespace detail {
-    template<class Archive> class interface_oarchive;
-} // namespace detail
-
-/////////////////////////////////////////////////////////////////////////
-// class basic_text_oarchive 
-template<class Archive>
-class BOOST_SYMBOL_VISIBLE basic_text_oarchive : 
-    public detail::common_oarchive<Archive>
-{
-#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
-public:
-#else
-protected:
-    #if BOOST_WORKAROUND(BOOST_MSVC, < 1500)
-        // for some inexplicable reason insertion of "class" generates compile erro
-        // on msvc 7.1
-        friend detail::interface_oarchive<Archive>;
-    #else
-        friend class detail::interface_oarchive<Archive>;
-    #endif
-#endif
-
-    enum {
-        none,
-        eol,
-        space
-    } delimiter;
-
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-    newtoken();
-
-    void newline(){
-        delimiter = eol;
-    }
-
-    // default processing - kick back to base class.  Note the
-    // extra stuff to get it passed borland compilers
-    typedef detail::common_oarchive<Archive> detail_common_oarchive;
-    template<class T>
-    void save_override(T & t){
-        this->detail_common_oarchive::save_override(t);
-    }
-
-    // start new objects on a new line
-    void save_override(const object_id_type & t){
-        this->This()->newline();
-        this->detail_common_oarchive::save_override(t);
-    }
-
-    // text file don't include the optional information 
-    void save_override(const class_id_optional_type & /* t */){}
-
-    void save_override(const class_name_type & t){
-        const std::string s(t);
-        * this->This() << s;
-    }
-
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-    init();
-
-    basic_text_oarchive(unsigned int flags) :
-        detail::common_oarchive<Archive>(flags),
-        delimiter(none)
-    {}
-    ~basic_text_oarchive(){}
-};
-
-} // namespace archive
-} // namespace boost
-
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
-
-#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
-
-#endif // BOOST_ARCHIVE_BASIC_TEXT_OARCHIVE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/basic_text_oprimitive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/basic_text_oprimitive.hpp
deleted file mode 100644
index 45f09358ece..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/basic_text_oprimitive.hpp
+++ /dev/null
@@ -1,209 +0,0 @@
-#ifndef BOOST_ARCHIVE_BASIC_TEXT_OPRIMITIVE_HPP
-#define BOOST_ARCHIVE_BASIC_TEXT_OPRIMITIVE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// basic_text_oprimitive.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-// archives stored as text - note these ar templated on the basic
-// stream templates to accommodate wide (and other?) kind of characters
-//
-// note the fact that on libraries without wide characters, ostream is
-// is not a specialization of basic_ostream which in fact is not defined
-// in such cases.   So we can't use basic_ostream<OStream::char_type> but rather
-// use two template parameters
-
-#include <iomanip>
-#include <locale>
-#include <cstddef> // size_t
-
-#include <boost/config.hpp>
-#include <boost/static_assert.hpp>
-#include <boost/io/ios_state.hpp>
-
-#include <boost/detail/workaround.hpp>
-#if BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, == 1)
-#include <boost/archive/dinkumware.hpp>
-#endif
-
-#if defined(BOOST_NO_STDC_NAMESPACE)
-namespace std{ 
-    using ::size_t;
-    #if ! defined(BOOST_DINKUMWARE_STDLIB) && ! defined(__SGI_STL_PORT)
-        using ::locale;
-    #endif
-} // namespace std
-#endif
-
-#include <boost/type_traits/is_floating_point.hpp>
-#include <boost/mpl/bool.hpp>
-#include <boost/limits.hpp>
-#include <boost/integer.hpp>
-#include <boost/io/ios_state.hpp>
-#include <boost/serialization/throw_exception.hpp>
-#include <boost/archive/basic_streambuf_locale_saver.hpp>
-#include <boost/archive/codecvt_null.hpp>
-#include <boost/archive/archive_exception.hpp>
-#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
-
-namespace boost {
-namespace archive {
-
-/////////////////////////////////////////////////////////////////////////
-// class basic_text_oprimitive - output of prmitives to stream
-template<class OStream>
-class BOOST_SYMBOL_VISIBLE basic_text_oprimitive
-{
-protected:
-    OStream &os;
-    io::ios_flags_saver flags_saver;
-    io::ios_precision_saver precision_saver;
-
-    #ifndef BOOST_NO_STD_LOCALE
-    // note order! - if you change this, libstd++ will fail!
-    // a) create new locale with new codecvt facet
-    // b) save current locale
-    // c) change locale to new one
-    // d) use stream buffer
-    // e) change locale back to original
-    // f) destroy new codecvt facet
-    boost::archive::codecvt_null<typename OStream::char_type> codecvt_null_facet;
-    std::locale archive_locale;
-    basic_ostream_locale_saver<
-        typename OStream::char_type,
-        typename OStream::traits_type
-    > locale_saver;
-    #endif
-
-    /////////////////////////////////////////////////////////
-    // fundamental types that need special treatment
-    void save(const bool t){
-        // trap usage of invalid uninitialized boolean which would
-        // otherwise crash on load.
-        BOOST_ASSERT(0 == static_cast<int>(t) || 1 == static_cast<int>(t));
-        if(os.fail())
-            boost::serialization::throw_exception(
-                archive_exception(archive_exception::output_stream_error)
-            );
-        os << t;
-    }
-    void save(const signed char t)
-    {
-        save(static_cast<short int>(t));
-    }
-    void save(const unsigned char t)
-    {
-        save(static_cast<short unsigned int>(t));
-    }
-    void save(const char t)
-    {
-        save(static_cast<short int>(t));
-    }
-    #ifndef BOOST_NO_INTRINSIC_WCHAR_T
-    void save(const wchar_t t)
-    {
-        BOOST_STATIC_ASSERT(sizeof(wchar_t) <= sizeof(int));
-        save(static_cast<int>(t));
-    }
-    #endif
-
-    /////////////////////////////////////////////////////////
-    // saving of any types not listed above
-
-    template<class T>
-    void save_impl(const T &t, boost::mpl::bool_<false> &){
-        if(os.fail())
-            boost::serialization::throw_exception(
-                archive_exception(archive_exception::output_stream_error)
-            );
-        os << t;
-    }
-
-    /////////////////////////////////////////////////////////
-    // floating point types need even more special treatment
-    // the following determines whether the type T is some sort
-    // of floating point type.  Note that we then assume that
-    // the stream << operator is defined on that type - if not
-    // we'll get a compile time error. This is meant to automatically
-    // support synthesized types which support floating point
-    // operations. Also it should handle compiler dependent types
-    // such long double.  Due to John Maddock.
-
-    template<class T>
-    struct is_float {
-        typedef typename mpl::bool_< 
-            boost::is_floating_point<T>::value 
-            || (std::numeric_limits<T>::is_specialized
-            && !std::numeric_limits<T>::is_integer
-            && !std::numeric_limits<T>::is_exact
-            && std::numeric_limits<T>::max_exponent) 
-        >::type type;
-    };
-
-    template<class T>
-    void save_impl(const T &t, boost::mpl::bool_<true> &){
-        // must be a user mistake - can't serialize un-initialized data
-        if(os.fail())
-            boost::serialization::throw_exception(
-                archive_exception(archive_exception::output_stream_error)
-            );
-        // The formulae for the number of decimla digits required is given in
-        // http://www2.open-std.org/JTC1/SC22/WG21/docs/papers/2005/n1822.pdf
-        // which is derived from Kahan's paper:
-        // www.eecs.berkeley.edu/~wkahan/ieee754status/ieee754.ps
-        // const unsigned int digits = (std::numeric_limits<T>::digits * 3010) / 10000;
-        // note: I've commented out the above because I didn't get good results.  e.g.
-        // in one case I got a difference of 19 units.
-        #ifndef BOOST_NO_CXX11_NUMERIC_LIMITS
-            const unsigned int digits = std::numeric_limits<T>::max_digits10;
-        #else
-            const unsigned int digits = std::numeric_limits<T>::digits10 + 2;
-        #endif
-        os << std::setprecision(digits) << std::scientific << t;
-    }
-
-    template<class T>
-    void save(const T & t){
-        typename is_float<T>::type tf;
-        save_impl(t, tf);
-    }
-
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL
-    basic_text_oprimitive(OStream & os, bool no_codecvt);
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL 
-    ~basic_text_oprimitive();
-public:
-    // unformatted append of one character
-    void put(typename OStream::char_type c){
-        if(os.fail())
-            boost::serialization::throw_exception(
-                archive_exception(archive_exception::output_stream_error)
-            );
-        os.put(c);
-    }
-    // unformatted append of null terminated string
-    void put(const char * s){
-        while('\0' != *s)
-            os.put(*s++);
-    }
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL void 
-    save_binary(const void *address, std::size_t count);
-};
-
-} //namespace boost 
-} //namespace archive 
-
-#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
-
-#endif // BOOST_ARCHIVE_BASIC_TEXT_OPRIMITIVE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/basic_xml_archive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/basic_xml_archive.hpp
deleted file mode 100644
index bef368b973b..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/basic_xml_archive.hpp
+++ /dev/null
@@ -1,67 +0,0 @@
-#ifndef BOOST_ARCHIVE_BASIC_XML_TEXT_ARCHIVE_HPP
-#define BOOST_ARCHIVE_BASIC_XML_TEXT_ARCHIVE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// basic_xml_archive.hpp:
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/archive/archive_exception.hpp>
-
-#include <boost/archive/detail/auto_link_archive.hpp>
-#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
-
-namespace boost { 
-namespace archive {
-
-// constant strings used in xml i/o
-
-extern 
-BOOST_ARCHIVE_DECL const char *
-BOOST_ARCHIVE_XML_OBJECT_ID();
-
-extern 
-BOOST_ARCHIVE_DECL const char *
-BOOST_ARCHIVE_XML_OBJECT_REFERENCE();
-
-extern 
-BOOST_ARCHIVE_DECL const char *
-BOOST_ARCHIVE_XML_CLASS_ID();
-
-extern 
-BOOST_ARCHIVE_DECL const char *
-BOOST_ARCHIVE_XML_CLASS_ID_REFERENCE();
-
-extern 
-BOOST_ARCHIVE_DECL const char *
-BOOST_ARCHIVE_XML_CLASS_NAME();
-
-extern 
-BOOST_ARCHIVE_DECL const char *
-BOOST_ARCHIVE_XML_TRACKING();
-
-extern 
-BOOST_ARCHIVE_DECL const char *
-BOOST_ARCHIVE_XML_VERSION();
-
-extern 
-BOOST_ARCHIVE_DECL const char *
-BOOST_ARCHIVE_XML_SIGNATURE();
-
-}// namespace archive
-}// namespace boost
-
-#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
-
-#endif // BOOST_ARCHIVE_BASIC_XML_TEXT_ARCHIVE_HPP
-
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/basic_xml_iarchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/basic_xml_iarchive.hpp
deleted file mode 100644
index e9f7482f744..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/basic_xml_iarchive.hpp
+++ /dev/null
@@ -1,119 +0,0 @@
-#ifndef BOOST_ARCHIVE_BASIC_XML_IARCHIVE_HPP
-#define BOOST_ARCHIVE_BASIC_XML_IARCHIVE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// basic_xml_iarchive.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/config.hpp>
-#include <boost/mpl/assert.hpp>
-
-#include <boost/archive/detail/common_iarchive.hpp>
-#include <boost/serialization/nvp.hpp>
-#include <boost/serialization/string.hpp>
-
-#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
-
-#ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable : 4511 4512)
-#endif
-
-namespace boost {
-namespace archive {
-
-namespace detail {
-    template<class Archive> class interface_iarchive;
-} // namespace detail
-
-/////////////////////////////////////////////////////////////////////////
-// class basic_xml_iarchive - read serialized objects from a input text stream
-template<class Archive>
-class BOOST_SYMBOL_VISIBLE basic_xml_iarchive :
-    public detail::common_iarchive<Archive>
-{
-    unsigned int depth;
-#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
-public:
-#else
-protected:
-    friend class detail::interface_iarchive<Archive>;
-#endif
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-    load_start(const char *name);
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-    load_end(const char *name);
-
-    // Anything not an attribute and not a name-value pair is an
-    // should be trapped here.
-    template<class T>
-    void load_override(T & t)
-    {
-        // If your program fails to compile here, its most likely due to
-        // not specifying an nvp wrapper around the variable to
-        // be serialized.
-        BOOST_MPL_ASSERT((serialization::is_wrapper< T >));
-        this->detail_common_iarchive::load_override(t);
-    }
-
-    // Anything not an attribute - see below - should be a name value
-    // pair and be processed here
-    typedef detail::common_iarchive<Archive> detail_common_iarchive;
-    template<class T>
-    void load_override(
-        const boost::serialization::nvp< T > & t
-    ){
-        this->This()->load_start(t.name());
-        this->detail_common_iarchive::load_override(t.value());
-        this->This()->load_end(t.name());
-    }
-
-    // specific overrides for attributes - handle as
-    // primitives. These are not name-value pairs
-    // so they have to be intercepted here and passed on to load.
-    // although the class_id is included in the xml text file in order
-    // to make the file self describing, it isn't used when loading
-    // an xml archive.  So we can skip it here.  Note: we MUST override
-    // it otherwise it will be loaded as a normal primitive w/o tag and
-    // leaving the archive in an undetermined state
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-    load_override(class_id_type & t);
-    void load_override(class_id_optional_type & /* t */){}
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-    load_override(object_id_type & t);
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-    load_override(version_type & t);
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-    load_override(tracking_type & t);
-    // class_name_type can't be handled here as it depends upon the
-    // char type used by the stream.  So require the derived implementation
-    // handle this.
-    // void load_override(class_name_type & t);
-
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL
-    basic_xml_iarchive(unsigned int flags);
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL
-    ~basic_xml_iarchive();
-};
-
-} // namespace archive
-} // namespace boost
-
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
-
-#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
-
-#endif // BOOST_ARCHIVE_BASIC_XML_IARCHIVE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/basic_xml_oarchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/basic_xml_oarchive.hpp
deleted file mode 100644
index 107fca4ec65..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/basic_xml_oarchive.hpp
+++ /dev/null
@@ -1,138 +0,0 @@
-#ifndef BOOST_ARCHIVE_BASIC_XML_OARCHIVE_HPP
-#define BOOST_ARCHIVE_BASIC_XML_OARCHIVE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// basic_xml_oarchive.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/config.hpp>
-#include <boost/mpl/assert.hpp>
-
-#include <boost/archive/detail/common_oarchive.hpp>
-#include <boost/serialization/nvp.hpp>
-#include <boost/serialization/string.hpp>
-
-#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
-
-#ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable : 4511 4512)
-#endif
-
-namespace boost {
-namespace archive {
-
-namespace detail {
-    template<class Archive> class interface_oarchive;
-} // namespace detail
-
-//////////////////////////////////////////////////////////////////////
-// class basic_xml_oarchive - write serialized objects to a xml output stream
-template<class Archive>
-class BOOST_SYMBOL_VISIBLE basic_xml_oarchive :
-    public detail::common_oarchive<Archive>
-{
-    // special stuff for xml output
-    unsigned int depth;
-    bool pending_preamble;
-#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
-public:
-#else
-protected:
-    friend class detail::interface_oarchive<Archive>;
-#endif
-    bool indent_next;
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-    indent();
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-    init();
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-    windup();
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-    write_attribute(
-        const char *attribute_name,
-        int t,
-        const char *conjunction = "=\""
-    );
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-    write_attribute(
-        const char *attribute_name,
-        const char *key
-    );
-    // helpers used below
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-    save_start(const char *name);
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-    save_end(const char *name);
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-    end_preamble();
-
-    // Anything not an attribute and not a name-value pair is an
-    // error and should be trapped here.
-    template<class T>
-    void save_override(T & t)
-    {
-        // If your program fails to compile here, its most likely due to
-        // not specifying an nvp wrapper around the variable to
-        // be serialized.
-        BOOST_MPL_ASSERT((serialization::is_wrapper< T >));
-        this->detail_common_oarchive::save_override(t);
-    }
-
-    // special treatment for name-value pairs.
-    typedef detail::common_oarchive<Archive> detail_common_oarchive;
-    template<class T>
-    void save_override(
-        const ::boost::serialization::nvp< T > & t
-    ){
-        this->This()->save_start(t.name());
-        this->detail_common_oarchive::save_override(t.const_value());
-        this->This()->save_end(t.name());
-    }
-
-    // specific overrides for attributes - not name value pairs so we
-    // want to trap them before the above "fall through"
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-    save_override(const class_id_type & t);
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-    save_override(const class_id_optional_type & t);
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-    save_override(const class_id_reference_type & t);
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-    save_override(const object_id_type & t);
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-    save_override(const object_reference_type & t);
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-    save_override(const version_type & t);
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-    save_override(const class_name_type & t);
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-    save_override(const tracking_type & t);
-
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL
-    basic_xml_oarchive(unsigned int flags);
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL
-    ~basic_xml_oarchive();
-};
-
-} // namespace archive
-} // namespace boost
-
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
-
-#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
-
-#endif // BOOST_ARCHIVE_BASIC_XML_OARCHIVE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/binary_iarchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/binary_iarchive.hpp
deleted file mode 100644
index 785ce7610b1..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/binary_iarchive.hpp
+++ /dev/null
@@ -1,64 +0,0 @@
-#ifndef BOOST_ARCHIVE_BINARY_IARCHIVE_HPP
-#define BOOST_ARCHIVE_BINARY_IARCHIVE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// binary_iarchive.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <istream>
-#include <boost/archive/binary_iarchive_impl.hpp>
-#include <boost/archive/detail/register_archive.hpp>
-
-#ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable : 4511 4512)
-#endif
-
-namespace boost {
-namespace archive {
-
-// do not derive from this class.  If you want to extend this functionality
-// via inhertance, derived from binary_iarchive_impl instead.  This will
-// preserve correct static polymorphism.
-class BOOST_SYMBOL_VISIBLE binary_iarchive :
-    public binary_iarchive_impl<
-        boost::archive::binary_iarchive, 
-        std::istream::char_type, 
-        std::istream::traits_type
-    >{
-public:
-    binary_iarchive(std::istream & is, unsigned int flags = 0) :
-        binary_iarchive_impl<
-            binary_iarchive, std::istream::char_type, std::istream::traits_type
-        >(is, flags)
-    {}
-    binary_iarchive(std::streambuf & bsb, unsigned int flags = 0) :
-        binary_iarchive_impl<
-            binary_iarchive, std::istream::char_type, std::istream::traits_type
-        >(bsb, flags)
-    {}
-};
-
-} // namespace archive
-} // namespace boost
-
-// required by export
-BOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::binary_iarchive)
-BOOST_SERIALIZATION_USE_ARRAY_OPTIMIZATION(boost::archive::binary_iarchive)
-
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
-
-#endif // BOOST_ARCHIVE_BINARY_IARCHIVE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/binary_iarchive_impl.hpp b/contrib/libboost/boost_1_65_0/boost/archive/binary_iarchive_impl.hpp
deleted file mode 100644
index b4747c98ece..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/binary_iarchive_impl.hpp
+++ /dev/null
@@ -1,105 +0,0 @@
-#ifndef BOOST_ARCHIVE_BINARY_IARCHIVE_IMPL_HPP
-#define BOOST_ARCHIVE_BINARY_IARCHIVE_IMPL_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// binary_iarchive_impl.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <istream>
-#include <boost/archive/basic_binary_iprimitive.hpp>
-#include <boost/archive/basic_binary_iarchive.hpp>
-
-#ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable : 4511 4512)
-#endif
-
-namespace boost { 
-namespace archive {
-
-namespace detail {
-    template<class Archive> class interface_iarchive;
-} // namespace detail
-
-template<class Archive, class Elem, class Tr>
-class BOOST_SYMBOL_VISIBLE binary_iarchive_impl : 
-    public basic_binary_iprimitive<Archive, Elem, Tr>,
-    public basic_binary_iarchive<Archive>
-{
-#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
-public:
-#else
-protected:
-    #if BOOST_WORKAROUND(BOOST_MSVC, < 1500)
-        // for some inexplicable reason insertion of "class" generates compile erro
-        // on msvc 7.1
-        friend detail::interface_iarchive<Archive>;
-        friend basic_binary_iarchive<Archive>;
-        friend load_access;
-    #else
-        friend class detail::interface_iarchive<Archive>;
-        friend class basic_binary_iarchive<Archive>;
-        friend class load_access;
-    #endif
-#endif
-    template<class T>
-    void load_override(T & t){
-        this->basic_binary_iarchive<Archive>::load_override(t);
-    }
-    void init(unsigned int flags){
-        if(0 != (flags & no_header)){
-            return;
-        }
-        #if ! defined(__MWERKS__)
-            this->basic_binary_iarchive<Archive>::init();
-            this->basic_binary_iprimitive<Archive, Elem, Tr>::init();
-        #else
-            basic_binary_iarchive<Archive>::init();
-            basic_binary_iprimitive<Archive, Elem, Tr>::init();
-        #endif
-    }
-    binary_iarchive_impl(
-        std::basic_streambuf<Elem, Tr> & bsb, 
-        unsigned int flags
-    ) :
-        basic_binary_iprimitive<Archive, Elem, Tr>(
-            bsb, 
-            0 != (flags & no_codecvt)
-        ),
-        basic_binary_iarchive<Archive>(flags)
-    {
-        init(flags);
-    }
-    binary_iarchive_impl(
-        std::basic_istream<Elem, Tr> & is, 
-        unsigned int flags
-    ) :
-        basic_binary_iprimitive<Archive, Elem, Tr>(
-            * is.rdbuf(), 
-            0 != (flags & no_codecvt)
-        ),
-        basic_binary_iarchive<Archive>(flags)
-    {
-        init(flags);
-    }
-};
-
-} // namespace archive
-} // namespace boost
-
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
-
-#endif // BOOST_ARCHIVE_BINARY_IARCHIVE_IMPL_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/binary_oarchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/binary_oarchive.hpp
deleted file mode 100644
index e8313fd7c95..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/binary_oarchive.hpp
+++ /dev/null
@@ -1,64 +0,0 @@
-#ifndef BOOST_ARCHIVE_BINARY_OARCHIVE_HPP
-#define BOOST_ARCHIVE_BINARY_OARCHIVE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// binary_oarchive.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <ostream>
-#include <boost/config.hpp>
-#include <boost/archive/binary_oarchive_impl.hpp>
-#include <boost/archive/detail/register_archive.hpp>
-
-#ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable : 4511 4512)
-#endif
-
-namespace boost { 
-namespace archive {
-
-// do not derive from this class.  If you want to extend this functionality
-// via inhertance, derived from binary_oarchive_impl instead.  This will
-// preserve correct static polymorphism.
-class BOOST_SYMBOL_VISIBLE binary_oarchive : 
-    public binary_oarchive_impl<
-        binary_oarchive, std::ostream::char_type, std::ostream::traits_type
-    >
-{
-public:
-    binary_oarchive(std::ostream & os, unsigned int flags = 0) :
-        binary_oarchive_impl<
-            binary_oarchive, std::ostream::char_type, std::ostream::traits_type
-        >(os, flags)
-    {}
-    binary_oarchive(std::streambuf & bsb, unsigned int flags = 0) :
-        binary_oarchive_impl<
-            binary_oarchive, std::ostream::char_type, std::ostream::traits_type
-        >(bsb, flags)
-    {}
-};
-
-} // namespace archive
-} // namespace boost
-
-// required by export
-BOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::binary_oarchive)
-BOOST_SERIALIZATION_USE_ARRAY_OPTIMIZATION(boost::archive::binary_oarchive)
-
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
-
-#endif // BOOST_ARCHIVE_BINARY_OARCHIVE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/binary_oarchive_impl.hpp b/contrib/libboost/boost_1_65_0/boost/archive/binary_oarchive_impl.hpp
deleted file mode 100644
index 6b4d018a564..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/binary_oarchive_impl.hpp
+++ /dev/null
@@ -1,106 +0,0 @@
-#ifndef BOOST_ARCHIVE_BINARY_OARCHIVE_IMPL_HPP
-#define BOOST_ARCHIVE_BINARY_OARCHIVE_IMPL_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// binary_oarchive_impl.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <ostream>
-#include <boost/config.hpp>
-#include <boost/archive/basic_binary_oprimitive.hpp>
-#include <boost/archive/basic_binary_oarchive.hpp>
-
-#ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable : 4511 4512)
-#endif
-
-namespace boost { 
-namespace archive {
-
-namespace detail {
-    template<class Archive> class interface_oarchive;
-} // namespace detail
-
-template<class Archive, class Elem, class Tr>
-class BOOST_SYMBOL_VISIBLE binary_oarchive_impl : 
-    public basic_binary_oprimitive<Archive, Elem, Tr>,
-    public basic_binary_oarchive<Archive>
-{
-#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
-public:
-#else
-protected:
-    #if BOOST_WORKAROUND(BOOST_MSVC, < 1500)
-        // for some inexplicable reason insertion of "class" generates compile erro
-        // on msvc 7.1
-        friend detail::interface_oarchive<Archive>;
-        friend basic_binary_oarchive<Archive>;
-        friend save_access;
-    #else
-        friend class detail::interface_oarchive<Archive>;
-        friend class basic_binary_oarchive<Archive>;
-        friend class save_access;
-    #endif
-#endif
-    template<class T>
-    void save_override(T & t){
-        this->basic_binary_oarchive<Archive>::save_override(t);
-    }
-    void init(unsigned int flags) {
-        if(0 != (flags & no_header)){
-            return;
-        }
-        #if ! defined(__MWERKS__)
-            this->basic_binary_oarchive<Archive>::init();
-            this->basic_binary_oprimitive<Archive, Elem, Tr>::init();
-        #else
-            basic_binary_oarchive<Archive>::init();
-            basic_binary_oprimitive<Archive, Elem, Tr>::init();
-        #endif
-    }
-    binary_oarchive_impl(
-        std::basic_streambuf<Elem, Tr> & bsb, 
-        unsigned int flags
-    ) :
-        basic_binary_oprimitive<Archive, Elem, Tr>(
-            bsb, 
-            0 != (flags & no_codecvt)
-        ),
-        basic_binary_oarchive<Archive>(flags)
-    {
-        init(flags);
-    }
-    binary_oarchive_impl(
-        std::basic_ostream<Elem, Tr> & os, 
-        unsigned int flags
-    ) :
-        basic_binary_oprimitive<Archive, Elem, Tr>(
-            * os.rdbuf(), 
-            0 != (flags & no_codecvt)
-        ),
-        basic_binary_oarchive<Archive>(flags)
-    {
-        init(flags);
-    }
-};
-
-} // namespace archive
-} // namespace boost
-
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
-
-#endif // BOOST_ARCHIVE_BINARY_OARCHIVE_IMPL_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/binary_wiarchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/binary_wiarchive.hpp
deleted file mode 100644
index 775d8f82726..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/binary_wiarchive.hpp
+++ /dev/null
@@ -1,56 +0,0 @@
-#ifndef BOOST_ARCHIVE_BINARY_WIARCHIVE_HPP
-#define BOOST_ARCHIVE_BINARY_WIARCHIVE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// binary_wiarchive.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/config.hpp>
-#ifdef BOOST_NO_STD_WSTREAMBUF
-#error "wide char i/o not supported on this platform"
-#else
-
-#include <istream> // wistream
-#include <boost/archive/binary_iarchive_impl.hpp>
-#include <boost/archive/detail/register_archive.hpp>
-
-namespace boost { 
-namespace archive {
-
-class binary_wiarchive : 
-    public binary_iarchive_impl<
-        binary_wiarchive, std::wistream::char_type, std::wistream::traits_type
-    >
-{
-public:
-    binary_wiarchive(std::wistream & is, unsigned int flags = 0) :
-        binary_iarchive_impl<
-            binary_wiarchive, std::wistream::char_type, std::wistream::traits_type
-        >(is, flags)
-    {}
-    binary_wiarchive(std::wstreambuf & bsb, unsigned int flags = 0) :
-        binary_iarchive_impl<
-            binary_wiarchive, std::wistream::char_type, std::wistream::traits_type
-        >(bsb, flags)
-    {}
-};
-
-} // namespace archive
-} // namespace boost
-
-// required by export
-BOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::binary_wiarchive)
-
-#endif // BOOST_NO_STD_WSTREAMBUF
-#endif // BOOST_ARCHIVE_BINARY_WIARCHIVE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/binary_woarchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/binary_woarchive.hpp
deleted file mode 100644
index a8817d6f8b4..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/binary_woarchive.hpp
+++ /dev/null
@@ -1,59 +0,0 @@
-#ifndef BOOST_ARCHIVE_BINARY_WOARCHIVE_HPP
-#define BOOST_ARCHIVE_BINARY_WOARCHIVE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// binary_woarchive.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/config.hpp>
-#ifdef BOOST_NO_STD_WSTREAMBUF
-#error "wide char i/o not supported on this platform"
-#else
-
-#include <ostream>
-#include <boost/archive/binary_oarchive_impl.hpp>
-#include <boost/archive/detail/register_archive.hpp>
-
-namespace boost { 
-namespace archive {
-
-// do not derive from this class.  If you want to extend this functionality
-// via inhertance, derived from binary_oarchive_impl instead.  This will
-// preserve correct static polymorphism.
-class binary_woarchive : 
-    public binary_oarchive_impl<
-            binary_woarchive, std::wostream::char_type, std::wostream::traits_type
-        >
-{
-public:
-    binary_woarchive(std::wostream & os, unsigned int flags = 0) :
-        binary_oarchive_impl<
-            binary_woarchive, std::wostream::char_type, std::wostream::traits_type
-        >(os, flags)
-    {}
-    binary_woarchive(std::wstreambuf & bsb, unsigned int flags = 0) :
-        binary_oarchive_impl<
-            binary_woarchive, std::wostream::char_type, std::wostream::traits_type
-        >(bsb, flags)
-    {}
-};
-
-} // namespace archive
-} // namespace boost
-
-// required by export
-BOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::binary_woarchive)
-
-#endif // BOOST_NO_STD_WSTREAMBUF
-#endif // BOOST_ARCHIVE_BINARY_WOARCHIVE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/codecvt_null.hpp b/contrib/libboost/boost_1_65_0/boost/archive/codecvt_null.hpp
deleted file mode 100644
index 7bce2b9b329..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/codecvt_null.hpp
+++ /dev/null
@@ -1,109 +0,0 @@
-#ifndef BOOST_ARCHIVE_CODECVT_NULL_HPP
-#define BOOST_ARCHIVE_CODECVT_NULL_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// codecvt_null.hpp:
-
-// (C) Copyright 2004 Robert Ramey - http://www.rrsd.com .
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <locale>
-#include <cstddef> // NULL, size_t
-#ifndef BOOST_NO_CWCHAR
-#include <cwchar>   // for mbstate_t
-#endif
-#include <boost/config.hpp>
-#include <boost/serialization/force_include.hpp>
-#include <boost/archive/detail/auto_link_archive.hpp>
-#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
-
-#if defined(BOOST_NO_STDC_NAMESPACE)
-namespace std {
-// For STLport on WinCE, BOOST_NO_STDC_NAMESPACE can get defined if STLport is putting symbols in its own namespace.
-// In the case of codecvt, however, this does not mean that codecvt is in the global namespace (it will be in STLport's namespace)
-#  if !defined(__SGI_STL_PORT) && !defined(_STLPORT_VERSION)
-    using ::codecvt;
-#  endif
-    using ::mbstate_t;
-    using ::size_t;
-} // namespace
-#endif
-
-#ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable : 4511 4512)
-#endif
-
-namespace boost {
-namespace archive {
-
-template<class Ch>
-class codecvt_null;
-
-template<>
-class codecvt_null<char> : public std::codecvt<char, char, std::mbstate_t>
-{
-    virtual bool do_always_noconv() const throw() {
-        return true;
-    }
-public:
-    explicit codecvt_null(std::size_t no_locale_manage = 0) :
-        std::codecvt<char, char, std::mbstate_t>(no_locale_manage)
-    {}
-    virtual ~codecvt_null(){};
-};
-
-template<>
-class BOOST_SYMBOL_VISIBLE codecvt_null<wchar_t> : public std::codecvt<wchar_t, char, std::mbstate_t>
-{
-    virtual BOOST_WARCHIVE_DECL BOOST_DLLEXPORT std::codecvt_base::result
-    do_out(
-        std::mbstate_t & state,
-        const wchar_t * first1,
-        const wchar_t * last1,
-        const wchar_t * & next1,
-        char * first2,
-        char * last2,
-        char * & next2
-    ) const BOOST_USED;
-    virtual BOOST_WARCHIVE_DECL BOOST_DLLEXPORT std::codecvt_base::result
-    do_in(
-        std::mbstate_t & state,
-        const char * first1,
-        const char * last1,
-        const char * & next1,
-        wchar_t * first2,
-        wchar_t * last2,
-        wchar_t * & next2
-    ) const BOOST_USED;
-    virtual int do_encoding( ) const throw( ){
-        return sizeof(wchar_t) / sizeof(char);
-    }
-    virtual int do_max_length( ) const throw( ){
-        return do_encoding();
-    }
-public:
-    BOOST_DLLEXPORT explicit codecvt_null(std::size_t no_locale_manage = 0) :
-        std::codecvt<wchar_t, char, std::mbstate_t>(no_locale_manage)
-    {}
-    virtual ~codecvt_null(){};
-};
-
-} // namespace archive
-} // namespace boost
-
-#ifdef BOOST_MSVC
-#  pragma warning(pop)
-#endif
-#include <boost/archive/detail/abi_suffix.hpp> // pop pragmas
-
-#endif //BOOST_ARCHIVE_CODECVT_NULL_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/detail/abi_prefix.hpp b/contrib/libboost/boost_1_65_0/boost/archive/detail/abi_prefix.hpp
deleted file mode 100644
index debf79e9f0b..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/detail/abi_prefix.hpp
+++ /dev/null
@@ -1,16 +0,0 @@
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// abi_prefix.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/config/abi_prefix.hpp> // must be the last header
-#ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable : 4251 4231 4660 4275)
-#endif
-
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/detail/abi_suffix.hpp b/contrib/libboost/boost_1_65_0/boost/archive/detail/abi_suffix.hpp
deleted file mode 100644
index 4e054d66214..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/detail/abi_suffix.hpp
+++ /dev/null
@@ -1,15 +0,0 @@
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// abi_suffix.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
-#include <boost/config/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
-
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/detail/archive_serializer_map.hpp b/contrib/libboost/boost_1_65_0/boost/archive/detail/archive_serializer_map.hpp
deleted file mode 100644
index 5432bfc73e7..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/detail/archive_serializer_map.hpp
+++ /dev/null
@@ -1,54 +0,0 @@
-#ifndef BOOST_ARCHIVE_SERIALIZER_MAP_HPP
-#define BOOST_ARCHIVE_SERIALIZER_MAP_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// archive_serializer_map.hpp: extenstion of type_info required for 
-// serialization.
-
-// (C) Copyright 2009 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-// note: this is nothing more than the thinest of wrappers around
-// basic_serializer_map so we can have a one map / archive type. 
-
-#include <boost/config.hpp>
-#include <boost/archive/detail/auto_link_archive.hpp>
-#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
-
-namespace boost {
-
-namespace serialization {
-    class extended_type_info;
-} // namespace serialization
-
-namespace archive {
-namespace detail {
-
-class basic_serializer;
-
-template<class Archive>
-class BOOST_SYMBOL_VISIBLE archive_serializer_map {
-public:
-    static BOOST_ARCHIVE_OR_WARCHIVE_DECL bool insert(const basic_serializer * bs);
-    static BOOST_ARCHIVE_OR_WARCHIVE_DECL void erase(const basic_serializer * bs);
-    static BOOST_ARCHIVE_OR_WARCHIVE_DECL const basic_serializer * find(
-        const boost::serialization::extended_type_info & type_
-    );
-};
-
-} // namespace detail
-} // namespace archive
-} // namespace boost
-
-#include <boost/archive/detail/abi_suffix.hpp> // must be the last header
-
-#endif //BOOST_ARCHIVE_SERIALIZER_MAP_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/detail/auto_link_archive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/detail/auto_link_archive.hpp
deleted file mode 100644
index 79b0e490d65..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/detail/auto_link_archive.hpp
+++ /dev/null
@@ -1,48 +0,0 @@
-#ifndef BOOST_ARCHIVE_DETAIL_AUTO_LINK_ARCHIVE_HPP
-#define BOOST_ARCHIVE_DETAIL_AUTO_LINK_ARCHIVE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-//  auto_link_archive.hpp
-//
-//  (c) Copyright Robert Ramey 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)
-
-//  See library home page at http://www.boost.org/libs/serialization
-
-//----------------------------------------------------------------------------// 
-
-// This header implements separate compilation features as described in
-// http://www.boost.org/more/separate_compilation.html
-
-//  enable automatic library variant selection  ------------------------------// 
-
-#include <boost/archive/detail/decl.hpp>
-
-#if !defined(BOOST_ALL_NO_LIB) && !defined(BOOST_SERIALIZATION_NO_LIB) \
-&&  !defined(BOOST_ARCHIVE_SOURCE) && !defined(BOOST_WARCHIVE_SOURCE)  \
-&&  !defined(BOOST_SERIALIZATION_SOURCE)
-
-    // Set the name of our library, this will get undef'ed by auto_link.hpp
-    // once it's done with it:
-    //
-    #define BOOST_LIB_NAME boost_serialization
-    //
-    // If we're importing code from a dll, then tell auto_link.hpp about it:
-    //
-    #if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_SERIALIZATION_DYN_LINK)
-    #  define BOOST_DYN_LINK
-    #endif
-    //
-    // And include the header that does the work:
-    //
-    #include <boost/config/auto_link.hpp>
-#endif  // auto-linking disabled
-
-#endif // BOOST_ARCHIVE_DETAIL_AUTO_LINK_ARCHIVE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/detail/auto_link_warchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/detail/auto_link_warchive.hpp
deleted file mode 100644
index 683d191c20d..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/detail/auto_link_warchive.hpp
+++ /dev/null
@@ -1,47 +0,0 @@
-#ifndef BOOST_ARCHIVE_DETAIL_AUTO_LINK_WARCHIVE_HPP
-#define BOOST_ARCHIVE_DETAIL_AUTO_LINK_WARCHIVE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-//  auto_link_warchive.hpp
-//
-//  (c) Copyright Robert Ramey 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)
-
-//  See library home page at http://www.boost.org/libs/serialization
-
-//----------------------------------------------------------------------------// 
-
-// This header implements separate compilation features as described in
-// http://www.boost.org/more/separate_compilation.html
-
-//  enable automatic library variant selection  ------------------------------// 
-
-#include <boost/archive/detail/decl.hpp>
-
-#if !defined(BOOST_WARCHIVE_SOURCE) \
-&& !defined(BOOST_ALL_NO_LIB) && !defined(BOOST_SERIALIZATION_NO_LIB)
-
-// Set the name of our library, this will get undef'ed by auto_link.hpp
-// once it's done with it:
-//
-#define BOOST_LIB_NAME boost_wserialization
-//
-// If we're importing code from a dll, then tell auto_link.hpp about it:
-//
-#if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_SERIALIZATION_DYN_LINK)
-#  define BOOST_DYN_LINK
-#endif
-//
-// And include the header that does the work:
-//
-#include <boost/config/auto_link.hpp>
-#endif  // auto-linking disabled
-
-#endif // ARCHIVE_DETAIL_AUTO_LINK_ARCHIVE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/detail/basic_iarchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/detail/basic_iarchive.hpp
deleted file mode 100644
index 1f5a8bf63bf..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/detail/basic_iarchive.hpp
+++ /dev/null
@@ -1,105 +0,0 @@
-#ifndef BOOST_ARCHIVE_DETAIL_BASIC_IARCHIVE_HPP
-#define BOOST_ARCHIVE_DETAIL_BASIC_IARCHIVE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// basic_iarchive.hpp:
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-// can't use this - much as I'd like to as borland doesn't support it
-
-#include <boost/config.hpp>
-#include <boost/noncopyable.hpp>
-#include <boost/scoped_ptr.hpp>
-
-#include <boost/serialization/tracking_enum.hpp>
-#include <boost/archive/basic_archive.hpp>
-#include <boost/archive/detail/decl.hpp>
-#include <boost/archive/detail/helper_collection.hpp>
-#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
-
-namespace boost {
-namespace serialization {
-    class extended_type_info;
-} // namespace serialization
-
-namespace archive {
-namespace detail {
-
-class basic_iarchive_impl;
-class basic_iserializer;
-class basic_pointer_iserializer;
-
-//////////////////////////////////////////////////////////////////////
-// class basic_iarchive - read serialized objects from a input stream
-class BOOST_SYMBOL_VISIBLE basic_iarchive :
-    private boost::noncopyable,
-    public boost::archive::detail::helper_collection
-{
-    friend class basic_iarchive_impl;
-    // hide implementation of this class to minimize header conclusion
-    boost::scoped_ptr<basic_iarchive_impl> pimpl;
-
-    virtual void vload(version_type &t) =  0;
-    virtual void vload(object_id_type &t) =  0;
-    virtual void vload(class_id_type &t) =  0;
-    virtual void vload(class_id_optional_type &t) = 0;
-    virtual void vload(class_name_type &t) = 0;
-    virtual void vload(tracking_type &t) = 0;
-protected:
-    BOOST_ARCHIVE_DECL basic_iarchive(unsigned int flags);
-    boost::archive::detail::helper_collection &
-    get_helper_collection(){
-        return *this;
-    }
-public:
-    // some msvc versions require that the following function be public
-    // otherwise it should really protected.
-    virtual BOOST_ARCHIVE_DECL ~basic_iarchive();
-    // note: NOT part of the public API.
-    BOOST_ARCHIVE_DECL void next_object_pointer(void *t);
-    BOOST_ARCHIVE_DECL void register_basic_serializer(
-        const basic_iserializer & bis
-    );
-    BOOST_ARCHIVE_DECL void load_object(
-        void *t, 
-        const basic_iserializer & bis
-    );
-    BOOST_ARCHIVE_DECL const basic_pointer_iserializer * 
-    load_pointer(
-        void * & t, 
-        const basic_pointer_iserializer * bpis_ptr,
-        const basic_pointer_iserializer * (*finder)(
-            const boost::serialization::extended_type_info & eti
-        )
-    );
-    // real public API starts here
-    BOOST_ARCHIVE_DECL void 
-    set_library_version(library_version_type archive_library_version);
-    BOOST_ARCHIVE_DECL library_version_type 
-    get_library_version() const;
-    BOOST_ARCHIVE_DECL unsigned int
-    get_flags() const;
-    BOOST_ARCHIVE_DECL void 
-    reset_object_address(const void * new_address, const void * old_address);
-    BOOST_ARCHIVE_DECL void 
-    delete_created_pointers();
-};
-
-} // namespace detail
-} // namespace archive
-} // namespace boost
-
-#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
-
-#endif //BOOST_ARCHIVE_DETAIL_BASIC_IARCHIVE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/detail/basic_iserializer.hpp b/contrib/libboost/boost_1_65_0/boost/archive/detail/basic_iserializer.hpp
deleted file mode 100644
index 0d66674c349..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/detail/basic_iserializer.hpp
+++ /dev/null
@@ -1,91 +0,0 @@
-#ifndef BOOST_ARCHIVE_DETAIL_BASIC_ISERIALIZER_HPP
-#define BOOST_ARCHIVE_DETAIL_BASIC_ISERIALIZER_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// basic_iserializer.hpp: extenstion of type_info required for serialization.
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <cstdlib> // NULL
-#include <boost/config.hpp>
-
-#include <boost/archive/basic_archive.hpp>
-#include <boost/archive/detail/decl.hpp>
-#include <boost/archive/detail/basic_serializer.hpp>
-#include <boost/archive/detail/auto_link_archive.hpp>
-#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
-
-#ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable : 4511 4512)
-#endif
-
-namespace boost {
-namespace serialization {
-    class extended_type_info;
-} // namespace serialization
-
-// forward declarations
-namespace archive {
-namespace detail {
-
-class basic_iarchive;
-class basic_pointer_iserializer;
-
-class BOOST_SYMBOL_VISIBLE basic_iserializer : 
-    public basic_serializer
-{
-private:
-    basic_pointer_iserializer *m_bpis;
-protected:
-    explicit BOOST_ARCHIVE_DECL basic_iserializer(
-        const boost::serialization::extended_type_info & type
-    );
-    virtual BOOST_ARCHIVE_DECL ~basic_iserializer();
-public:
-    bool serialized_as_pointer() const {
-        return m_bpis != NULL;
-    }
-    void set_bpis(basic_pointer_iserializer *bpis){
-        m_bpis = bpis;
-    }
-    const basic_pointer_iserializer * get_bpis_ptr() const {
-        return m_bpis;
-    }
-    virtual void load_object_data(
-        basic_iarchive & ar, 
-        void *x,
-        const unsigned int file_version
-    ) const = 0;
-    // returns true if class_info should be saved
-    virtual bool class_info() const = 0 ;
-    // returns true if objects should be tracked
-    virtual bool tracking(const unsigned int) const = 0 ;
-    // returns class version
-    virtual version_type version() const = 0 ;
-    // returns true if this class is polymorphic
-    virtual bool is_polymorphic() const = 0;
-    virtual void destroy(/*const*/ void *address) const = 0 ;
-};
-
-} // namespae detail
-} // namespace archive
-} // namespace boost
-
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
-
-#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
-
-#endif // BOOST_ARCHIVE_DETAIL_BASIC_ISERIALIZER_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/detail/basic_oarchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/detail/basic_oarchive.hpp
deleted file mode 100644
index c379108d584..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/detail/basic_oarchive.hpp
+++ /dev/null
@@ -1,94 +0,0 @@
-#ifndef BOOST_ARCHIVE_BASIC_OARCHIVE_HPP
-#define BOOST_ARCHIVE_BASIC_OARCHIVE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// basic_oarchive.hpp:
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <cstddef> // NULL
-#include <boost/config.hpp>
-#include <boost/noncopyable.hpp>
-#include <boost/scoped_ptr.hpp>
-
-#include <boost/archive/basic_archive.hpp>
-#include <boost/serialization/tracking_enum.hpp>
-#include <boost/archive/detail/helper_collection.hpp>
-#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
-
-namespace boost {
-namespace serialization {
-    class extended_type_info;
-} // namespace serialization
-
-namespace archive {
-namespace detail {
-
-class basic_oarchive_impl;
-class basic_oserializer;
-class basic_pointer_oserializer;
-
-//////////////////////////////////////////////////////////////////////
-// class basic_oarchive - write serialized objects to an output stream
-class BOOST_SYMBOL_VISIBLE basic_oarchive :
-    private boost::noncopyable,
-    public boost::archive::detail::helper_collection
-{
-    friend class basic_oarchive_impl;
-    // hide implementation of this class to minimize header conclusion
-    boost::scoped_ptr<basic_oarchive_impl> pimpl;
-
-    // overload these to bracket object attributes. Used to implement
-    // xml archives
-    virtual void vsave(const version_type t) =  0;
-    virtual void vsave(const object_id_type t) =  0;
-    virtual void vsave(const object_reference_type t) =  0;
-    virtual void vsave(const class_id_type t) =  0;
-    virtual void vsave(const class_id_optional_type t) = 0;
-    virtual void vsave(const class_id_reference_type t) =  0;
-    virtual void vsave(const class_name_type & t) = 0;
-    virtual void vsave(const tracking_type t) = 0;
-protected:
-    BOOST_ARCHIVE_DECL basic_oarchive(unsigned int flags = 0);
-    BOOST_ARCHIVE_DECL boost::archive::detail::helper_collection &
-    get_helper_collection();
-    virtual BOOST_ARCHIVE_DECL ~basic_oarchive();
-public:
-    // note: NOT part of the public interface
-    BOOST_ARCHIVE_DECL void register_basic_serializer(
-        const basic_oserializer & bos
-    );
-    BOOST_ARCHIVE_DECL void save_object(
-        const void *x, 
-        const basic_oserializer & bos
-    );
-    BOOST_ARCHIVE_DECL void save_pointer(
-        const void * t, 
-        const basic_pointer_oserializer * bpos_ptr
-    );
-    void save_null_pointer(){
-        vsave(NULL_POINTER_TAG);
-    }
-    // real public interface starts here
-    BOOST_ARCHIVE_DECL void end_preamble(); // default implementation does nothing
-    BOOST_ARCHIVE_DECL library_version_type get_library_version() const;
-    BOOST_ARCHIVE_DECL unsigned int get_flags() const;
-};
-
-} // namespace detail
-} // namespace archive
-} // namespace boost
-
-#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
-
-#endif //BOOST_ARCHIVE_BASIC_OARCHIVE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/detail/basic_oserializer.hpp b/contrib/libboost/boost_1_65_0/boost/archive/detail/basic_oserializer.hpp
deleted file mode 100644
index 94247e90056..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/detail/basic_oserializer.hpp
+++ /dev/null
@@ -1,89 +0,0 @@
-#ifndef BOOST_SERIALIZATION_BASIC_OSERIALIZER_HPP
-#define BOOST_SERIALIZATION_BASIC_OSERIALIZER_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// basic_oserializer.hpp: extenstion of type_info required for serialization.
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <cstddef> // NULL
-#include <boost/config.hpp>
-#include <boost/noncopyable.hpp>
-
-#include <boost/archive/basic_archive.hpp>
-#include <boost/archive/detail/auto_link_archive.hpp>
-#include <boost/archive/detail/basic_serializer.hpp>
-
-#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
-
-#ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable : 4511 4512)
-#endif
-
-namespace boost {
-namespace serialization {
-    class extended_type_info;
-} // namespace serialization
-
-// forward declarations
-namespace archive {
-namespace detail {
-
-class basic_oarchive;
-class basic_pointer_oserializer;
-
-class BOOST_SYMBOL_VISIBLE basic_oserializer :
-    public basic_serializer
-{
-private:
-    basic_pointer_oserializer *m_bpos;
-protected:
-    explicit BOOST_ARCHIVE_DECL basic_oserializer(
-        const boost::serialization::extended_type_info & type_
-    );
-    virtual BOOST_ARCHIVE_DECL ~basic_oserializer();
-public:
-    bool serialized_as_pointer() const {
-        return m_bpos != NULL;
-    }
-    void set_bpos(basic_pointer_oserializer *bpos){
-        m_bpos = bpos;
-    }
-    const basic_pointer_oserializer * get_bpos() const {
-        return m_bpos;
-    }
-    virtual void save_object_data(
-        basic_oarchive & ar, const void * x
-    ) const = 0;
-    // returns true if class_info should be saved
-    virtual bool class_info() const = 0;
-    // returns true if objects should be tracked
-    virtual bool tracking(const unsigned int flags) const = 0;
-    // returns class version
-    virtual version_type version() const = 0;
-    // returns true if this class is polymorphic
-    virtual bool is_polymorphic() const = 0;
-};
-
-} // namespace detail
-} // namespace serialization
-} // namespace boost
-
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
-
-#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
-
-#endif // BOOST_SERIALIZATION_BASIC_OSERIALIZER_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/detail/basic_pointer_iserializer.hpp b/contrib/libboost/boost_1_65_0/boost/archive/detail/basic_pointer_iserializer.hpp
deleted file mode 100644
index 1fc4b14d6e9..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/detail/basic_pointer_iserializer.hpp
+++ /dev/null
@@ -1,70 +0,0 @@
-#ifndef BOOST_ARCHIVE_BASIC_POINTER_ISERIALIZER_HPP
-#define BOOST_ARCHIVE_BASIC_POINTER_ISERIALIZER_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// basic_pointer_oserializer.hpp: extenstion of type_info required for 
-// serialization.
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-#include <boost/config.hpp>
-#include <boost/noncopyable.hpp>
-#include <boost/archive/detail/auto_link_archive.hpp>
-#include <boost/archive/detail/basic_serializer.hpp>
-
-#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
-
-#ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable : 4511 4512)
-#endif
-
-namespace boost {
-namespace serialization {
-    class extended_type_info;
-} // namespace serialization
-
-// forward declarations
-namespace archive {
-namespace detail {
-
-class basic_iarchive;
-class basic_iserializer;
-
-class BOOST_SYMBOL_VISIBLE basic_pointer_iserializer
-    : public basic_serializer {
-protected:
-    explicit BOOST_ARCHIVE_DECL basic_pointer_iserializer(
-        const boost::serialization::extended_type_info & type_
-    );
-    virtual BOOST_ARCHIVE_DECL ~basic_pointer_iserializer();
-public:
-    virtual void * heap_allocation() const = 0;
-    virtual const basic_iserializer & get_basic_serializer() const = 0;
-    virtual void load_object_ptr(
-        basic_iarchive & ar, 
-        void * x,
-        const unsigned int file_version
-    ) const = 0;
-};
-
-} // namespace detail
-} // namespace archive
-} // namespace boost
-
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
-
-#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
-
-#endif // BOOST_ARCHIVE_BASIC_POINTER_ISERIALIZER_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/detail/basic_pointer_oserializer.hpp b/contrib/libboost/boost_1_65_0/boost/archive/detail/basic_pointer_oserializer.hpp
deleted file mode 100644
index 1a5d9549eab..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/detail/basic_pointer_oserializer.hpp
+++ /dev/null
@@ -1,68 +0,0 @@
-#ifndef BOOST_ARCHIVE_BASIC_POINTER_OSERIALIZER_HPP
-#define BOOST_ARCHIVE_BASIC_POINTER_OSERIALIZER_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// basic_pointer_oserializer.hpp: extenstion of type_info required for 
-// serialization.
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-#include <boost/config.hpp>
-#include <boost/noncopyable.hpp>
-#include <boost/archive/detail/auto_link_archive.hpp>
-#include <boost/archive/detail/basic_serializer.hpp>
-
-#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
-
-#ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable : 4511 4512)
-#endif
-
-namespace boost {
-namespace serialization {
-    class extended_type_info;
-} // namespace serialization
-
-namespace archive {
-namespace detail {
-
-class basic_oarchive;
-class basic_oserializer;
-
-class BOOST_SYMBOL_VISIBLE basic_pointer_oserializer : 
-    public basic_serializer
-{
-protected:
-    explicit BOOST_ARCHIVE_DECL basic_pointer_oserializer(
-        const boost::serialization::extended_type_info & type_
-    );
-public:
-    virtual BOOST_ARCHIVE_DECL ~basic_pointer_oserializer();
-    virtual const basic_oserializer & get_basic_serializer() const = 0;
-    virtual void save_object_ptr(
-        basic_oarchive & ar,
-        const void * x
-    ) const = 0;
-};
-
-} // namespace detail
-} // namespace archive
-} // namespace boost
-
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
-
-#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
-
-#endif // BOOST_ARCHIVE_BASIC_POINTER_OSERIALIZER_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/detail/basic_serializer.hpp b/contrib/libboost/boost_1_65_0/boost/archive/detail/basic_serializer.hpp
deleted file mode 100644
index f9c4203f862..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/detail/basic_serializer.hpp
+++ /dev/null
@@ -1,77 +0,0 @@
-#ifndef  BOOST_ARCHIVE_BASIC_SERIALIZER_HPP
-#define BOOST_ARCHIVE_BASIC_SERIALIZER_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// basic_serializer.hpp: extenstion of type_info required for serialization.
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/assert.hpp>
-#include <cstddef> // NULL
-
-#include <boost/noncopyable.hpp>
-#include <boost/config.hpp>
-#include <boost/serialization/extended_type_info.hpp>
-
-#ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable : 4511 4512)
-#endif
-
-namespace boost {
-namespace archive {
-namespace detail {
-
-class basic_serializer : 
-    private boost::noncopyable
-{
-    const boost::serialization::extended_type_info * m_eti;
-protected:
-    explicit basic_serializer(
-        const boost::serialization::extended_type_info & eti
-    ) : 
-        m_eti(& eti)
-    {}
-public:
-    inline bool 
-    operator<(const basic_serializer & rhs) const {
-        // can't compare address since there can be multiple eti records
-        // for the same type in different execution modules (that is, DLLS)
-        // leave this here as a reminder not to do this!
-        // return & lhs.get_eti() < & rhs.get_eti();
-        return get_eti() < rhs.get_eti();
-    }
-    const char * get_debug_info() const {
-        return m_eti->get_debug_info();
-    }
-    const boost::serialization::extended_type_info & get_eti() const {
-        return * m_eti;
-    }
-};
-
-class basic_serializer_arg : public basic_serializer {
-public:
-    basic_serializer_arg(const serialization::extended_type_info & eti) :
-        basic_serializer(eti)
-    {}
-};
-
-} // namespace detail
-} // namespace archive
-} // namespace boost
-
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
-
-#endif // BOOST_ARCHIVE_BASIC_SERIALIZER_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/detail/basic_serializer_map.hpp b/contrib/libboost/boost_1_65_0/boost/archive/detail/basic_serializer_map.hpp
deleted file mode 100644
index 79341803367..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/detail/basic_serializer_map.hpp
+++ /dev/null
@@ -1,69 +0,0 @@
-#ifndef  BOOST_SERIALIZER_MAP_HPP
-#define BOOST_SERIALIZER_MAP_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// basic_serializer_map.hpp: extenstion of type_info required for serialization.
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <set>
-
-#include <boost/config.hpp>
-#include <boost/noncopyable.hpp>
-#include <boost/archive/detail/auto_link_archive.hpp>
-
-#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
-
-namespace boost { 
-namespace serialization {
-    class extended_type_info;
-}
-
-namespace archive {
-namespace detail {
-
-class basic_serializer;
-
-class BOOST_SYMBOL_VISIBLE
-basic_serializer_map : public
-    boost::noncopyable
-{
-    struct type_info_pointer_compare
-    {
-        bool operator()(
-            const basic_serializer * lhs, const basic_serializer * rhs
-        ) const ;
-    };
-    typedef std::set<
-        const basic_serializer *, 
-        type_info_pointer_compare
-    > map_type;
-    map_type m_map;
-public:
-    BOOST_ARCHIVE_DECL bool insert(const basic_serializer * bs);
-    BOOST_ARCHIVE_DECL void erase(const basic_serializer * bs);
-    BOOST_ARCHIVE_DECL const basic_serializer * find(
-        const boost::serialization::extended_type_info & type_
-    ) const;
-private:
-    // cw 8.3 requires this
-    basic_serializer_map& operator=(basic_serializer_map const&);
-};
-
-} // namespace detail
-} // namespace archive
-} // namespace boost
-
-#include <boost/archive/detail/abi_suffix.hpp> // must be the last header
-
-#endif // BOOST_SERIALIZER_MAP_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/detail/check.hpp b/contrib/libboost/boost_1_65_0/boost/archive/detail/check.hpp
deleted file mode 100644
index 10034e7d101..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/detail/check.hpp
+++ /dev/null
@@ -1,169 +0,0 @@
-#ifndef BOOST_ARCHIVE_DETAIL_CHECK_HPP
-#define BOOST_ARCHIVE_DETAIL_CHECK_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#pragma inline_depth(511)
-#pragma inline_recursion(on)
-#endif
-
-#if defined(__MWERKS__)
-#pragma inline_depth(511)
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// check.hpp: interface for serialization system.
-
-// (C) Copyright 2009 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/config.hpp>
-
-#include <boost/static_assert.hpp>
-#include <boost/type_traits/is_const.hpp>
-
-#include <boost/mpl/eval_if.hpp>
-#include <boost/mpl/or.hpp>
-#include <boost/mpl/equal_to.hpp>
-#include <boost/mpl/int.hpp>
-#include <boost/mpl/not.hpp>
-#include <boost/mpl/greater.hpp>
-#include <boost/mpl/assert.hpp>
-
-#include <boost/serialization/static_warning.hpp>
-#include <boost/serialization/version.hpp>
-#include <boost/serialization/level.hpp>
-#include <boost/serialization/tracking.hpp>
-#include <boost/serialization/wrapper.hpp>
-
-namespace boost {
-namespace archive {
-namespace detail {
-
-// checks for objects
-
-template<class T>
-inline void check_object_level(){
-    typedef 
-        typename mpl::greater_equal<
-            serialization::implementation_level< T >,
-            mpl::int_<serialization::primitive_type>
-        >::type typex;
-
-    // trap attempts to serialize objects marked
-    // not_serializable
-    BOOST_STATIC_ASSERT(typex::value);
-}
-
-template<class T>
-inline void check_object_versioning(){
-    typedef 
-        typename mpl::or_<
-            typename mpl::greater<
-                serialization::implementation_level< T >,
-                mpl::int_<serialization::object_serializable>
-            >,
-            typename mpl::equal_to<
-                serialization::version< T >,
-                mpl::int_<0>
-            >
-        > typex;
-    // trap attempts to serialize with objects that don't
-    // save class information in the archive with versioning.
-    BOOST_STATIC_ASSERT(typex::value);
-}
-
-template<class T>
-inline void check_object_tracking(){
-    // presume it has already been determined that
-    // T is not a const
-    BOOST_STATIC_ASSERT(! boost::is_const< T >::value);
-    typedef typename mpl::equal_to<
-        serialization::tracking_level< T >,
-        mpl::int_<serialization::track_never>
-    >::type typex;
-    // saving an non-const object of a type not marked "track_never)
-
-    // may be an indicator of an error usage of the
-    // serialization library and should be double checked.  
-    // See documentation on object tracking.  Also, see the 
-    // "rationale" section of the documenation
-    // for motivation for this checking.
-
-    BOOST_STATIC_WARNING(typex::value);
-}
-
-// checks for pointers
-
-template<class T>
-inline void check_pointer_level(){
-    // we should only invoke this once we KNOW that T
-    // has been used as a pointer!!
-    typedef 
-        typename mpl::or_<
-            typename mpl::greater<
-                serialization::implementation_level< T >,
-                mpl::int_<serialization::object_serializable>
-            >,
-            typename mpl::not_<
-                typename mpl::equal_to<
-                    serialization::tracking_level< T >,
-                    mpl::int_<serialization::track_selectively>
-                >
-            >
-        > typex;
-    // Address the following when serializing to a pointer:
-
-    // a) This type doesn't save class information in the
-    // archive. That is, the serialization trait implementation
-    // level <= object_serializable.
-    // b) Tracking for this type is set to "track selectively"
-
-    // in this case, indication that an object is tracked is
-    // not stored in the archive itself - see level == object_serializable
-    // but rather the existence of the operation ar >> T * is used to 
-    // infer that an object of this type should be tracked.  So, if
-    // you save via a pointer but don't load via a pointer the operation
-    // will fail on load without given any valid reason for the failure.
-
-    // So if your program traps here, consider changing the 
-    // tracking or implementation level traits - or not
-    // serializing via a pointer.
-    BOOST_STATIC_WARNING(typex::value);
-}
-
-template<class T>
-void inline check_pointer_tracking(){
-    typedef typename mpl::greater<
-        serialization::tracking_level< T >,
-        mpl::int_<serialization::track_never>
-    >::type typex;
-    // serializing an object of a type marked "track_never" through a pointer
-    // could result in creating more objects than were saved!
-    BOOST_STATIC_WARNING(typex::value);
-}
-
-template<class T>
-inline void check_const_loading(){
-    typedef
-        typename mpl::or_<
-            typename boost::serialization::is_wrapper< T >,
-            typename mpl::not_<
-                typename boost::is_const< T >
-            >
-        >::type typex;
-    // cannot load data into a "const" object unless it's a
-    // wrapper around some other non-const object.
-    BOOST_STATIC_ASSERT(typex::value);
-}
-
-} // detail
-} // archive
-} // boost
-
-#endif // BOOST_ARCHIVE_DETAIL_CHECK_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/detail/common_iarchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/detail/common_iarchive.hpp
deleted file mode 100644
index 82304f1e5ac..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/detail/common_iarchive.hpp
+++ /dev/null
@@ -1,88 +0,0 @@
-#ifndef BOOST_ARCHIVE_DETAIL_COMMON_IARCHIVE_HPP
-#define BOOST_ARCHIVE_DETAIL_COMMON_IARCHIVE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// common_iarchive.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/config.hpp>
-
-#include <boost/archive/detail/basic_iarchive.hpp>
-#include <boost/archive/detail/basic_pointer_iserializer.hpp>
-#include <boost/archive/detail/interface_iarchive.hpp>
-
-#ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable : 4511 4512)
-#endif
-
-namespace boost {
-namespace archive {
-namespace detail {
-
-class extended_type_info;
-
-// note: referred to as Curiously Recurring Template Patter (CRTP)
-template<class Archive>
-class BOOST_SYMBOL_VISIBLE common_iarchive : 
-    public basic_iarchive,
-    public interface_iarchive<Archive>
-{
-    friend class interface_iarchive<Archive>;
-private:
-    virtual void vload(version_type & t){
-        * this->This() >> t; 
-    }
-    virtual void vload(object_id_type & t){
-        * this->This() >> t;
-    }
-    virtual void vload(class_id_type & t){
-        * this->This() >> t;
-    }
-    virtual void vload(class_id_optional_type & t){
-        * this->This() >> t;
-    }
-    virtual void vload(tracking_type & t){
-        * this->This() >> t;
-    }
-    virtual void vload(class_name_type &s){
-        * this->This() >> s;
-    }
-protected:
-    // default processing - invoke serialization library
-    template<class T>
-    void load_override(T & t){
-        archive::load(* this->This(), t);
-    }
-    // default implementations of functions which emit start/end tags for
-    // archive types that require them.
-    void load_start(const char * /*name*/){}
-    void load_end(const char * /*name*/){}
-    // default archive initialization
-    common_iarchive(unsigned int flags = 0) : 
-        basic_iarchive(flags),
-        interface_iarchive<Archive>()
-    {}
-};
-
-} // namespace detail
-} // namespace archive
-} // namespace boost
-
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
-
-#endif // BOOST_ARCHIVE_DETAIL_COMMON_IARCHIVE_HPP
-
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/detail/common_oarchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/detail/common_oarchive.hpp
deleted file mode 100644
index ee42bbe5976..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/detail/common_oarchive.hpp
+++ /dev/null
@@ -1,88 +0,0 @@
-#ifndef BOOST_ARCHIVE_DETAIL_COMMON_OARCHIVE_HPP
-#define BOOST_ARCHIVE_DETAIL_COMMON_OARCHIVE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// common_oarchive.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/config.hpp>
-
-#include <boost/archive/detail/basic_oarchive.hpp>
-#include <boost/archive/detail/interface_oarchive.hpp>
-
-#ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable : 4511 4512)
-#endif
-
-namespace boost {
-namespace archive {
-namespace detail {
-
-// note: referred to as Curiously Recurring Template Patter (CRTP)
-template<class Archive>
-
-class BOOST_SYMBOL_VISIBLE common_oarchive :
-    public basic_oarchive,
-    public interface_oarchive<Archive>
-{
-    friend class interface_oarchive<Archive>;
-private:
-    virtual void vsave(const version_type t){
-        * this->This() << t;
-    }
-    virtual void vsave(const object_id_type t){
-        * this->This() << t;
-    }
-    virtual void vsave(const object_reference_type t){
-        * this->This() << t;
-    }
-    virtual void vsave(const class_id_type t){
-        * this->This() << t;
-    }
-    virtual void vsave(const class_id_reference_type t){
-        * this->This() << t;
-    }
-    virtual void vsave(const class_id_optional_type t){
-        * this->This() << t;
-    }
-    virtual void vsave(const class_name_type & t){
-        * this->This() << t;
-    }
-    virtual void vsave(const tracking_type t){
-        * this->This() << t;
-    }
-protected:
-    // default processing - invoke serialization library
-    template<class T>
-    void save_override(T & t){
-        archive::save(* this->This(), t);
-    }
-    void save_start(const char * /*name*/){}
-    void save_end(const char * /*name*/){}
-    common_oarchive(unsigned int flags = 0) : 
-        basic_oarchive(flags),
-        interface_oarchive<Archive>()
-    {}
-};
-
-} // namespace detail
-} // namespace archive
-} // namespace boost
-
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
-
-#endif // BOOST_ARCHIVE_DETAIL_COMMON_OARCHIVE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/detail/decl.hpp b/contrib/libboost/boost_1_65_0/boost/archive/detail/decl.hpp
deleted file mode 100644
index 4f731cded37..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/detail/decl.hpp
+++ /dev/null
@@ -1,57 +0,0 @@
-#ifndef BOOST_ARCHIVE_DETAIL_DECL_HPP
-#define BOOST_ARCHIVE_DETAIL_DECL_HPP 
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif 
-
-/////////1/////////2///////// 3/////////4/////////5/////////6/////////7/////////8
-//  decl.hpp
-//
-//  (c) Copyright Robert Ramey 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)
-
-//  See library home page at http://www.boost.org/libs/serialization
-
-//----------------------------------------------------------------------------// 
-
-// This header implements separate compilation features as described in
-// http://www.boost.org/more/separate_compilation.html
-
-#include <boost/config.hpp>
-
-#if (defined(BOOST_ALL_DYN_LINK) || defined(BOOST_SERIALIZATION_DYN_LINK))
-    #if defined(BOOST_ARCHIVE_SOURCE)
-        #define BOOST_ARCHIVE_DECL BOOST_SYMBOL_EXPORT
-    #else
-        #define BOOST_ARCHIVE_DECL BOOST_SYMBOL_IMPORT
-    #endif
-
-    #if defined(BOOST_WARCHIVE_SOURCE)
-        #define BOOST_WARCHIVE_DECL BOOST_SYMBOL_EXPORT
-    #else
-        #define BOOST_WARCHIVE_DECL BOOST_SYMBOL_IMPORT
-    #endif
-
-    #if defined(BOOST_WARCHIVE_SOURCE) || defined(BOOST_ARCHIVE_SOURCE)
-        #define BOOST_ARCHIVE_OR_WARCHIVE_DECL BOOST_SYMBOL_EXPORT
-    #else
-        #define BOOST_ARCHIVE_OR_WARCHIVE_DECL BOOST_SYMBOL_IMPORT
-    #endif
-
-#endif
-
-#if ! defined(BOOST_ARCHIVE_DECL)
-    #define BOOST_ARCHIVE_DECL
-#endif
-#if ! defined(BOOST_WARCHIVE_DECL)
-    #define BOOST_WARCHIVE_DECL
-#endif
-#if ! defined(BOOST_ARCHIVE_OR_WARCHIVE_DECL)
-    #define BOOST_ARCHIVE_OR_WARCHIVE_DECL
-#endif
-
-#endif // BOOST_ARCHIVE_DETAIL_DECL_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/detail/helper_collection.hpp b/contrib/libboost/boost_1_65_0/boost/archive/detail/helper_collection.hpp
deleted file mode 100644
index edb4125e308..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/detail/helper_collection.hpp
+++ /dev/null
@@ -1,99 +0,0 @@
-#ifndef BOOST_ARCHIVE_DETAIL_HELPER_COLLECTION_HPP
-#define BOOST_ARCHIVE_DETAIL_HELPER_COLLECTION_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// helper_collection.hpp: archive support for run-time helpers
-
-// (C) Copyright 2002-2008 Robert Ramey and Joaquin M Lopez Munoz
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <cstddef> // NULL
-#include <vector>
-#include <utility>
-#include <memory>
-#include <algorithm>
-
-#include <boost/config.hpp>
-
-#include <boost/smart_ptr/shared_ptr.hpp>
-#include <boost/smart_ptr/make_shared.hpp>
-
-namespace boost {
-
-namespace archive {
-namespace detail {
-
-class helper_collection
-{
-    helper_collection(const helper_collection&);              // non-copyable
-    helper_collection& operator = (const helper_collection&); // non-copyable
-
-    // note: we dont' actually "share" the function object pointer
-    // we only use shared_ptr to make sure that it get's deleted
-
-    typedef std::pair<
-        const void *,
-        boost::shared_ptr<void>
-    > helper_value_type;
-    template<class T>
-    boost::shared_ptr<void> make_helper_ptr(){
-        // use boost::shared_ptr rather than std::shared_ptr to maintain
-        // c++03 compatibility
-        return boost::make_shared<T>();
-    }
-
-    typedef std::vector<helper_value_type> collection;
-    collection m_collection;
-
-    struct predicate {
-        BOOST_DELETED_FUNCTION(predicate & operator=(const predicate & rhs))
-    public:
-        const void * const m_ti;
-        bool operator()(helper_value_type const &rhs) const {
-            return m_ti == rhs.first;
-        }
-        predicate(const void * ti) :
-            m_ti(ti)
-        {}
-    };
-protected:
-    helper_collection(){}
-    ~helper_collection(){}
-public:
-    template<typename Helper>
-    Helper& find_helper(void * const id = 0) {
-        collection::const_iterator it =
-            std::find_if(
-                m_collection.begin(),
-                m_collection.end(),
-                predicate(id)
-            );
-
-        void * rval = 0;
-        if(it == m_collection.end()){
-            m_collection.push_back(
-                std::make_pair(id, make_helper_ptr<Helper>())
-            );
-            rval = m_collection.back().second.get();
-        }
-        else{
-            rval = it->second.get();
-        }
-        return *static_cast<Helper *>(rval);
-    }
-};
-
-} // namespace detail
-} // namespace serialization
-} // namespace boost
-
-#endif // BOOST_ARCHIVE_DETAIL_HELPER_COLLECTION_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/detail/interface_iarchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/detail/interface_iarchive.hpp
deleted file mode 100644
index 4a99e28b59f..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/detail/interface_iarchive.hpp
+++ /dev/null
@@ -1,85 +0,0 @@
-#ifndef BOOST_ARCHIVE_DETAIL_INTERFACE_IARCHIVE_HPP
-#define BOOST_ARCHIVE_DETAIL_INTERFACE_IARCHIVE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// interface_iarchive.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-#include <cstddef> // NULL
-#include <boost/cstdint.hpp>
-#include <boost/mpl/bool.hpp>
-#include <boost/archive/detail/auto_link_archive.hpp>
-#include <boost/archive/detail/iserializer.hpp>
-#include <boost/archive/detail/helper_collection.hpp>
-#include <boost/serialization/singleton.hpp>
-#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
-
-namespace boost {
-namespace archive {
-namespace detail {
-
-class basic_pointer_iserializer;
-
-template<class Archive>
-class interface_iarchive 
-{
-protected:
-    interface_iarchive(){};
-public:
-    /////////////////////////////////////////////////////////
-    // archive public interface
-    typedef mpl::bool_<true> is_loading;
-    typedef mpl::bool_<false> is_saving;
-
-    // return a pointer to the most derived class
-    Archive * This(){
-        return static_cast<Archive *>(this);
-    }
-
-    template<class T>
-    const basic_pointer_iserializer * 
-    register_type(T * = NULL){
-        const basic_pointer_iserializer & bpis =
-            boost::serialization::singleton<
-                pointer_iserializer<Archive, T> 
-            >::get_const_instance();
-        this->This()->register_basic_serializer(bpis.get_basic_serializer());
-        return & bpis;
-    }
-    template<class Helper>
-    Helper &
-    get_helper(void * const id = 0){
-        helper_collection & hc = this->This()->get_helper_collection();
-        return hc.template find_helper<Helper>(id);
-    }
-    
-    template<class T>
-    Archive & operator>>(T & t){
-        this->This()->load_override(t);
-        return * this->This();
-    }
-
-    // the & operator 
-    template<class T>
-    Archive & operator&(T & t){
-        return *(this->This()) >> t;
-    }
-};
-
-} // namespace detail
-} // namespace archive
-} // namespace boost
-
-#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
-
-#endif // BOOST_ARCHIVE_DETAIL_INTERFACE_IARCHIVE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/detail/interface_oarchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/detail/interface_oarchive.hpp
deleted file mode 100644
index 359463ed9d8..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/detail/interface_oarchive.hpp
+++ /dev/null
@@ -1,87 +0,0 @@
-#ifndef BOOST_ARCHIVE_DETAIL_INTERFACE_OARCHIVE_HPP
-#define BOOST_ARCHIVE_DETAIL_INTERFACE_OARCHIVE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// interface_oarchive.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-#include <cstddef> // NULL
-#include <boost/cstdint.hpp>
-#include <boost/mpl/bool.hpp>
-
-#include <boost/archive/detail/auto_link_archive.hpp>
-#include <boost/archive/detail/oserializer.hpp>
-#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
-
-#include <boost/serialization/singleton.hpp>
-
-namespace boost {
-namespace archive {
-namespace detail {
-
-class basic_pointer_oserializer;
-
-template<class Archive>
-class interface_oarchive 
-{
-protected:
-    interface_oarchive(){};
-public:
-    /////////////////////////////////////////////////////////
-    // archive public interface
-    typedef mpl::bool_<false> is_loading;
-    typedef mpl::bool_<true> is_saving;
-
-    // return a pointer to the most derived class
-    Archive * This(){
-        return static_cast<Archive *>(this);
-    }
-
-    template<class T>
-    const basic_pointer_oserializer * 
-    register_type(const T * = NULL){
-        const basic_pointer_oserializer & bpos =
-            boost::serialization::singleton<
-                pointer_oserializer<Archive, T>
-            >::get_const_instance();
-        this->This()->register_basic_serializer(bpos.get_basic_serializer());
-        return & bpos;
-    }
-    
-    template<class Helper>
-    Helper &
-    get_helper(void * const id = 0){
-        helper_collection & hc = this->This()->get_helper_collection();
-        return hc.template find_helper<Helper>(id);
-    }
-
-    template<class T>
-    Archive & operator<<(const T & t){
-        this->This()->save_override(t);
-        return * this->This();
-    }
-    
-    // the & operator 
-    template<class T>
-    Archive & operator&(const T & t){
-        return * this ->This() << t;
-    }
-};
-
-} // namespace detail
-} // namespace archive
-} // namespace boost
-
-#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
-
-#endif // BOOST_ARCHIVE_DETAIL_INTERFACE_IARCHIVE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/detail/iserializer.hpp b/contrib/libboost/boost_1_65_0/boost/archive/detail/iserializer.hpp
deleted file mode 100644
index 193e98a82e4..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/detail/iserializer.hpp
+++ /dev/null
@@ -1,631 +0,0 @@
-#ifndef BOOST_ARCHIVE_DETAIL_ISERIALIZER_HPP
-#define BOOST_ARCHIVE_DETAIL_ISERIALIZER_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#pragma inline_depth(511)
-#pragma inline_recursion(on)
-#endif
-
-#if defined(__MWERKS__)
-#pragma inline_depth(511)
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// iserializer.hpp: interface for serialization system.
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <new>     // for placement new
-#include <cstddef> // size_t, NULL
-
-#include <boost/config.hpp>
-#include <boost/detail/workaround.hpp>
-#if defined(BOOST_NO_STDC_NAMESPACE)
-namespace std{ 
-    using ::size_t; 
-} // namespace std
-#endif
-
-#include <boost/static_assert.hpp>
-
-#include <boost/mpl/eval_if.hpp>
-#include <boost/mpl/identity.hpp>
-#include <boost/mpl/greater_equal.hpp>
-#include <boost/mpl/equal_to.hpp>
-#include <boost/core/no_exceptions_support.hpp>
-
-#ifndef BOOST_SERIALIZATION_DEFAULT_TYPE_INFO   
-    #include <boost/serialization/extended_type_info_typeid.hpp>   
-#endif
-#include <boost/serialization/throw_exception.hpp>
-#include <boost/serialization/smart_cast.hpp>
-#include <boost/serialization/static_warning.hpp>
-
-#include <boost/type_traits/is_pointer.hpp>
-#include <boost/type_traits/is_enum.hpp>
-#include <boost/type_traits/is_const.hpp>
-#include <boost/type_traits/remove_const.hpp>
-#include <boost/type_traits/remove_extent.hpp>
-#include <boost/type_traits/is_polymorphic.hpp>
-
-#include <boost/serialization/assume_abstract.hpp>
-
-#ifndef BOOST_MSVC
-    #define DONT_USE_HAS_NEW_OPERATOR (                    \
-           BOOST_WORKAROUND(__IBMCPP__, < 1210)            \
-        || defined(__SUNPRO_CC) && (__SUNPRO_CC < 0x590)   \
-    )
-#else
-    #define DONT_USE_HAS_NEW_OPERATOR 0
-#endif
-
-#if ! DONT_USE_HAS_NEW_OPERATOR
-#include <boost/type_traits/has_new_operator.hpp>
-#endif
-
-#include <boost/serialization/serialization.hpp>
-#include <boost/serialization/version.hpp>
-#include <boost/serialization/level.hpp>
-#include <boost/serialization/tracking.hpp>
-#include <boost/serialization/type_info_implementation.hpp>
-#include <boost/serialization/nvp.hpp>
-#include <boost/serialization/void_cast.hpp>
-#include <boost/serialization/collection_size_type.hpp>
-#include <boost/serialization/singleton.hpp>
-#include <boost/serialization/wrapper.hpp>
-#include <boost/serialization/array_wrapper.hpp>
-
-// the following is need only for dynamic cast of polymorphic pointers
-#include <boost/archive/archive_exception.hpp>
-#include <boost/archive/detail/basic_iarchive.hpp>
-#include <boost/archive/detail/basic_iserializer.hpp>
-#include <boost/archive/detail/basic_pointer_iserializer.hpp>
-#include <boost/archive/detail/archive_serializer_map.hpp>
-#include <boost/archive/detail/check.hpp>
-
-namespace boost {
-
-namespace serialization {
-    class extended_type_info;
-} // namespace serialization
-
-namespace archive {
-
-// an accessor to permit friend access to archives.  Needed because
-// some compilers don't handle friend templates completely
-class load_access {
-public:
-    template<class Archive, class T>
-    static void load_primitive(Archive &ar, T &t){
-        ar.load(t);
-    }
-};
-
-namespace detail {
-
-#ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable : 4511 4512)
-#endif
-
-template<class Archive, class T>
-class iserializer : public basic_iserializer
-{
-private:
-    virtual void destroy(/*const*/ void *address) const {
-        boost::serialization::access::destroy(static_cast<T *>(address));
-    }
-protected:
-    // protected constructor since it's always created by singleton
-    explicit iserializer() :
-        basic_iserializer(
-            boost::serialization::singleton<
-                typename 
-                boost::serialization::type_info_implementation< T >::type
-            >::get_const_instance()
-        )
-    {}
-public:
-    virtual BOOST_DLLEXPORT void load_object_data(
-        basic_iarchive & ar,
-        void *x, 
-        const unsigned int file_version
-    ) const BOOST_USED;
-    virtual bool class_info() const {
-        return boost::serialization::implementation_level< T >::value 
-            >= boost::serialization::object_class_info;
-    }
-    virtual bool tracking(const unsigned int /* flags */) const {
-        return boost::serialization::tracking_level< T >::value 
-                == boost::serialization::track_always
-            || ( boost::serialization::tracking_level< T >::value 
-                == boost::serialization::track_selectively
-                && serialized_as_pointer());
-    }
-    virtual version_type version() const {
-        return version_type(::boost::serialization::version< T >::value);
-    }
-    virtual bool is_polymorphic() const {
-        return boost::is_polymorphic< T >::value;
-    }
-    virtual ~iserializer(){};
-};
-
-#ifdef BOOST_MSVC
-#  pragma warning(pop)
-#endif
-
-template<class Archive, class T>
-BOOST_DLLEXPORT void iserializer<Archive, T>::load_object_data(
-    basic_iarchive & ar,
-    void *x, 
-    const unsigned int file_version
-) const {
-    // note: we now comment this out. Before we permited archive
-    // version # to be very large.  Now we don't.  To permit
-    // readers of these old archives, we have to suppress this 
-    // code.  Perhaps in the future we might re-enable it but
-    // permit its suppression with a runtime switch.
-    #if 0
-    // trap case where the program cannot handle the current version
-    if(file_version > static_cast<const unsigned int>(version()))
-        boost::serialization::throw_exception(
-            archive::archive_exception(
-                boost::archive::archive_exception::unsupported_class_version,
-                get_debug_info()
-            )
-        );
-    #endif
-    // make sure call is routed through the higest interface that might
-    // be specialized by the user.
-    boost::serialization::serialize_adl(
-        boost::serialization::smart_cast_reference<Archive &>(ar),
-        * static_cast<T *>(x), 
-        file_version
-    );
-}
-
-#ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable : 4511 4512)
-#endif
-
-// the purpose of this code is to allocate memory for an object
-// without requiring the constructor to be called.  Presumably
-// the allocated object will be subsequently initialized with
-// "placement new". 
-// note: we have the boost type trait has_new_operator but we
-// have no corresponding has_delete_operator.  So we presume
-// that the former being true would imply that the a delete
-// operator is also defined for the class T.
-
-template<class T>
-struct heap_allocation {
-    // boost::has_new_operator< T > doesn't work on these compilers
-    #if DONT_USE_HAS_NEW_OPERATOR
-        // This doesn't handle operator new overload for class T
-        static T * invoke_new(){
-            return static_cast<T *>(operator new(sizeof(T)));
-        }
-        static void invoke_delete(T *t){
-            (operator delete(t));
-        }
-    #else
-        // note: we presume that a true value for has_new_operator
-        // implies the existence of a class specific delete operator as well
-        // as a class specific new operator.
-        struct has_new_operator {
-            static T * invoke_new() {
-                return static_cast<T *>((T::operator new)(sizeof(T)));
-            }
-            static void invoke_delete(T * t) {
-                // if compilation fails here, the likely cause that the class
-                // T has a class specific new operator but no class specific
-                // delete operator which matches the following signature.
-                // note that this solution addresses the issue that two
-                // possible signatures.  But it doesn't address the possibility
-                // that the class might have class specific new with NO
-                // class specific delete at all.  Patches (compatible with
-                // C++03) welcome!
-                delete t;
-            }
-        };
-        struct doesnt_have_new_operator {
-            static T* invoke_new() {
-                return static_cast<T *>(operator new(sizeof(T)));
-            }
-            static void invoke_delete(T * t) {
-                // Note: I'm reliance upon automatic conversion from T * to void * here
-                delete t;
-            }
-        };
-        static T * invoke_new() {
-            typedef typename
-                mpl::eval_if<
-                    boost::has_new_operator< T >,
-                    mpl::identity<has_new_operator >,
-                    mpl::identity<doesnt_have_new_operator >    
-                >::type typex;
-            return typex::invoke_new();
-        }
-        static void invoke_delete(T *t) {
-            typedef typename
-                mpl::eval_if<
-                    boost::has_new_operator< T >,
-                    mpl::identity<has_new_operator >,
-                    mpl::identity<doesnt_have_new_operator >    
-                >::type typex;
-            typex::invoke_delete(t);
-        }
-    #endif
-    explicit heap_allocation(){
-        m_p = invoke_new();
-    }
-    ~heap_allocation(){
-        if (0 != m_p)
-            invoke_delete(m_p);
-    }
-    T* get() const {
-        return m_p;
-    }
-
-    T* release() {
-        T* p = m_p;
-        m_p = 0;
-        return p;
-    }
-private:
-    T* m_p;
-};
-
-template<class Archive, class T>
-class pointer_iserializer :
-    public basic_pointer_iserializer
-{
-private:
-    virtual void * heap_allocation() const {
-        detail::heap_allocation<T> h;
-        T * t = h.get();
-        h.release();
-        return t;
-    }
-    virtual const basic_iserializer & get_basic_serializer() const {
-        return boost::serialization::singleton<
-            iserializer<Archive, T>
-        >::get_const_instance();
-    }
-    BOOST_DLLEXPORT virtual void load_object_ptr(
-        basic_iarchive & ar, 
-        void * x,
-        const unsigned int file_version
-    ) const BOOST_USED;
-protected:
-    // this should alway be a singleton so make the constructor protected
-    pointer_iserializer();
-    ~pointer_iserializer();
-};
-
-#ifdef BOOST_MSVC
-#  pragma warning(pop)
-#endif
-
-// note: BOOST_DLLEXPORT is so that code for polymorphic class
-// serialized only through base class won't get optimized out
-template<class Archive, class T>
-BOOST_DLLEXPORT void pointer_iserializer<Archive, T>::load_object_ptr(
-    basic_iarchive & ar, 
-    void * t,
-    const unsigned int file_version
-) const
-{
-    Archive & ar_impl = 
-        boost::serialization::smart_cast_reference<Archive &>(ar);
-
-    // note that the above will throw std::bad_alloc if the allocation
-    // fails so we don't have to address this contingency here.
-
-    // catch exception during load_construct_data so that we don't
-    // automatically delete the t which is most likely not fully
-    // constructed
-    BOOST_TRY {
-        // this addresses an obscure situation that occurs when 
-        // load_constructor de-serializes something through a pointer.
-        ar.next_object_pointer(t);
-        boost::serialization::load_construct_data_adl<Archive, T>(
-            ar_impl,
-            static_cast<T *>(t),
-            file_version
-        );
-    }
-    BOOST_CATCH(...){
-        // if we get here the load_construct failed.  The heap_allocation
-        // will be automatically deleted so we don't have to do anything
-        // special here.
-        BOOST_RETHROW;
-    }
-    BOOST_CATCH_END
-
-    ar_impl >> boost::serialization::make_nvp(NULL, * static_cast<T *>(t));
-}
-
-template<class Archive, class T>
-pointer_iserializer<Archive, T>::pointer_iserializer() :
-    basic_pointer_iserializer(
-        boost::serialization::singleton<
-            typename 
-            boost::serialization::type_info_implementation< T >::type
-        >::get_const_instance()
-    )
-{
-    boost::serialization::singleton<
-        iserializer<Archive, T>
-    >::get_mutable_instance().set_bpis(this);
-    archive_serializer_map<Archive>::insert(this);
-}
-
-template<class Archive, class T>
-pointer_iserializer<Archive, T>::~pointer_iserializer(){
-    archive_serializer_map<Archive>::erase(this);
-}
-
-template<class Archive>
-struct load_non_pointer_type {
-    // note this bounces the call right back to the archive
-    // with no runtime overhead
-    struct load_primitive {
-        template<class T>
-        static void invoke(Archive & ar, T & t){
-            load_access::load_primitive(ar, t);
-        }
-    };
-    // note this bounces the call right back to the archive
-    // with no runtime overhead
-    struct load_only {
-        template<class T>
-        static void invoke(Archive & ar, const T & t){
-            // short cut to user's serializer
-            // make sure call is routed through the higest interface that might
-            // be specialized by the user.
-            boost::serialization::serialize_adl(
-                ar, 
-                const_cast<T &>(t), 
-                boost::serialization::version< T >::value
-            );
-        }
-    };
-
-    // note this save class information including version
-    // and serialization level to the archive
-    struct load_standard {
-        template<class T>
-        static void invoke(Archive &ar, const T & t){
-            void * x = & const_cast<T &>(t);
-            ar.load_object(
-                x, 
-                boost::serialization::singleton<
-                    iserializer<Archive, T>
-                >::get_const_instance()
-            );
-        }
-    };
-
-    struct load_conditional {
-        template<class T>
-        static void invoke(Archive &ar, T &t){
-            //if(0 == (ar.get_flags() & no_tracking))
-                load_standard::invoke(ar, t);
-            //else
-            //    load_only::invoke(ar, t);
-        }
-    };
-
-    template<class T>
-    static void invoke(Archive & ar, T &t){
-        typedef typename mpl::eval_if<
-                // if its primitive
-                mpl::equal_to<
-                    boost::serialization::implementation_level< T >,
-                    mpl::int_<boost::serialization::primitive_type>
-                >,
-                mpl::identity<load_primitive>,
-            // else
-            typename mpl::eval_if<
-            // class info / version
-            mpl::greater_equal<
-                        boost::serialization::implementation_level< T >,
-                        mpl::int_<boost::serialization::object_class_info>
-                    >,
-            // do standard load
-            mpl::identity<load_standard>,
-        // else
-        typename mpl::eval_if<
-            // no tracking
-                    mpl::equal_to<
-                        boost::serialization::tracking_level< T >,
-                        mpl::int_<boost::serialization::track_never>
-                >,
-                // do a fast load
-                mpl::identity<load_only>,
-            // else
-            // do a fast load only tracking is turned off
-            mpl::identity<load_conditional>
-        > > >::type typex;
-        check_object_versioning< T >();
-        check_object_level< T >();
-        typex::invoke(ar, t);
-    }
-};
-
-template<class Archive>
-struct load_pointer_type {
-    struct abstract
-    {
-        template<class T>
-        static const basic_pointer_iserializer * register_type(Archive & /* ar */){
-            // it has? to be polymorphic
-            BOOST_STATIC_ASSERT(boost::is_polymorphic< T >::value);
-            return static_cast<basic_pointer_iserializer *>(NULL);
-         }
-    };
-
-    struct non_abstract
-    {
-        template<class T>
-        static const basic_pointer_iserializer * register_type(Archive & ar){
-            return ar.register_type(static_cast<T *>(NULL));
-        }
-    };
-
-    template<class T>
-    static const basic_pointer_iserializer * register_type(Archive &ar, const T & /*t*/){
-        // there should never be any need to load an abstract polymorphic 
-        // class pointer.  Inhibiting code generation for this
-        // permits abstract base classes to be used - note: exception
-        // virtual serialize functions used for plug-ins
-        typedef typename
-            mpl::eval_if<
-                boost::serialization::is_abstract<const T>,
-                boost::mpl::identity<abstract>,
-                boost::mpl::identity<non_abstract>  
-            >::type typex;
-        return typex::template register_type< T >(ar);
-    }
-
-    template<class T>
-    static T * pointer_tweak(
-        const boost::serialization::extended_type_info & eti,
-        void const * const t,
-        const T &
-    ) {
-        // tweak the pointer back to the base class
-        void * upcast = const_cast<void *>(
-            boost::serialization::void_upcast(
-                eti,
-                boost::serialization::singleton<
-                    typename 
-                    boost::serialization::type_info_implementation< T >::type
-                >::get_const_instance(),
-                t
-            )
-        );
-        if(NULL == upcast)
-            boost::serialization::throw_exception(
-                archive_exception(archive_exception::unregistered_class)
-            );
-        return static_cast<T *>(upcast);
-    }
-
-    template<class T>
-    static void check_load(T & /* t */){
-        check_pointer_level< T >();
-        check_pointer_tracking< T >();
-    }
-
-    static const basic_pointer_iserializer *
-    find(const boost::serialization::extended_type_info & type){
-        return static_cast<const basic_pointer_iserializer *>(
-            archive_serializer_map<Archive>::find(type)
-        );
-    }
-
-    template<class Tptr>
-    static void invoke(Archive & ar, Tptr & t){
-        check_load(*t);
-        const basic_pointer_iserializer * bpis_ptr = register_type(ar, *t);
-        const basic_pointer_iserializer * newbpis_ptr = ar.load_pointer(
-            // note major hack here !!!
-            // I tried every way to convert Tptr &t (where Tptr might
-            // include const) to void * &.  This is the only way
-            // I could make it work. RR
-            (void * & )t,
-            bpis_ptr,
-            find
-        );
-        // if the pointer isn't that of the base class
-        if(newbpis_ptr != bpis_ptr){
-            t = pointer_tweak(newbpis_ptr->get_eti(), t, *t);
-        }
-    }
-};
-
-template<class Archive>
-struct load_enum_type {
-    template<class T>
-    static void invoke(Archive &ar, T &t){
-        // convert integers to correct enum to load
-        int i;
-        ar >> boost::serialization::make_nvp(NULL, i);
-        t = static_cast< T >(i);
-    }
-};
-
-template<class Archive>
-struct load_array_type {
-    template<class T>
-    static void invoke(Archive &ar, T &t){
-        typedef typename remove_extent< T >::type value_type;
-        
-        // convert integers to correct enum to load
-        // determine number of elements in the array. Consider the
-        // fact that some machines will align elements on boundries
-        // other than characters.
-        std::size_t current_count = sizeof(t) / (
-            static_cast<char *>(static_cast<void *>(&t[1])) 
-            - static_cast<char *>(static_cast<void *>(&t[0]))
-        );
-        boost::serialization::collection_size_type count;
-        ar >> BOOST_SERIALIZATION_NVP(count);
-        if(static_cast<std::size_t>(count) > current_count)
-            boost::serialization::throw_exception(
-                archive::archive_exception(
-                    boost::archive::archive_exception::array_size_too_short
-                )
-            );
-        // explict template arguments to pass intel C++ compiler
-        ar >> serialization::make_array<
-            value_type,
-            boost::serialization::collection_size_type
-        >(
-            static_cast<value_type *>(&t[0]),
-            count
-        );
-    }
-};
-
-} // detail
-
-template<class Archive, class T>
-inline void load(Archive & ar, T &t){
-    // if this assertion trips. It means we're trying to load a
-    // const object with a compiler that doesn't have correct
-    // function template ordering.  On other compilers, this is
-    // handled below.
-    detail::check_const_loading< T >();
-    typedef
-        typename mpl::eval_if<is_pointer< T >,
-            mpl::identity<detail::load_pointer_type<Archive> >
-        ,//else
-        typename mpl::eval_if<is_array< T >,
-            mpl::identity<detail::load_array_type<Archive> >
-        ,//else
-        typename mpl::eval_if<is_enum< T >,
-            mpl::identity<detail::load_enum_type<Archive> >
-        ,//else
-            mpl::identity<detail::load_non_pointer_type<Archive> >
-        >
-        >
-        >::type typex;
-    typex::invoke(ar, t);
-}
-
-} // namespace archive
-} // namespace boost
-
-#endif // BOOST_ARCHIVE_DETAIL_ISERIALIZER_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/detail/oserializer.hpp b/contrib/libboost/boost_1_65_0/boost/archive/detail/oserializer.hpp
deleted file mode 100644
index c120ec55073..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/detail/oserializer.hpp
+++ /dev/null
@@ -1,540 +0,0 @@
-#ifndef BOOST_ARCHIVE_OSERIALIZER_HPP
-#define BOOST_ARCHIVE_OSERIALIZER_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#pragma inline_depth(511)
-#pragma inline_recursion(on)
-#endif
-
-#if defined(__MWERKS__)
-#pragma inline_depth(511)
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// oserializer.hpp: interface for serialization system.
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/assert.hpp>
-#include <cstddef> // NULL
-
-#include <boost/config.hpp>
-#include <boost/static_assert.hpp>
-#include <boost/detail/workaround.hpp>
-
-#include <boost/mpl/eval_if.hpp>
-#include <boost/mpl/equal_to.hpp>
-#include <boost/mpl/greater_equal.hpp>
-#include <boost/mpl/identity.hpp>
-#include <boost/mpl/bool_fwd.hpp>
-
-#ifndef BOOST_SERIALIZATION_DEFAULT_TYPE_INFO   
-    #include <boost/serialization/extended_type_info_typeid.hpp>   
-#endif
-#include <boost/serialization/throw_exception.hpp>
-#include <boost/serialization/smart_cast.hpp>
-#include <boost/serialization/assume_abstract.hpp>
-#include <boost/serialization/static_warning.hpp>
-
-#include <boost/type_traits/is_pointer.hpp>
-#include <boost/type_traits/is_enum.hpp>
-#include <boost/type_traits/is_const.hpp>
-#include <boost/type_traits/is_polymorphic.hpp>
-#include <boost/type_traits/remove_extent.hpp>
-
-#include <boost/serialization/serialization.hpp>
-#include <boost/serialization/version.hpp>
-#include <boost/serialization/level.hpp>
-#include <boost/serialization/tracking.hpp>
-#include <boost/serialization/type_info_implementation.hpp>
-#include <boost/serialization/nvp.hpp>
-#include <boost/serialization/void_cast.hpp>
-#include <boost/serialization/collection_size_type.hpp>
-#include <boost/serialization/array_wrapper.hpp>
-
-#include <boost/serialization/singleton.hpp>
-
-#include <boost/archive/archive_exception.hpp>
-#include <boost/archive/detail/basic_oarchive.hpp>
-#include <boost/archive/detail/basic_oserializer.hpp>
-#include <boost/archive/detail/basic_pointer_oserializer.hpp>
-#include <boost/archive/detail/archive_serializer_map.hpp>
-#include <boost/archive/detail/check.hpp>
-
-namespace boost {
-
-namespace serialization {
-    class extended_type_info;
-} // namespace serialization
-
-namespace archive {
-
-// an accessor to permit friend access to archives.  Needed because
-// some compilers don't handle friend templates completely
-class save_access {
-public:
-    template<class Archive>
-    static void end_preamble(Archive & ar){
-        ar.end_preamble();
-    }
-    template<class Archive, class T>
-    static void save_primitive(Archive & ar, const  T & t){
-        ar.end_preamble();
-        ar.save(t);
-    }
-};
-
-namespace detail {
-
-#ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable : 4511 4512)
-#endif
-
-template<class Archive, class T>
-class oserializer : public basic_oserializer
-{
-private:
-    // private constructor to inhibit any existence other than the 
-    // static one
-public:
-    explicit BOOST_DLLEXPORT oserializer() :
-        basic_oserializer(
-            boost::serialization::singleton<
-                typename 
-                boost::serialization::type_info_implementation< T >::type
-            >::get_const_instance()
-        )
-    {}
-    virtual BOOST_DLLEXPORT void save_object_data(
-        basic_oarchive & ar,    
-        const void *x
-    ) const BOOST_USED;
-    virtual bool class_info() const {
-        return boost::serialization::implementation_level< T >::value 
-            >= boost::serialization::object_class_info;
-    }
-    virtual bool tracking(const unsigned int /* flags */) const {
-        return boost::serialization::tracking_level< T >::value == boost::serialization::track_always
-            || (boost::serialization::tracking_level< T >::value == boost::serialization::track_selectively
-                && serialized_as_pointer());
-    }
-    virtual version_type version() const {
-        return version_type(::boost::serialization::version< T >::value);
-    }
-    virtual bool is_polymorphic() const {
-        return boost::is_polymorphic< T >::value;
-    }
-    virtual ~oserializer(){}
-};
-
-#ifdef BOOST_MSVC
-#  pragma warning(pop)
-#endif
-
-template<class Archive, class T>
-BOOST_DLLEXPORT void oserializer<Archive, T>::save_object_data(
-    basic_oarchive & ar,    
-    const void *x
-) const {
-    // make sure call is routed through the highest interface that might
-    // be specialized by the user.
-    BOOST_STATIC_ASSERT(boost::is_const< T >::value == false);
-    boost::serialization::serialize_adl(
-        boost::serialization::smart_cast_reference<Archive &>(ar),
-        * static_cast<T *>(const_cast<void *>(x)),
-        version()
-    );
-}
-
-#ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable : 4511 4512)
-#endif
-
-template<class Archive, class T>
-class pointer_oserializer :
-    public basic_pointer_oserializer
-{
-private:
-    const basic_oserializer & 
-    get_basic_serializer() const {
-        return boost::serialization::singleton<
-            oserializer<Archive, T>
-        >::get_const_instance();
-    }
-    virtual BOOST_DLLEXPORT void save_object_ptr(
-        basic_oarchive & ar,
-        const void * x
-    ) const BOOST_USED;
-public:
-    pointer_oserializer();
-    ~pointer_oserializer();
-};
-
-#ifdef BOOST_MSVC
-#  pragma warning(pop)
-#endif
-
-template<class Archive, class T>
-BOOST_DLLEXPORT void pointer_oserializer<Archive, T>::save_object_ptr(
-    basic_oarchive & ar,
-    const void * x
-) const {
-    BOOST_ASSERT(NULL != x);
-    // make sure call is routed through the highest interface that might
-    // be specialized by the user.
-    T * t = static_cast<T *>(const_cast<void *>(x));
-    const unsigned int file_version = boost::serialization::version< T >::value;
-    Archive & ar_impl 
-        = boost::serialization::smart_cast_reference<Archive &>(ar);
-    boost::serialization::save_construct_data_adl<Archive, T>(
-        ar_impl, 
-        t, 
-        file_version
-    );
-    ar_impl << boost::serialization::make_nvp(NULL, * t);
-}
-
-template<class Archive, class T>
-pointer_oserializer<Archive, T>::pointer_oserializer() :
-    basic_pointer_oserializer(
-        boost::serialization::singleton<
-            typename 
-            boost::serialization::type_info_implementation< T >::type
-        >::get_const_instance()
-    )
-{
-    // make sure appropriate member function is instantiated
-    boost::serialization::singleton<
-        oserializer<Archive, T> 
-    >::get_mutable_instance().set_bpos(this);
-    archive_serializer_map<Archive>::insert(this);
-}
-
-template<class Archive, class T>
-pointer_oserializer<Archive, T>::~pointer_oserializer(){
-    archive_serializer_map<Archive>::erase(this);
-}
-
-template<class Archive>
-struct save_non_pointer_type {
-    // note this bounces the call right back to the archive
-    // with no runtime overhead
-    struct save_primitive {
-        template<class T>
-        static void invoke(Archive & ar, const T & t){
-            save_access::save_primitive(ar, t);
-        }
-    };
-    // same as above but passes through serialization
-    struct save_only {
-        template<class T>
-        static void invoke(Archive & ar, const T & t){
-            // make sure call is routed through the highest interface that might
-            // be specialized by the user.
-            boost::serialization::serialize_adl(
-                ar, 
-                const_cast<T &>(t), 
-                ::boost::serialization::version< T >::value
-            );
-        }
-    };
-    // adds class information to the archive. This includes
-    // serialization level and class version
-    struct save_standard {
-        template<class T>
-        static void invoke(Archive &ar, const T & t){
-            ar.save_object(
-                & t, 
-                boost::serialization::singleton<
-                    oserializer<Archive, T>
-                >::get_const_instance()
-            );
-        }
-    };
-
-    // adds class information to the archive. This includes
-    // serialization level and class version
-    struct save_conditional {
-        template<class T>
-        static void invoke(Archive &ar, const T &t){
-            //if(0 == (ar.get_flags() & no_tracking))
-                save_standard::invoke(ar, t);
-            //else
-            //   save_only::invoke(ar, t);
-        }
-    };
-
-
-    template<class T>
-    static void invoke(Archive & ar, const T & t){
-        typedef 
-            typename mpl::eval_if<
-            // if its primitive
-                mpl::equal_to<
-                    boost::serialization::implementation_level< T >,
-                    mpl::int_<boost::serialization::primitive_type>
-                >,
-                mpl::identity<save_primitive>,
-            // else
-            typename mpl::eval_if<
-                // class info / version
-                mpl::greater_equal<
-                    boost::serialization::implementation_level< T >,
-                    mpl::int_<boost::serialization::object_class_info>
-                >,
-                // do standard save
-                mpl::identity<save_standard>,
-            // else
-            typename mpl::eval_if<
-                    // no tracking
-                mpl::equal_to<
-                    boost::serialization::tracking_level< T >,
-                    mpl::int_<boost::serialization::track_never>
-                >,
-                // do a fast save
-                mpl::identity<save_only>,
-            // else
-                // do a fast save only tracking is turned off
-                mpl::identity<save_conditional>
-            > > >::type typex; 
-        check_object_versioning< T >();
-        typex::invoke(ar, t);
-    }
-    template<class T>
-    static void invoke(Archive & ar, T & t){
-        check_object_level< T >();
-        check_object_tracking< T >();
-        invoke(ar, const_cast<const T &>(t));
-    }
-};
-
-template<class Archive>
-struct save_pointer_type {
-    struct abstract
-    {
-        template<class T>
-        static const basic_pointer_oserializer * register_type(Archive & /* ar */){
-            // it has? to be polymorphic
-            BOOST_STATIC_ASSERT(boost::is_polymorphic< T >::value);
-            return NULL;
-        }
-    };
-
-    struct non_abstract
-    {
-        template<class T>
-        static const basic_pointer_oserializer * register_type(Archive & ar){
-            return ar.register_type(static_cast<T *>(NULL));
-        }
-    };
-
-    template<class T>
-    static const basic_pointer_oserializer * register_type(Archive &ar, T & /*t*/){
-        // there should never be any need to save an abstract polymorphic 
-        // class pointer.  Inhibiting code generation for this
-        // permits abstract base classes to be used - note: exception
-        // virtual serialize functions used for plug-ins
-        typedef 
-            typename mpl::eval_if<
-                boost::serialization::is_abstract< T >,
-                mpl::identity<abstract>,
-                mpl::identity<non_abstract>       
-            >::type typex;
-        return typex::template register_type< T >(ar);
-    }
-
-    struct non_polymorphic
-    {
-        template<class T>
-        static void save(
-            Archive &ar, 
-            T & t
-        ){
-            const basic_pointer_oserializer & bpos = 
-                boost::serialization::singleton<
-                    pointer_oserializer<Archive, T>
-                >::get_const_instance();
-            // save the requested pointer type
-            ar.save_pointer(& t, & bpos);
-        }
-    };
-
-    struct polymorphic
-    {
-        template<class T>
-        static void save(
-            Archive &ar, 
-            T & t
-        ){
-            typename 
-            boost::serialization::type_info_implementation< T >::type const
-            & i = boost::serialization::singleton<
-                typename 
-                boost::serialization::type_info_implementation< T >::type
-            >::get_const_instance();
-
-            boost::serialization::extended_type_info const * const this_type = & i;
-
-            // retrieve the true type of the object pointed to
-            // if this assertion fails its an error in this library
-            BOOST_ASSERT(NULL != this_type);
-
-            const boost::serialization::extended_type_info * true_type =
-                i.get_derived_extended_type_info(t);
-
-            // note:if this exception is thrown, be sure that derived pointer
-            // is either registered or exported.
-            if(NULL == true_type){
-                boost::serialization::throw_exception(
-                    archive_exception(
-                        archive_exception::unregistered_class,
-                        "derived class not registered or exported"
-                    )
-                );
-            }
-
-            // if its not a pointer to a more derived type
-            const void *vp = static_cast<const void *>(&t);
-            if(*this_type == *true_type){
-                const basic_pointer_oserializer * bpos = register_type(ar, t);
-                ar.save_pointer(vp, bpos);
-                return;
-            }
-            // convert pointer to more derived type. if this is thrown
-            // it means that the base/derived relationship hasn't be registered
-            vp = serialization::void_downcast(
-                *true_type, 
-                *this_type, 
-                static_cast<const void *>(&t)
-            );
-            if(NULL == vp){
-                boost::serialization::throw_exception(
-                    archive_exception(
-                        archive_exception::unregistered_cast,
-                        true_type->get_debug_info(),
-                        this_type->get_debug_info()
-                    )
-                );
-            }
-
-            // since true_type is valid, and this only gets made if the 
-            // pointer oserializer object has been created, this should never
-            // fail
-            const basic_pointer_oserializer * bpos
-                = static_cast<const basic_pointer_oserializer *>(
-                    boost::serialization::singleton<
-                        archive_serializer_map<Archive>
-                    >::get_const_instance().find(*true_type)
-                );
-            BOOST_ASSERT(NULL != bpos);
-            if(NULL == bpos)
-                boost::serialization::throw_exception(
-                    archive_exception(
-                        archive_exception::unregistered_class,
-                        "derived class not registered or exported"
-                    )
-                );
-            ar.save_pointer(vp, bpos);
-        }
-    };
-
-    template<class T>
-    static void save(
-        Archive & ar, 
-        const T & t
-    ){
-        check_pointer_level< T >();
-        check_pointer_tracking< T >();
-        typedef typename mpl::eval_if<
-            is_polymorphic< T >,
-            mpl::identity<polymorphic>,
-            mpl::identity<non_polymorphic>
-        >::type type;
-        type::save(ar, const_cast<T &>(t));
-    }
-
-    template<class TPtr>
-    static void invoke(Archive &ar, const TPtr t){
-        register_type(ar, * t);
-        if(NULL == t){
-            basic_oarchive & boa 
-                = boost::serialization::smart_cast_reference<basic_oarchive &>(ar);
-            boa.save_null_pointer();
-            save_access::end_preamble(ar);
-            return;
-        }
-        save(ar, * t);
-    }
-};
-
-template<class Archive>
-struct save_enum_type
-{
-    template<class T>
-    static void invoke(Archive &ar, const T &t){
-        // convert enum to integers on save
-        const int i = static_cast<int>(t);
-        ar << boost::serialization::make_nvp(NULL, i);
-    }
-};
-
-template<class Archive>
-struct save_array_type
-{
-    template<class T>
-    static void invoke(Archive &ar, const T &t){
-        typedef typename boost::remove_extent< T >::type value_type;
-        
-        save_access::end_preamble(ar);
-        // consider alignment
-        std::size_t c = sizeof(t) / (
-            static_cast<const char *>(static_cast<const void *>(&t[1])) 
-            - static_cast<const char *>(static_cast<const void *>(&t[0]))
-        );
-        boost::serialization::collection_size_type count(c);
-        ar << BOOST_SERIALIZATION_NVP(count);
-        // explict template arguments to pass intel C++ compiler
-        ar << serialization::make_array<
-            const value_type,
-            boost::serialization::collection_size_type
-        >(
-            static_cast<const value_type *>(&t[0]),
-            count
-        );
-    }
-};
-
-} // detail
-
-template<class Archive, class T>
-inline void save(Archive & ar, /*const*/ T &t){
-    typedef 
-        typename mpl::eval_if<is_pointer< T >,
-            mpl::identity<detail::save_pointer_type<Archive> >,
-        //else
-        typename mpl::eval_if<is_enum< T >,
-            mpl::identity<detail::save_enum_type<Archive> >,
-        //else
-        typename mpl::eval_if<is_array< T >,
-            mpl::identity<detail::save_array_type<Archive> >,
-        //else
-            mpl::identity<detail::save_non_pointer_type<Archive> >
-        >
-        >
-        >::type typex;
-    typex::invoke(ar, t);
-}
-
-} // namespace archive
-} // namespace boost
-
-#endif // BOOST_ARCHIVE_OSERIALIZER_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/detail/polymorphic_iarchive_route.hpp b/contrib/libboost/boost_1_65_0/boost/archive/detail/polymorphic_iarchive_route.hpp
deleted file mode 100644
index 105685ebbd8..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/detail/polymorphic_iarchive_route.hpp
+++ /dev/null
@@ -1,218 +0,0 @@
-#ifndef BOOST_ARCHIVE_DETAIL_POLYMORPHIC_IARCHIVE_ROUTE_HPP
-#define BOOST_ARCHIVE_DETAIL_POLYMORPHIC_IARCHIVE_ROUTE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// polymorphic_iarchive_route.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <string>
-#include <ostream>
-#include <cstddef>
-
-#include <boost/config.hpp>
-#if defined(BOOST_NO_STDC_NAMESPACE)
-namespace std{
-    using ::size_t;
-} // namespace std
-#endif
-
-#include <boost/cstdint.hpp>
-#include <boost/integer_traits.hpp>
-#include <boost/archive/polymorphic_iarchive.hpp>
-#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
-
-namespace boost {
-namespace serialization {
-    class extended_type_info;
-} // namespace serialization
-namespace archive {
-namespace detail{
-
-class basic_iserializer;
-class basic_pointer_iserializer;
-
-#ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable : 4511 4512)
-#endif
-
-template<class ArchiveImplementation>
-class polymorphic_iarchive_route :
-    public polymorphic_iarchive,
-    // note: gcc dynamic cross cast fails if the the derivation below is
-    // not public.  I think this is a mistake.
-    public /*protected*/ ArchiveImplementation
-{
-private:
-    // these are used by the serialization library.
-    virtual void load_object(
-        void *t,
-        const basic_iserializer & bis
-    ){
-        ArchiveImplementation::load_object(t, bis);
-    }
-    virtual const basic_pointer_iserializer * load_pointer(
-        void * & t,
-        const basic_pointer_iserializer * bpis_ptr,
-        const basic_pointer_iserializer * (*finder)(
-            const boost::serialization::extended_type_info & type
-        )
-    ){
-        return ArchiveImplementation::load_pointer(t, bpis_ptr, finder);
-    }
-    virtual void set_library_version(library_version_type archive_library_version){
-        ArchiveImplementation::set_library_version(archive_library_version);
-    }
-    virtual library_version_type get_library_version() const{
-        return ArchiveImplementation::get_library_version();
-    }
-    virtual unsigned int get_flags() const {
-        return ArchiveImplementation::get_flags();
-    }
-    virtual void delete_created_pointers(){
-        ArchiveImplementation::delete_created_pointers();
-    }
-    virtual void reset_object_address(
-        const void * new_address,
-        const void * old_address
-    ){
-        ArchiveImplementation::reset_object_address(new_address, old_address);
-    }
-    virtual void load_binary(void * t, std::size_t size){
-        ArchiveImplementation::load_binary(t, size);
-    }
-    // primitive types the only ones permitted by polymorphic archives
-    virtual void load(bool & t){
-        ArchiveImplementation::load(t);
-    }
-    virtual void load(char & t){
-        ArchiveImplementation::load(t);
-    }
-    virtual void load(signed char & t){
-        ArchiveImplementation::load(t);
-    }
-    virtual void load(unsigned char & t){
-        ArchiveImplementation::load(t);
-    }
-    #ifndef BOOST_NO_CWCHAR
-    #ifndef BOOST_NO_INTRINSIC_WCHAR_T
-    virtual void load(wchar_t & t){
-        ArchiveImplementation::load(t);
-    }
-    #endif
-    #endif
-    virtual void load(short & t){
-        ArchiveImplementation::load(t);
-    }
-    virtual void load(unsigned short & t){
-        ArchiveImplementation::load(t);
-    }
-    virtual void load(int & t){
-        ArchiveImplementation::load(t);
-    }
-    virtual void load(unsigned int & t){
-        ArchiveImplementation::load(t);
-    }
-    virtual void load(long & t){
-        ArchiveImplementation::load(t);
-    }
-    virtual void load(unsigned long & t){
-        ArchiveImplementation::load(t);
-    }
-    #if defined(BOOST_HAS_LONG_LONG)
-    virtual void load(boost::long_long_type & t){
-        ArchiveImplementation::load(t);
-    }
-    virtual void load(boost::ulong_long_type & t){
-        ArchiveImplementation::load(t);
-    }
-    #elif defined(BOOST_HAS_MS_INT64)
-    virtual void load(__int64 & t){
-        ArchiveImplementation::load(t);
-    }
-    virtual void load(unsigned __int64 & t){
-        ArchiveImplementation::load(t);
-    }
-    #endif
-    virtual void load(float & t){
-        ArchiveImplementation::load(t);
-    }
-    virtual void load(double & t){
-        ArchiveImplementation::load(t);
-    }
-    virtual void load(std::string & t){
-        ArchiveImplementation::load(t);
-    }
-    #ifndef BOOST_NO_STD_WSTRING
-    virtual void load(std::wstring & t){
-        ArchiveImplementation::load(t);
-    }
-    #endif
-    // used for xml and other tagged formats default does nothing
-    virtual void load_start(const char * name){
-        ArchiveImplementation::load_start(name);
-    }
-    virtual void load_end(const char * name){
-        ArchiveImplementation::load_end(name);
-    }
-    virtual void register_basic_serializer(const basic_iserializer & bis){
-        ArchiveImplementation::register_basic_serializer(bis);
-    }
-    virtual helper_collection &
-    get_helper_collection(){
-        return ArchiveImplementation::get_helper_collection();
-    }
-public:
-    // this can't be inheriteded because they appear in mulitple
-    // parents
-    typedef mpl::bool_<true> is_loading;
-    typedef mpl::bool_<false> is_saving;
-    // the >> operator
-    template<class T>
-    polymorphic_iarchive & operator>>(T & t){
-        return polymorphic_iarchive::operator>>(t);
-    }
-    // the & operator
-    template<class T>
-    polymorphic_iarchive & operator&(T & t){
-        return polymorphic_iarchive::operator&(t);
-    }
-    // register type function
-    template<class T>
-    const basic_pointer_iserializer * 
-    register_type(T * t = NULL){
-        return ArchiveImplementation::register_type(t);
-    }
-    // all current archives take a stream as constructor argument
-    template <class _Elem, class _Tr>
-    polymorphic_iarchive_route(
-        std::basic_istream<_Elem, _Tr> & is,
-        unsigned int flags = 0
-    ) :
-        ArchiveImplementation(is, flags)
-    {}
-    virtual ~polymorphic_iarchive_route(){};
-};
-
-} // namespace detail
-} // namespace archive
-} // namespace boost
-
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
-
-#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
-
-#endif // BOOST_ARCHIVE_DETAIL_POLYMORPHIC_IARCHIVE_DISPATCH_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/detail/polymorphic_oarchive_route.hpp b/contrib/libboost/boost_1_65_0/boost/archive/detail/polymorphic_oarchive_route.hpp
deleted file mode 100644
index b23fd6bf39d..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/detail/polymorphic_oarchive_route.hpp
+++ /dev/null
@@ -1,209 +0,0 @@
-#ifndef BOOST_ARCHIVE_DETAIL_POLYMORPHIC_OARCHIVE_ROUTE_HPP
-#define BOOST_ARCHIVE_DETAIL_POLYMORPHIC_OARCHIVE_ROUTE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// polymorphic_oarchive_route.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <string>
-#include <ostream>
-#include <cstddef> // size_t
-
-#include <boost/config.hpp>
-#if defined(BOOST_NO_STDC_NAMESPACE)
-namespace std{
-    using ::size_t;
-} // namespace std
-#endif
-
-#include <boost/cstdint.hpp>
-#include <boost/integer_traits.hpp>
-#include <boost/archive/polymorphic_oarchive.hpp>
-#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
-
-namespace boost {
-namespace serialization {
-    class extended_type_info;
-} // namespace serialization
-namespace archive {
-namespace detail{
-
-class basic_oserializer;
-class basic_pointer_oserializer;
-
-#ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable : 4511 4512)
-#endif
-
-template<class ArchiveImplementation>
-class polymorphic_oarchive_route :
-    public polymorphic_oarchive,
-    // note: gcc dynamic cross cast fails if the the derivation below is
-    // not public.  I think this is a mistake.
-    public /*protected*/ ArchiveImplementation
-{
-private:
-    // these are used by the serialization library.
-    virtual void save_object(
-        const void *x,
-        const detail::basic_oserializer & bos
-    ){
-        ArchiveImplementation::save_object(x, bos);
-    }
-    virtual void save_pointer(
-        const void * t,
-        const detail::basic_pointer_oserializer * bpos_ptr
-    ){
-        ArchiveImplementation::save_pointer(t, bpos_ptr);
-    }
-    virtual void save_null_pointer(){
-        ArchiveImplementation::save_null_pointer();
-    }
-    // primitive types the only ones permitted by polymorphic archives
-    virtual void save(const bool t){
-        ArchiveImplementation::save(t);
-    }
-    virtual void save(const char t){
-        ArchiveImplementation::save(t);
-    }
-    virtual void save(const signed char t){
-        ArchiveImplementation::save(t);
-    }
-    virtual void save(const unsigned char t){
-        ArchiveImplementation::save(t);
-    }
-    #ifndef BOOST_NO_CWCHAR
-    #ifndef BOOST_NO_INTRINSIC_WCHAR_T
-    virtual void save(const wchar_t t){
-        ArchiveImplementation::save(t);
-    }
-    #endif
-    #endif
-    virtual void save(const short t){
-        ArchiveImplementation::save(t);
-    }
-    virtual void save(const unsigned short t){
-        ArchiveImplementation::save(t);
-    }
-    virtual void save(const int t){
-        ArchiveImplementation::save(t);
-    }
-    virtual void save(const unsigned int t){
-        ArchiveImplementation::save(t);
-    }
-    virtual void save(const long t){
-        ArchiveImplementation::save(t);
-    }
-    virtual void save(const unsigned long t){
-        ArchiveImplementation::save(t);
-    }
-    #if defined(BOOST_HAS_LONG_LONG)
-    virtual void save(const boost::long_long_type t){
-        ArchiveImplementation::save(t);
-    }
-    virtual void save(const boost::ulong_long_type t){
-        ArchiveImplementation::save(t);
-    }
-    #elif defined(BOOST_HAS_MS_INT64)
-    virtual void save(const boost::int64_t t){
-        ArchiveImplementation::save(t);
-    }
-    virtual void save(const boost::uint64_t t){
-        ArchiveImplementation::save(t);
-    }
-    #endif
-    virtual void save(const float t){
-        ArchiveImplementation::save(t);
-    }
-    virtual void save(const double t){
-        ArchiveImplementation::save(t);
-    }
-    virtual void save(const std::string & t){
-        ArchiveImplementation::save(t);
-    }
-    #ifndef BOOST_NO_STD_WSTRING
-    virtual void save(const std::wstring & t){
-        ArchiveImplementation::save(t);
-    }
-    #endif
-    virtual library_version_type get_library_version() const{
-        return ArchiveImplementation::get_library_version();
-    }
-    virtual unsigned int get_flags() const {
-        return ArchiveImplementation::get_flags();
-    }
-    virtual void save_binary(const void * t, std::size_t size){
-        ArchiveImplementation::save_binary(t, size);
-    }
-    // used for xml and other tagged formats default does nothing
-    virtual void save_start(const char * name){
-        ArchiveImplementation::save_start(name);
-    }
-    virtual void save_end(const char * name){
-        ArchiveImplementation::save_end(name);
-    }
-    virtual void end_preamble(){
-        ArchiveImplementation::end_preamble();
-    }
-    virtual void register_basic_serializer(const detail::basic_oserializer & bos){
-        ArchiveImplementation::register_basic_serializer(bos);
-    }
-    virtual helper_collection &
-    get_helper_collection(){
-        return ArchiveImplementation::get_helper_collection();
-    }
-public:
-    // this can't be inheriteded because they appear in mulitple
-    // parents
-    typedef mpl::bool_<false> is_loading;
-    typedef mpl::bool_<true> is_saving;
-    // the << operator
-    template<class T>
-    polymorphic_oarchive & operator<<(T & t){
-        return polymorphic_oarchive::operator<<(t);
-    }
-    // the & operator
-    template<class T>
-    polymorphic_oarchive & operator&(T & t){
-        return polymorphic_oarchive::operator&(t);
-    }
-    // register type function
-    template<class T>
-    const basic_pointer_oserializer * 
-    register_type(T * t = NULL){
-        return ArchiveImplementation::register_type(t);
-    }
-    // all current archives take a stream as constructor argument
-    template <class _Elem, class _Tr>
-    polymorphic_oarchive_route(
-        std::basic_ostream<_Elem, _Tr> & os,
-        unsigned int flags = 0
-    ) :
-        ArchiveImplementation(os, flags)
-    {}
-    virtual ~polymorphic_oarchive_route(){};
-};
-
-} // namespace detail
-} // namespace archive
-} // namespace boost
-
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
-
-#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
-
-#endif // BOOST_ARCHIVE_DETAIL_POLYMORPHIC_OARCHIVE_DISPATCH_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/detail/register_archive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/detail/register_archive.hpp
deleted file mode 100644
index 5ffecc702ce..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/detail/register_archive.hpp
+++ /dev/null
@@ -1,91 +0,0 @@
-// Copyright David Abrahams 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)
-#ifndef BOOST_ARCHIVE_DETAIL_REGISTER_ARCHIVE_DWA2006521_HPP
-# define BOOST_ARCHIVE_DETAIL_REGISTER_ARCHIVE_DWA2006521_HPP
-
-namespace boost { namespace archive { namespace detail { 
-
-// No instantiate_ptr_serialization overloads generated by
-// BOOST_SERIALIZATION_REGISTER_ARCHIVE that lexically follow the call
-// will be seen *unless* they are in an associated namespace of one of
-// the arguments, so we pass one of these along to make sure this
-// namespace is considered.  See temp.dep.candidate (14.6.4.2) in the
-// standard.
-struct adl_tag {};
-
-template <class Archive, class Serializable>
-struct ptr_serialization_support;
-
-// We could've just used ptr_serialization_support, above, but using
-// it with only a forward declaration causes vc6/7 to complain about a
-// missing instantiate member, even if it has one.  This is just a
-// friendly layer of indirection.
-template <class Archive, class Serializable>
-struct _ptr_serialization_support
-  : ptr_serialization_support<Archive,Serializable>
-{
-    typedef int type;
-};
-
-#if defined(__SUNPRO_CC) && (__SUNPRO_CC < 0x5130)
-
-template<int N>
-struct counter : counter<N-1> {};
-template<>
-struct counter<0> {};
-
-template<class Serializable>
-void instantiate_ptr_serialization(Serializable* s, int, adl_tag) {
-    instantiate_ptr_serialization(s, counter<20>());
-}
-
-template<class Archive>
-struct get_counter {
-    static const int value = sizeof(adjust_counter(counter<20>()));
-    typedef counter<value> type;
-    typedef counter<value - 1> prior;
-    typedef char (&next)[value+1];
-};
-
-char adjust_counter(counter<0>);
-template<class Serializable>
-void instantiate_ptr_serialization(Serializable*, counter<0>) {}
-
-#define BOOST_SERIALIZATION_REGISTER_ARCHIVE(Archive)                     \
-namespace boost { namespace archive { namespace detail {                  \
-    get_counter<Archive >::next adjust_counter(get_counter<Archive >::type);\
-    template<class Serializable>                                          \
-    void instantiate_ptr_serialization(Serializable* s,                   \
-        get_counter<Archive >::type) {                                    \
-        ptr_serialization_support<Archive, Serializable> x;               \
-        instantiate_ptr_serialization(s, get_counter<Archive >::prior()); \
-    }\
-}}}
-
-
-#else
-
-// This function gets called, but its only purpose is to participate
-// in overload resolution with the functions declared by
-// BOOST_SERIALIZATION_REGISTER_ARCHIVE, below.
-template <class Serializable>
-void instantiate_ptr_serialization(Serializable*, int, adl_tag ) {}
-
-// The function declaration generated by this macro never actually
-// gets called, but its return type gets instantiated, and that's
-// enough to cause registration of serialization functions between
-// Archive and any exported Serializable type.  See also:
-// boost/serialization/export.hpp
-# define BOOST_SERIALIZATION_REGISTER_ARCHIVE(Archive)                  \
-namespace boost { namespace archive { namespace detail {                \
-                                                                        \
-template <class Serializable>                                           \
-typename _ptr_serialization_support<Archive, Serializable>::type  \
-instantiate_ptr_serialization( Serializable*, Archive*, adl_tag );              \
-                                                                        \
-}}}
-#endif
-}}} // namespace boost::archive::detail
-
-#endif // BOOST_ARCHIVE_DETAIL_INSTANTIATE_SERIALIZE_DWA2006521_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/detail/utf8_codecvt_facet.hpp b/contrib/libboost/boost_1_65_0/boost/archive/detail/utf8_codecvt_facet.hpp
deleted file mode 100644
index a40104abea6..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/detail/utf8_codecvt_facet.hpp
+++ /dev/null
@@ -1,39 +0,0 @@
-// Copyright (c) 2001 Ronald Garcia, Indiana University (garcia@osl.iu.edu)
-// Andrew Lumsdaine, Indiana University (lums@osl.iu.edu).
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_ARCHIVE_DETAIL_UTF8_CODECVT_FACET_HPP
-#define BOOST_ARCHIVE_DETAIL_UTF8_CODECVT_FACET_HPP
-
-#include <boost/config.hpp>
-
-#ifdef BOOST_NO_STD_WSTREAMBUF
-#error "wide char i/o not supported on this platform"
-#endif
-
-// std::codecvt_utf8 doesn't seem to work for any versions of msvc
-
-#if defined(_MSC_VER) || defined(BOOST_NO_CXX11_HDR_CODECVT)
-    // use boost's utf8 codecvt facet
-    #include <boost/archive/detail/decl.hpp>
-    #define BOOST_UTF8_BEGIN_NAMESPACE \
-         namespace boost { namespace archive { namespace detail {
-    #define BOOST_UTF8_DECL BOOST_ARCHIVE_DECL
-    #define BOOST_UTF8_END_NAMESPACE }}}
-
-    #include <boost/detail/utf8_codecvt_facet.hpp>
-
-    #undef BOOST_UTF8_END_NAMESPACE
-    #undef BOOST_UTF8_DECL
-    #undef BOOST_UTF8_BEGIN_NAMESPACE
-#else
-    // use the standard vendor supplied facet
-    #include <codecvt>
-    namespace boost { namespace archive { namespace detail {
-        typedef std::codecvt_utf8<wchar_t> utf8_codecvt_facet;
-    } } }
-#endif
-
-#endif // BOOST_ARCHIVE_DETAIL_UTF8_CODECVT_FACET_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/dinkumware.hpp b/contrib/libboost/boost_1_65_0/boost/archive/dinkumware.hpp
deleted file mode 100644
index 90ba6271cdd..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/dinkumware.hpp
+++ /dev/null
@@ -1,224 +0,0 @@
-#ifndef BOOST_ARCHIVE_DINKUMWARE_HPP
-#define BOOST_ARCHIVE_DINKUMWARE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// dinkumware.hpp:
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-// this file adds a couple of things that are missing from the dinkumware
-// implementation of the standard library.
-
-#include <iterator>
-#include <string>
-
-#include <boost/config.hpp>
-#include <boost/cstdint.hpp>
-
-namespace std {
-
-// define i/o operators for 64 bit integers
-template<class CharType>
-basic_ostream<CharType> & 
-operator<<(basic_ostream<CharType> & os, boost::uint64_t t){
-    // octal rendering of 64 bit number would be 22 octets + eos
-    CharType d[23];
-    unsigned int radix;
-
-    if(os.flags() & (int)std::ios_base::hex)
-        radix = 16;
-    else
-    if(os.flags() & (int)std::ios_base::oct)
-        radix = 8;
-    else
-    //if(s.flags() & (int)std::ios_base::dec)
-        radix =  10;
-    unsigned int i = 0;
-    do{
-        unsigned int j = t % radix;
-        d[i++] = j + ((j < 10) ? '0' : ('a' - 10));
-        t /= radix;
-    }
-    while(t > 0);
-    d[i--] = '\0';
-
-    // reverse digits
-    unsigned int j = 0;
-    while(j < i){
-        CharType k = d[i];
-        d[i] = d[j];
-        d[j] = k;
-        --i;++j;
-    }
-    os << d;
-    return os;
-
-}
-
-template<class CharType>
-basic_ostream<CharType> & 
-operator<<(basic_ostream<CharType> &os, boost::int64_t t){
-    if(0 <= t){
-        os << static_cast<boost::uint64_t>(t);
-    }
-    else{
-        os.put('-');
-        os << -t;
-    }
-    return os;
-}
-
-template<class CharType>
-basic_istream<CharType> & 
-operator>>(basic_istream<CharType> &is, boost::int64_t & t){
-    CharType d;
-    do{
-        d = is.get();
-    }
-    while(::isspace(d));
-    bool negative = (d == '-');
-    if(negative)
-        d = is.get();
-    unsigned int radix;
-    if(is.flags() & (int)std::ios_base::hex)
-        radix = 16;
-    else
-    if(is.flags() & (int)std::ios_base::oct)
-        radix = 8;
-    else
-    //if(s.flags() & (int)std::ios_base::dec)
-        radix =  10;
-    t = 0;
-    do{
-        if('0' <= d && d <= '9')
-            t = t * radix + (d - '0');
-        else
-        if('a' <= d && d <= 'f')
-            t = t * radix + (d - 'a' + 10);
-        else
-            break;
-        d = is.get();
-    }
-    while(!is.fail());
-    // restore the delimiter
-    is.putback(d);
-    is.clear();
-    if(negative)
-        t = -t;
-    return is;
-}
-
-template<class CharType>
-basic_istream<CharType> & 
-operator>>(basic_istream<CharType> &is, boost::uint64_t & t){
-    boost::int64_t it;
-    is >> it;
-    t = it;
-    return is;
-}
-
-//#endif
-
-template<>
-class back_insert_iterator<basic_string<char> > : public 
-    iterator<output_iterator_tag, char>
-{
-public:
-    typedef basic_string<char> container_type;
-    typedef container_type::reference reference;
-
-    explicit back_insert_iterator(container_type & s)
-        : container(& s)
-    {}    // construct with container
-    
-    back_insert_iterator<container_type> & operator=(
-        container_type::const_reference Val_
-    ){    // push value into container
-        //container->push_back(Val_);
-        *container += Val_;
-        return (*this);
-    }
-
-    back_insert_iterator<container_type> & operator*(){
-        return (*this);
-    }
-
-    back_insert_iterator<container_type> & operator++(){
-        // pretend to preincrement
-        return (*this);
-    }
-
-    back_insert_iterator<container_type> operator++(int){
-        // pretend to postincrement
-        return (*this);
-    }
-
-protected:
-    container_type *container;    // pointer to container
-};
-
-template<char> 
-inline back_insert_iterator<basic_string<char> > back_inserter(
-    basic_string<char> & s
-){
-    return (std::back_insert_iterator<basic_string<char> >(s));
-}
-
-template<>
-class back_insert_iterator<basic_string<wchar_t> > : public 
-    iterator<output_iterator_tag, wchar_t>
-{
-public:
-    typedef basic_string<wchar_t> container_type;
-    typedef container_type::reference reference;
-
-    explicit back_insert_iterator(container_type & s)
-        : container(& s)
-    {}    // construct with container
-    
-    back_insert_iterator<container_type> & operator=(
-        container_type::const_reference Val_
-    ){    // push value into container
-        //container->push_back(Val_);
-        *container += Val_;
-        return (*this);
-    }
-
-    back_insert_iterator<container_type> & operator*(){
-        return (*this);
-    }
-
-    back_insert_iterator<container_type> & operator++(){
-        // pretend to preincrement
-        return (*this);
-    }
-
-    back_insert_iterator<container_type> operator++(int){
-        // pretend to postincrement
-        return (*this);
-    }
-
-protected:
-    container_type *container;    // pointer to container
-};
-
-template<wchar_t> 
-inline back_insert_iterator<basic_string<wchar_t> > back_inserter(
-    basic_string<wchar_t> & s
-){
-    return (std::back_insert_iterator<basic_string<wchar_t> >(s));
-}
-
-} // namespace std
-
-#endif //BOOST_ARCHIVE_DINKUMWARE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/impl/archive_serializer_map.ipp b/contrib/libboost/boost_1_65_0/boost/archive/impl/archive_serializer_map.ipp
deleted file mode 100644
index 7f163ec4076..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/impl/archive_serializer_map.ipp
+++ /dev/null
@@ -1,75 +0,0 @@
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// archive_serializer_map.ipp:
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-
-//  See http://www.boost.org for updates, documentation, and revision history.
-
-//////////////////////////////////////////////////////////////////////
-// implementation of basic_text_iprimitive overrides for the combination
-// of template parameters used to implement a text_iprimitive
-
-#include <boost/config.hpp>
-#include <boost/archive/detail/archive_serializer_map.hpp>
-#include <boost/archive/detail/basic_serializer_map.hpp>
-#include <boost/serialization/singleton.hpp>
-
-namespace boost {
-namespace archive {
-namespace detail {
-
-#ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable : 4511 4512)
-#endif
-
-namespace extra_detail { // anon
-    template<class Archive>
-    class map : public basic_serializer_map 
-    {};
-}
-
-#ifdef BOOST_MSVC
-#  pragma warning(pop)
-#endif
-
-template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL bool
-archive_serializer_map<Archive>::insert(const basic_serializer * bs){
-    return boost::serialization::singleton<
-        extra_detail::map<Archive>
-    >::get_mutable_instance().insert(bs);
-}
-
-template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-archive_serializer_map<Archive>::erase(const basic_serializer * bs){
-    BOOST_ASSERT(! boost::serialization::singleton<
-            extra_detail::map<Archive>
-        >::is_destroyed()
-    );
-    if(boost::serialization::singleton<
-        extra_detail::map<Archive>
-    >::is_destroyed())
-        return;
-    boost::serialization::singleton<
-        extra_detail::map<Archive>
-    >::get_mutable_instance().erase(bs);
-}
-
-template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL const basic_serializer *
-archive_serializer_map<Archive>::find(
-    const boost::serialization::extended_type_info & eti
-) {
-    return boost::serialization::singleton<
-        extra_detail::map<Archive>
-    >::get_const_instance().find(eti);
-}
-
-} // namespace detail
-} // namespace archive
-} // namespace boost
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/impl/basic_binary_iarchive.ipp b/contrib/libboost/boost_1_65_0/boost/archive/impl/basic_binary_iarchive.ipp
deleted file mode 100644
index d5619ab6cf3..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/impl/basic_binary_iarchive.ipp
+++ /dev/null
@@ -1,134 +0,0 @@
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// basic_binary_iarchive.ipp:
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-#include <string>
-#include <boost/assert.hpp>
-#include <algorithm>
-#include <cstring>
-
-#include <boost/config.hpp>
-#if defined(BOOST_NO_STDC_NAMESPACE)
-namespace std{ 
-    using ::memcpy; 
-    using ::strlen;
-    using ::size_t;
-}
-#endif
-
-#include <boost/detail/workaround.hpp>
-#include <boost/detail/endian.hpp>
-
-#include <boost/archive/basic_binary_iarchive.hpp>
-
-namespace boost {
-namespace archive {
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// implementation of binary_binary_archive
-template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-basic_binary_iarchive<Archive>::load_override(class_name_type & t){
-    std::string cn;
-    cn.reserve(BOOST_SERIALIZATION_MAX_KEY_SIZE);
-    load_override(cn);
-    if(cn.size() > (BOOST_SERIALIZATION_MAX_KEY_SIZE - 1))
-        boost::serialization::throw_exception(
-            archive_exception(archive_exception::invalid_class_name)
-        );
-    std::memcpy(t, cn.data(), cn.size());
-    // borland tweak
-    t.t[cn.size()] = '\0';
-}
-
-template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-basic_binary_iarchive<Archive>::init(void){
-    // read signature in an archive version independent manner
-    std::string file_signature;
-    
-    #if 0 // commented out since it interfers with derivation
-    BOOST_TRY {
-        std::size_t l;
-        this->This()->load(l);
-        if(l == std::strlen(BOOST_ARCHIVE_SIGNATURE())) {
-            // borland de-allocator fixup
-            #if BOOST_WORKAROUND(_RWSTD_VER, BOOST_TESTED_AT(20101))
-            if(NULL != file_signature.data())
-            #endif
-                file_signature.resize(l);
-            // note breaking a rule here - could be a problem on some platform
-            if(0 < l)
-                this->This()->load_binary(&(*file_signature.begin()), l);
-        }
-    }
-    BOOST_CATCH(archive_exception const &) {  // catch stream_error archive exceptions
-        // will cause invalid_signature archive exception to be thrown below
-        file_signature = "";   
-    }
-    BOOST_CATCH_END
-    #else
-    // https://svn.boost.org/trac/boost/ticket/7301
-    * this->This() >> file_signature;
-    #endif
-
-    if(file_signature != BOOST_ARCHIVE_SIGNATURE())
-        boost::serialization::throw_exception(
-            archive_exception(archive_exception::invalid_signature)
-        );
-
-    // make sure the version of the reading archive library can
-    // support the format of the archive being read
-    library_version_type input_library_version;
-    //* this->This() >> input_library_version;
-    {
-        int v = 0;
-        v = this->This()->m_sb.sbumpc();
-        #if defined(BOOST_LITTLE_ENDIAN)
-        if(v < 6){
-            ;
-        }
-        else
-        if(v < 7){
-            // version 6 - next byte should be zero
-            this->This()->m_sb.sbumpc();
-        }
-        else
-        if(v < 8){
-            int x1;
-            // version 7 = might be followed by zero or some other byte
-            x1 = this->This()->m_sb.sgetc();
-            // it's =a zero, push it back
-            if(0 == x1)
-                this->This()->m_sb.sbumpc();
-        }
-        else{
-            // version 8+ followed by a zero
-            this->This()->m_sb.sbumpc();
-        }
-        #elif defined(BOOST_BIG_ENDIAN)
-        if(v == 0)
-            v = this->This()->m_sb.sbumpc();
-        #endif
-        input_library_version = static_cast<library_version_type>(v);
-    }
-    
-    #if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3205))
-    this->set_library_version(input_library_version);
-    #else
-    detail::basic_iarchive::set_library_version(input_library_version);
-    #endif
-    
-    if(BOOST_ARCHIVE_VERSION() < input_library_version)
-        boost::serialization::throw_exception(
-            archive_exception(archive_exception::unsupported_version)
-        );
-}
-
-} // namespace archive
-} // namespace boost
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/impl/basic_binary_iprimitive.ipp b/contrib/libboost/boost_1_65_0/boost/archive/impl/basic_binary_iprimitive.ipp
deleted file mode 100644
index bbe933ccf63..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/impl/basic_binary_iprimitive.ipp
+++ /dev/null
@@ -1,171 +0,0 @@
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// basic_binary_iprimitive.ipp:
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/assert.hpp>
-#include <cstddef> // size_t, NULL
-#include <cstring> // memcpy
-
-#include <boost/config.hpp>
-#if defined(BOOST_NO_STDC_NAMESPACE)
-namespace std{ 
-    using ::size_t;
-    using ::memcpy;
-} // namespace std
-#endif
-
-#include <boost/serialization/throw_exception.hpp>
-#include <boost/core/no_exceptions_support.hpp>
-#include <boost/archive/archive_exception.hpp>
-#include <boost/archive/basic_binary_iprimitive.hpp> 
-
-namespace boost {
-namespace archive {
-
-//////////////////////////////////////////////////////////////////////
-// implementation of basic_binary_iprimitive
-
-template<class Archive, class Elem, class Tr>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-basic_binary_iprimitive<Archive, Elem, Tr>::init()
-{
-    // Detect  attempts to pass native binary archives across
-    // incompatible platforms. This is not fool proof but its
-    // better than nothing.
-    unsigned char size;
-    this->This()->load(size);
-    if(sizeof(int) != size)
-        boost::serialization::throw_exception(
-            archive_exception(
-                archive_exception::incompatible_native_format,
-                "size of int"
-            )
-        );
-    this->This()->load(size);
-    if(sizeof(long) != size)
-        boost::serialization::throw_exception(
-            archive_exception(
-                archive_exception::incompatible_native_format,
-                "size of long"
-            )
-        );
-    this->This()->load(size);
-    if(sizeof(float) != size)
-        boost::serialization::throw_exception(
-            archive_exception(
-                archive_exception::incompatible_native_format,
-                "size of float"
-            )
-        );
-    this->This()->load(size);
-    if(sizeof(double) != size)
-        boost::serialization::throw_exception(
-            archive_exception(
-                archive_exception::incompatible_native_format,
-                "size of double"
-            )
-        );
-
-    // for checking endian
-    int i;
-    this->This()->load(i);
-    if(1 != i)
-        boost::serialization::throw_exception(
-            archive_exception(
-                archive_exception::incompatible_native_format,
-                "endian setting"
-            )
-        );
-}
-
-#ifndef BOOST_NO_CWCHAR
-template<class Archive, class Elem, class Tr>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-basic_binary_iprimitive<Archive, Elem, Tr>::load(wchar_t * ws)
-{
-    std::size_t l; // number of wchar_t !!!
-    this->This()->load(l);
-    load_binary(ws, l * sizeof(wchar_t) / sizeof(char));
-    ws[l] = L'\0';
-}
-#endif
-
-template<class Archive, class Elem, class Tr>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-basic_binary_iprimitive<Archive, Elem, Tr>::load(std::string & s)
-{
-    std::size_t l;
-    this->This()->load(l);
-    // borland de-allocator fixup
-    #if BOOST_WORKAROUND(_RWSTD_VER, BOOST_TESTED_AT(20101))
-    if(NULL != s.data())
-    #endif
-        s.resize(l);
-    // note breaking a rule here - could be a problem on some platform
-    if(0 < l)
-        load_binary(&(*s.begin()), l);
-}
-
-template<class Archive, class Elem, class Tr>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-basic_binary_iprimitive<Archive, Elem, Tr>::load(char * s)
-{
-    std::size_t l;
-    this->This()->load(l);
-    load_binary(s, l);
-    s[l] = '\0';
-}
-
-#ifndef BOOST_NO_STD_WSTRING
-template<class Archive, class Elem, class Tr>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-basic_binary_iprimitive<Archive, Elem, Tr>::load(std::wstring & ws)
-{
-    std::size_t l;
-    this->This()->load(l);
-    // borland de-allocator fixup
-    #if BOOST_WORKAROUND(_RWSTD_VER, BOOST_TESTED_AT(20101))
-    if(NULL != ws.data())
-    #endif
-        ws.resize(l);
-    // note breaking a rule here - is could be a problem on some platform
-    load_binary(const_cast<wchar_t *>(ws.data()), l * sizeof(wchar_t) / sizeof(char));
-}
-#endif
-
-template<class Archive, class Elem, class Tr>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL
-basic_binary_iprimitive<Archive, Elem, Tr>::basic_binary_iprimitive(
-    std::basic_streambuf<Elem, Tr> & sb, 
-    bool no_codecvt
-) :
-#ifndef BOOST_NO_STD_LOCALE
-    m_sb(sb),
-    codecvt_null_facet(1),
-    locale_saver(m_sb),
-    archive_locale(sb.getloc(), & codecvt_null_facet)
-{
-    if(! no_codecvt){
-        m_sb.pubsync();
-        m_sb.pubimbue(archive_locale);
-    }
-}
-#else
-    m_sb(sb)
-{}
-#endif
-
-// scoped_ptr requires that g be a complete type at time of
-// destruction so define destructor here rather than in the header
-template<class Archive, class Elem, class Tr>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL
-basic_binary_iprimitive<Archive, Elem, Tr>::~basic_binary_iprimitive(){}
-
-} // namespace archive
-} // namespace boost
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/impl/basic_binary_oarchive.ipp b/contrib/libboost/boost_1_65_0/boost/archive/impl/basic_binary_oarchive.ipp
deleted file mode 100644
index d5a019d32bc..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/impl/basic_binary_oarchive.ipp
+++ /dev/null
@@ -1,42 +0,0 @@
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// basic_binary_oarchive.ipp:
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-#include <string>
-#include <boost/assert.hpp>
-#include <algorithm>
-#include <cstring>
-
-#include <boost/config.hpp>
-#if defined(BOOST_NO_STDC_NAMESPACE)
-namespace std{ 
-    using ::memcpy; 
-}
-#endif
-
-#include <boost/archive/basic_binary_oarchive.hpp>
-
-namespace boost {
-namespace archive {
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// implementation of binary_binary_oarchive
-
-template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-basic_binary_oarchive<Archive>::init(){
-    // write signature in an archive version independent manner
-    const std::string file_signature(BOOST_ARCHIVE_SIGNATURE());
-    * this->This() << file_signature;
-    // write library version
-    const library_version_type v(BOOST_ARCHIVE_VERSION());
-    * this->This() << v;
-}
-
-} // namespace archive
-} // namespace boost
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/impl/basic_binary_oprimitive.ipp b/contrib/libboost/boost_1_65_0/boost/archive/impl/basic_binary_oprimitive.ipp
deleted file mode 100644
index 7b042173a48..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/impl/basic_binary_oprimitive.ipp
+++ /dev/null
@@ -1,126 +0,0 @@
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// basic_binary_oprimitive.ipp:
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <ostream>
-#include <cstddef> // NULL
-#include <cstring>
-
-#include <boost/config.hpp>
-
-#if defined(BOOST_NO_STDC_NAMESPACE) && ! defined(__LIBCOMO__)
-namespace std{ 
-    using ::strlen; 
-} // namespace std
-#endif
-
-#ifndef BOOST_NO_CWCHAR
-#include <cwchar>
-#ifdef BOOST_NO_STDC_NAMESPACE
-namespace std{ using ::wcslen; }
-#endif
-#endif
-
-#include <boost/archive/basic_binary_oprimitive.hpp>
-#include <boost/core/no_exceptions_support.hpp>
-
-namespace boost {
-namespace archive {
-
-//////////////////////////////////////////////////////////////////////
-// implementation of basic_binary_oprimitive
-
-template<class Archive, class Elem, class Tr>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-basic_binary_oprimitive<Archive, Elem, Tr>::init()
-{
-    // record native sizes of fundamental types
-    // this is to permit detection of attempts to pass
-    // native binary archives accross incompatible machines.
-    // This is not foolproof but its better than nothing.
-    this->This()->save(static_cast<unsigned char>(sizeof(int)));
-    this->This()->save(static_cast<unsigned char>(sizeof(long)));
-    this->This()->save(static_cast<unsigned char>(sizeof(float)));
-    this->This()->save(static_cast<unsigned char>(sizeof(double)));
-    // for checking endianness
-    this->This()->save(int(1));
-}
-
-template<class Archive, class Elem, class Tr>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-basic_binary_oprimitive<Archive, Elem, Tr>::save(const char * s)
-{
-    std::size_t l = std::strlen(s);
-    this->This()->save(l);
-    save_binary(s, l);
-}
-
-template<class Archive, class Elem, class Tr>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-basic_binary_oprimitive<Archive, Elem, Tr>::save(const std::string &s)
-{
-    std::size_t l = static_cast<std::size_t>(s.size());
-    this->This()->save(l);
-    save_binary(s.data(), l);
-}
-
-#ifndef BOOST_NO_CWCHAR
-#ifndef BOOST_NO_INTRINSIC_WCHAR_T
-template<class Archive, class Elem, class Tr>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-basic_binary_oprimitive<Archive, Elem, Tr>::save(const wchar_t * ws)
-{
-    std::size_t l = std::wcslen(ws);
-    this->This()->save(l);
-    save_binary(ws, l * sizeof(wchar_t) / sizeof(char));
-}
-#endif
-
-#ifndef BOOST_NO_STD_WSTRING
-template<class Archive, class Elem, class Tr>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-basic_binary_oprimitive<Archive, Elem, Tr>::save(const std::wstring &ws)
-{
-    std::size_t l = ws.size();
-    this->This()->save(l);
-    save_binary(ws.data(), l * sizeof(wchar_t) / sizeof(char));
-}
-#endif
-#endif // BOOST_NO_CWCHAR
-
-template<class Archive, class Elem, class Tr>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL
-basic_binary_oprimitive<Archive, Elem, Tr>::basic_binary_oprimitive(
-    std::basic_streambuf<Elem, Tr> & sb, 
-    bool no_codecvt
-) : 
-#ifndef BOOST_NO_STD_LOCALE
-    m_sb(sb),
-    codecvt_null_facet(1),
-    locale_saver(m_sb),
-    archive_locale(sb.getloc(), & codecvt_null_facet)
-{
-    if(! no_codecvt){
-        m_sb.pubsync();
-        m_sb.pubimbue(archive_locale);
-    }
-}
-#else
-    m_sb(sb)
-{}
-#endif
-
-// scoped_ptr requires that g be a complete type at time of
-// destruction so define destructor here rather than in the header
-template<class Archive, class Elem, class Tr>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL
-basic_binary_oprimitive<Archive, Elem, Tr>::~basic_binary_oprimitive(){}
-
-} // namespace archive
-} // namespace boost
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/impl/basic_text_iarchive.ipp b/contrib/libboost/boost_1_65_0/boost/archive/impl/basic_text_iarchive.ipp
deleted file mode 100644
index 9ec8c6588c8..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/impl/basic_text_iarchive.ipp
+++ /dev/null
@@ -1,76 +0,0 @@
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// basic_text_iarchive.ipp:
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-#include <string>
-#include <algorithm>
-#include <cstring>
-
-#include <boost/config.hpp>
-#if defined(BOOST_NO_STDC_NAMESPACE)
-namespace std{ 
-    using ::memcpy; 
-}
-#endif
-
-#include <boost/detail/workaround.hpp>
-#include <boost/serialization/string.hpp>
-#include <boost/archive/basic_text_iarchive.hpp>
-
-namespace boost {
-namespace archive {
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// implementation of text_text_archive
-
-template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-basic_text_iarchive<Archive>::load_override(class_name_type & t){
-    std::string cn;
-    cn.reserve(BOOST_SERIALIZATION_MAX_KEY_SIZE);
-    load_override(cn);
-    if(cn.size() > (BOOST_SERIALIZATION_MAX_KEY_SIZE - 1))
-        boost::serialization::throw_exception(
-            archive_exception(archive_exception::invalid_class_name)
-        );
-    std::memcpy(t, cn.data(), cn.size());
-    // borland tweak
-    t.t[cn.size()] = '\0';
-}
-
-template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-basic_text_iarchive<Archive>::init(void){
-    // read signature in an archive version independent manner
-    std::string file_signature;
-    * this->This() >> file_signature;
-    if(file_signature != BOOST_ARCHIVE_SIGNATURE())
-        boost::serialization::throw_exception(
-            archive_exception(archive_exception::invalid_signature)
-        );
-
-    // make sure the version of the reading archive library can
-    // support the format of the archive being read
-    library_version_type input_library_version;
-    * this->This() >> input_library_version;
-
-    #if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3205))
-    this->set_library_version(input_library_version);
-    #else
-    detail::basic_iarchive::set_library_version(input_library_version);
-    #endif
-
-    // extra little .t is to get around borland quirk
-    if(BOOST_ARCHIVE_VERSION() < input_library_version)
-        boost::serialization::throw_exception(
-            archive_exception(archive_exception::unsupported_version)
-        );
-}
-
-} // namespace archive
-} // namespace boost
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/impl/basic_text_iprimitive.ipp b/contrib/libboost/boost_1_65_0/boost/archive/impl/basic_text_iprimitive.ipp
deleted file mode 100644
index 4e44728068d..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/impl/basic_text_iprimitive.ipp
+++ /dev/null
@@ -1,137 +0,0 @@
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// basic_text_iprimitive.ipp:
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-
-//  See http://www.boost.org for updates, documentation, and revision history.
-
-#include <cstddef> // size_t, NULL
-#include <limits> // NULL
-
-#include <boost/config.hpp>
-#if defined(BOOST_NO_STDC_NAMESPACE)
-namespace std{ 
-    using ::size_t; 
-} // namespace std
-#endif
-
-#include <boost/serialization/throw_exception.hpp>
-
-#include <boost/archive/basic_text_iprimitive.hpp>
-
-#include <boost/archive/iterators/remove_whitespace.hpp>
-#include <boost/archive/iterators/istream_iterator.hpp>
-#include <boost/archive/iterators/binary_from_base64.hpp>
-#include <boost/archive/iterators/transform_width.hpp>
-
-namespace boost {
-namespace archive {
-
-namespace detail {
-    template<class CharType>
-    static inline bool is_whitespace(CharType c);
-
-    template<>
-    inline bool is_whitespace(char t){
-        return 0 != std::isspace(t);
-    }
-
-    #ifndef BOOST_NO_CWCHAR
-    template<>
-    inline bool is_whitespace(wchar_t t){
-        return 0 != std::iswspace(t);
-    }
-    #endif
-} // detail
-
-// translate base64 text into binary and copy into buffer
-// until buffer is full.
-template<class IStream>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-basic_text_iprimitive<IStream>::load_binary(
-    void *address, 
-    std::size_t count
-){
-    typedef typename IStream::char_type CharType;
-    
-    if(0 == count)
-        return;
-        
-    BOOST_ASSERT(
-        static_cast<std::size_t>((std::numeric_limits<std::streamsize>::max)())
-        > (count + sizeof(CharType) - 1)/sizeof(CharType)
-    );
-        
-    if(is.fail())
-        boost::serialization::throw_exception(
-            archive_exception(archive_exception::input_stream_error)
-        );
-    // convert from base64 to binary
-    typedef typename
-        iterators::transform_width<
-            iterators::binary_from_base64<
-                iterators::remove_whitespace<
-                    iterators::istream_iterator<CharType>
-                >
-                ,typename IStream::int_type
-            >
-            ,8
-            ,6
-            ,CharType
-        > 
-        binary;
-        
-    binary i = binary(iterators::istream_iterator<CharType>(is));
-
-    char * caddr = static_cast<char *>(address);
-    
-    // take care that we don't increment anymore than necessary
-    while(count-- > 0){
-        *caddr++ = static_cast<char>(*i++);
-    }
-
-    // skip over any excess input
-    for(;;){
-        typename IStream::int_type r;
-        r = is.get();
-        if(is.eof())
-            break;
-        if(detail::is_whitespace(static_cast<CharType>(r)))
-            break;
-    }
-}
-    
-template<class IStream>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL
-basic_text_iprimitive<IStream>::basic_text_iprimitive(
-    IStream  &is_,
-    bool no_codecvt
-) :
-    is(is_),
-    flags_saver(is_),
-    precision_saver(is_),
-#ifndef BOOST_NO_STD_LOCALE
-    codecvt_null_facet(1),
-    archive_locale(is.getloc(), & codecvt_null_facet),
-    locale_saver(is)
-{
-    if(! no_codecvt){
-        is_.sync();
-        is_.imbue(archive_locale);
-    }
-    is_ >> std::noboolalpha;
-}
-#else
-{}
-#endif
-
-template<class IStream>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL
-basic_text_iprimitive<IStream>::~basic_text_iprimitive(){
-}
-
-} // namespace archive
-} // namespace boost
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/impl/basic_text_oarchive.ipp b/contrib/libboost/boost_1_65_0/boost/archive/impl/basic_text_oarchive.ipp
deleted file mode 100644
index 44bc1401fd6..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/impl/basic_text_oarchive.ipp
+++ /dev/null
@@ -1,62 +0,0 @@
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// basic_text_oarchive.ipp:
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-#include <string>
-#include <boost/assert.hpp>
-#include <cstring>
-
-#include <boost/config.hpp>
-#if defined(BOOST_NO_STDC_NAMESPACE)
-namespace std{ 
-    using ::memcpy; 
-}
-#endif
-
-#include <boost/archive/basic_text_oarchive.hpp>
-
-namespace boost {
-namespace archive {
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// implementation of basic_text_oarchive
-
-template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-basic_text_oarchive<Archive>::newtoken()
-{
-    switch(delimiter){
-    default:
-        BOOST_ASSERT(false);
-        break;
-    case eol:
-        this->This()->put('\n');
-        delimiter = space;
-        break;
-    case space:
-        this->This()->put(' ');
-        break;
-    case none:
-        delimiter = space;
-        break;
-    }
-}
-
-template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-basic_text_oarchive<Archive>::init(){
-    // write signature in an archive version independent manner
-    const std::string file_signature(BOOST_ARCHIVE_SIGNATURE());
-    * this->This() << file_signature;
-    // write library version
-    const library_version_type v(BOOST_ARCHIVE_VERSION());
-    * this->This() << v;
-}
-
-} // namespace archive
-} // namespace boost
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/impl/basic_text_oprimitive.ipp b/contrib/libboost/boost_1_65_0/boost/archive/impl/basic_text_oprimitive.ipp
deleted file mode 100644
index 6030fd44c57..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/impl/basic_text_oprimitive.ipp
+++ /dev/null
@@ -1,115 +0,0 @@
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// basic_text_oprimitive.ipp:
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <cstddef> // NULL
-#include <algorithm> // std::copy
-#include <exception> // std::uncaught_exception
-#include <boost/config.hpp>
-#if defined(BOOST_NO_STDC_NAMESPACE)
-namespace std{ 
-    using ::size_t; 
-} // namespace std
-#endif
-
-#include <boost/archive/basic_text_oprimitive.hpp>
-
-#include <boost/archive/iterators/base64_from_binary.hpp>
-#include <boost/archive/iterators/insert_linebreaks.hpp>
-#include <boost/archive/iterators/transform_width.hpp>
-#include <boost/archive/iterators/ostream_iterator.hpp>
-
-namespace boost {
-namespace archive {
-
-// translate to base64 and copy in to buffer.
-template<class OStream>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-basic_text_oprimitive<OStream>::save_binary(
-    const void *address, 
-    std::size_t count
-){
-    typedef typename OStream::char_type CharType;
-    
-    if(0 == count)
-        return;
-    
-    if(os.fail())
-        boost::serialization::throw_exception(
-            archive_exception(archive_exception::output_stream_error)
-        );
-        
-    os.put('\n');
-    
-    typedef 
-        boost::archive::iterators::insert_linebreaks<
-            boost::archive::iterators::base64_from_binary<
-                boost::archive::iterators::transform_width<
-                    const char *,
-                    6,
-                    8
-                >
-            > 
-            ,76
-            ,const char // cwpro8 needs this
-        > 
-        base64_text;
-
-    boost::archive::iterators::ostream_iterator<CharType> oi(os);
-    std::copy(
-        base64_text(static_cast<const char *>(address)),
-        base64_text(
-            static_cast<const char *>(address) + count
-        ),
-        oi
-    );
-    
-    std::size_t tail = count % 3;
-    if(tail > 0){
-        *oi++ = '=';
-        if(tail < 2)
-            *oi = '=';
-    }
-}
-
-template<class OStream>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL
-basic_text_oprimitive<OStream>::basic_text_oprimitive(
-    OStream & os_,
-    bool no_codecvt
-) : 
-    os(os_),
-    flags_saver(os_),
-    precision_saver(os_),
-#ifndef BOOST_NO_STD_LOCALE
-    codecvt_null_facet(1),
-    archive_locale(os.getloc(), & codecvt_null_facet),
-    locale_saver(os)
-{
-    if(! no_codecvt){
-        os_.flush();
-        os_.imbue(archive_locale);
-    }
-    os_ << std::noboolalpha;
-}
-#else
-{}
-#endif
-
-
-template<class OStream>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL
-basic_text_oprimitive<OStream>::~basic_text_oprimitive(){
-    if(std::uncaught_exception())
-        return;
-    os << std::endl;
-}
-
-} //namespace boost 
-} //namespace archive 
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/impl/basic_xml_grammar.hpp b/contrib/libboost/boost_1_65_0/boost/archive/impl/basic_xml_grammar.hpp
deleted file mode 100644
index 6d4e4683f6a..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/impl/basic_xml_grammar.hpp
+++ /dev/null
@@ -1,173 +0,0 @@
-#ifndef BOOST_ARCHIVE_BASIC_XML_GRAMMAR_HPP
-#define BOOST_ARCHIVE_BASIC_XML_GRAMMAR_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// basic_xml_grammar.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-// this module is derived from simplexml.cpp - an example shipped as part of
-// the spirit parser.  This example contains the following notice:
-/*=============================================================================
-    simplexml.cpp
-
-    Spirit V1.3
-    URL: http://spirit.sourceforge.net/
-
-    Copyright (c) 2001, Daniel C. Nuffer
-
-    This software is provided 'as-is', without any express or implied
-    warranty. In no event will the copyright holder be held liable for
-    any damages arising from the use of this software.
-
-    Permission is granted to anyone to use this software for any purpose,
-    including commercial applications, and to alter it and redistribute
-    it freely, subject to the following restrictions:
-
-    1.  The origin of this software must not be misrepresented; you must
-        not claim that you wrote the original software. If you use this
-        software in a product, an acknowledgment in the product documentation
-        would be appreciated but is not required.
-
-    2.  Altered source versions must be plainly marked as such, and must
-        not be misrepresented as being the original software.
-
-    3.  This notice may not be removed or altered from any source
-        distribution.
-=============================================================================*/
-#include <string>
-
-#include <boost/config.hpp>
-#include <boost/detail/workaround.hpp>
-
-#include <boost/spirit/include/classic_rule.hpp>
-#include <boost/spirit/include/classic_chset.hpp>
-
-#include <boost/archive/basic_archive.hpp>
-#include <boost/serialization/tracking.hpp>
-#include <boost/serialization/version.hpp>
-
-namespace boost {
-namespace archive {
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// XML grammar parsing
-
-template<class CharType>
-class basic_xml_grammar {
-public:
-    // The following is not necessary according to DR45, but at least
-    // one compiler (Compaq C++ 6.5 in strict_ansi mode) chokes otherwise.
-    struct return_values;
-    friend struct return_values;
-    
-private:
-    typedef typename std::basic_istream<CharType> IStream;
-    typedef typename std::basic_string<CharType> StringType;
-    typedef typename boost::spirit::classic::chset<CharType> chset_t;
-    typedef typename boost::spirit::classic::chlit<CharType> chlit_t;
-    typedef typename boost::spirit::classic::scanner<
-        typename  std::basic_string<CharType>::iterator
-    > scanner_t;
-    typedef typename boost::spirit::classic::rule<scanner_t> rule_t;
-    // Start grammar definition
-    rule_t    
-        Reference,
-        Eq, 
-        STag,
-        ETag,
-        LetterOrUnderscoreOrColon,
-        AttValue, 
-        CharRef1, 
-        CharRef2, 
-        CharRef, 
-        AmpRef,
-        LTRef,
-        GTRef,
-        AposRef,
-        QuoteRef,
-        CharData,
-        CharDataChars,
-        content,
-        AmpName,
-        LTName,
-        GTName,
-        ClassNameChar,
-        ClassName,
-        Name,
-        XMLDecl,
-        XMLDeclChars,
-        DocTypeDecl,
-        DocTypeDeclChars,
-        ClassIDAttribute,
-        ObjectIDAttribute,
-        ClassNameAttribute,
-        TrackingAttribute,
-        VersionAttribute,
-        UnusedAttribute,
-        Attribute,
-        SignatureAttribute,
-        SerializationWrapper,
-        NameHead,
-        NameTail,
-        AttributeList,
-        S;
-
-    // XML Character classes
-    chset_t
-        BaseChar,
-        Ideographic,
-        Char, 
-        Letter, 
-        Digit,
-        CombiningChar,
-        Extender, 
-        Sch,
-        NameChar;
-
-    void init_chset();
-
-    bool my_parse(
-        IStream & is,
-        const rule_t &rule_, 
-        const CharType delimiter = L'>'
-    ) const ;
-public:
-    struct return_values {
-        StringType object_name;
-        StringType contents;
-        //class_id_type class_id;
-        int_least16_t class_id;
-        //object_id_type object_id;
-        uint_least32_t object_id;
-        //version_type version;
-        unsigned int version;
-        tracking_type tracking_level;
-        StringType class_name;
-        return_values() :
-            version(0),
-            tracking_level(false)
-        {}
-    } rv;
-    bool parse_start_tag(IStream & is) /*const*/;
-    bool parse_end_tag(IStream & is) const;
-    bool parse_string(IStream & is, StringType & s) /*const*/;
-    void init(IStream & is);
-    bool windup(IStream & is);
-    basic_xml_grammar();
-};
-
-} // namespace archive
-} // namespace boost
-
-#endif // BOOST_ARCHIVE_BASIC_XML_GRAMMAR_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/impl/basic_xml_iarchive.ipp b/contrib/libboost/boost_1_65_0/boost/archive/impl/basic_xml_iarchive.ipp
deleted file mode 100644
index 625458b9eb5..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/impl/basic_xml_iarchive.ipp
+++ /dev/null
@@ -1,115 +0,0 @@
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// basic_xml_iarchive.ipp:
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/assert.hpp>
-#include <cstddef> // NULL
-#include <algorithm>
-
-#include <boost/serialization/throw_exception.hpp>
-#include <boost/archive/xml_archive_exception.hpp>
-#include <boost/archive/basic_xml_iarchive.hpp>
-#include <boost/serialization/tracking.hpp>
-
-namespace boost {
-namespace archive {
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// implementation of xml_text_archive
-
-template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-basic_xml_iarchive<Archive>::load_start(const char *name){
-    // if there's no name
-    if(NULL == name)
-        return;
-    bool result = this->This()->gimpl->parse_start_tag(this->This()->get_is());
-    if(true != result){
-        boost::serialization::throw_exception(
-            archive_exception(archive_exception::input_stream_error)
-        );
-    }
-    // don't check start tag at highest level
-    ++depth;
-    return;
-}
-
-template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-basic_xml_iarchive<Archive>::load_end(const char *name){
-    // if there's no name
-    if(NULL == name)
-        return;
-    bool result = this->This()->gimpl->parse_end_tag(this->This()->get_is());
-    if(true != result){
-        boost::serialization::throw_exception(
-            archive_exception(archive_exception::input_stream_error)
-        );
-    }
-    
-    // don't check start tag at highest level
-    if(0 == --depth)
-        return;
-        
-    if(0 == (this->get_flags() & no_xml_tag_checking)){
-        // double check that the tag matches what is expected - useful for debug
-        if(0 != name[this->This()->gimpl->rv.object_name.size()]
-        || ! std::equal(
-                this->This()->gimpl->rv.object_name.begin(),
-                this->This()->gimpl->rv.object_name.end(),
-                name
-            )
-        ){
-            boost::serialization::throw_exception(
-                xml_archive_exception(
-                    xml_archive_exception::xml_archive_tag_mismatch,
-                    name
-                )
-            );
-        }
-    }
-}
-
-template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-basic_xml_iarchive<Archive>::load_override(object_id_type & t){
-    t = object_id_type(this->This()->gimpl->rv.object_id);
-}
-
-template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-basic_xml_iarchive<Archive>::load_override(version_type & t){
-    t = version_type(this->This()->gimpl->rv.version);
-}
-
-template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-basic_xml_iarchive<Archive>::load_override(class_id_type & t){
-    t = class_id_type(this->This()->gimpl->rv.class_id);
-}
-
-template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-basic_xml_iarchive<Archive>::load_override(tracking_type & t){
-    t = this->This()->gimpl->rv.tracking_level;
-}
-
-template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL
-basic_xml_iarchive<Archive>::basic_xml_iarchive(unsigned int flags) :
-    detail::common_iarchive<Archive>(flags),
-    depth(0)
-{}
-template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL
-basic_xml_iarchive<Archive>::~basic_xml_iarchive(){
-}
-
-} // namespace archive
-} // namespace boost
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/impl/basic_xml_oarchive.ipp b/contrib/libboost/boost_1_65_0/boost/archive/impl/basic_xml_oarchive.ipp
deleted file mode 100644
index 3184413f382..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/impl/basic_xml_oarchive.ipp
+++ /dev/null
@@ -1,272 +0,0 @@
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// basic_xml_oarchive.ipp:
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-
-//  See http://www.boost.org for updates, documentation, and revision history.
-
-#include <algorithm>
-#include <cstddef> // NULL
-#include <cstring>
-#if defined(BOOST_NO_STDC_NAMESPACE) && ! defined(__LIBCOMO__)
-namespace std{
-    using ::strlen;
-} // namespace std
-#endif
-
-#include <boost/archive/basic_xml_archive.hpp>
-#include <boost/archive/basic_xml_oarchive.hpp>
-#include <boost/archive/xml_archive_exception.hpp>
-#include <boost/core/no_exceptions_support.hpp>
-
-namespace boost {
-namespace archive {
-
-namespace detail {
-template<class CharType>
-struct XML_name {
-    void operator()(CharType t) const{
-        const unsigned char lookup_table[] = {
-            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,0,0,0,0,0,0,0,0,0,0,0,1,1,0, // -.
-            1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0, // 0-9
-            0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, // A-
-            1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,1, // -Z _
-            0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, // a-
-            1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0, // -z
-            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
-        };
-        if((unsigned)t > 127)
-            return;
-        if(0 == lookup_table[(unsigned)t])
-            boost::serialization::throw_exception(
-                xml_archive_exception(
-                    xml_archive_exception::xml_archive_tag_name_error
-                )
-            );
-    }
-};
-
-} // namespace detail
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// implemenations of functions common to both types of xml output
-
-template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-basic_xml_oarchive<Archive>::write_attribute(
-    const char *attribute_name,
-    int t,
-    const char *conjunction
-){
-    this->This()->put(' ');
-    this->This()->put(attribute_name);
-    this->This()->put(conjunction);
-    this->This()->save(t);
-    this->This()->put('"');
-}
-
-template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-basic_xml_oarchive<Archive>::write_attribute(
-    const char *attribute_name,
-    const char *key
-){
-    this->This()->put(' ');
-    this->This()->put(attribute_name);
-    this->This()->put("=\"");
-    this->This()->save(key);
-    this->This()->put('"');
-}
-
-template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-basic_xml_oarchive<Archive>::indent(){
-    int i;
-    for(i = depth; i-- > 0;)
-        this->This()->put('\t');
-}
-
-template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-basic_xml_oarchive<Archive>::save_start(const char *name)
-{
-    if(NULL == name)
-        return;
-
-    // be sure name has no invalid characters
-    std::for_each(name, name + std::strlen(name), detail::XML_name<const char>());
-
-    end_preamble();
-    if(depth > 0){
-        this->This()->put('\n');
-        indent();
-    }
-    ++depth;
-    this->This()->put('<');
-    this->This()->save(name);
-    pending_preamble = true;
-    indent_next = false;
-}
-
-template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-basic_xml_oarchive<Archive>::save_end(const char *name)
-{
-    if(NULL == name)
-        return;
-
-    // be sure name has no invalid characters
-    std::for_each(name, name + std::strlen(name), detail::XML_name<const char>());
-
-    end_preamble();
-    --depth;
-    if(indent_next){
-        this->This()->put('\n');
-        indent();
-    }
-    indent_next = true;
-    this->This()->put("</");
-    this->This()->save(name);
-    this->This()->put('>');
-    if(0 == depth)
-        this->This()->put('\n');
-}
-
-template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-basic_xml_oarchive<Archive>::end_preamble(){
-    if(pending_preamble){
-        this->This()->put('>');
-        pending_preamble = false;
-    }
-}
-#if 0
-template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-basic_xml_oarchive<Archive>::save_override(const object_id_type & t)
-{
-    int i = t.t; // extra .t is for borland
-    write_attribute(BOOST_ARCHIVE_XML_OBJECT_ID(), i, "=\"_");
-}
-template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-basic_xml_oarchive<Archive>::save_override(
-    const object_reference_type & t,
-    int
-){
-    int i = t.t; // extra .t is for borland
-    write_attribute(BOOST_ARCHIVE_XML_OBJECT_REFERENCE(), i, "=\"_");
-}
-template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-basic_xml_oarchive<Archive>::save_override(const version_type & t)
-{
-    int i = t.t; // extra .t is for borland
-    write_attribute(BOOST_ARCHIVE_XML_VERSION(), i);
-}
-#endif
-
-template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-basic_xml_oarchive<Archive>::save_override(const object_id_type & t)
-{
-    // borland doesn't do conversion of STRONG_TYPEDEFs very well
-    const unsigned int i = t;
-    write_attribute(BOOST_ARCHIVE_XML_OBJECT_ID(), i, "=\"_");
-}
-template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-basic_xml_oarchive<Archive>::save_override(
-    const object_reference_type & t
-){
-    const unsigned int i = t;
-    write_attribute(BOOST_ARCHIVE_XML_OBJECT_REFERENCE(), i, "=\"_");
-}
-template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-basic_xml_oarchive<Archive>::save_override(const version_type & t)
-{
-    const unsigned int i = t;
-    write_attribute(BOOST_ARCHIVE_XML_VERSION(), i);
-}
-
-template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-basic_xml_oarchive<Archive>::save_override(const class_id_type & t)
-{
-    write_attribute(BOOST_ARCHIVE_XML_CLASS_ID(), t);
-}
-template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-basic_xml_oarchive<Archive>::save_override(
-    const class_id_reference_type & t
-){
-    write_attribute(BOOST_ARCHIVE_XML_CLASS_ID_REFERENCE(), t);
-}
-template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-basic_xml_oarchive<Archive>::save_override(
-    const class_id_optional_type & t
-){
-    write_attribute(BOOST_ARCHIVE_XML_CLASS_ID(), t);
-}
-template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-basic_xml_oarchive<Archive>::save_override(const class_name_type & t)
-{
-    const char * key = t;
-    if(NULL == key)
-        return;
-    write_attribute(BOOST_ARCHIVE_XML_CLASS_NAME(), key);
-}
-
-template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-basic_xml_oarchive<Archive>::save_override(const tracking_type & t)
-{
-    write_attribute(BOOST_ARCHIVE_XML_TRACKING(), t.t);
-}
-
-template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-basic_xml_oarchive<Archive>::init(){
-    // xml header
-    this->This()->put("<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\" ?>\n");
-    this->This()->put("<!DOCTYPE boost_serialization>\n");
-    // xml document wrapper - outer root
-    this->This()->put("<boost_serialization");
-    write_attribute("signature", BOOST_ARCHIVE_SIGNATURE());
-    write_attribute("version", BOOST_ARCHIVE_VERSION());
-    this->This()->put(">\n");
-}
-
-template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-basic_xml_oarchive<Archive>::windup(){
-    // xml_trailer
-    this->This()->put("</boost_serialization>\n");
-}
-
-template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL
-basic_xml_oarchive<Archive>::basic_xml_oarchive(unsigned int flags) :
-    detail::common_oarchive<Archive>(flags),
-    depth(0),
-    pending_preamble(false),
-    indent_next(false)
-{
-}
-
-template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL
-basic_xml_oarchive<Archive>::~basic_xml_oarchive(){
-}
-
-} // namespace archive
-} // namespace boost
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/impl/text_iarchive_impl.ipp b/contrib/libboost/boost_1_65_0/boost/archive/impl/text_iarchive_impl.ipp
deleted file mode 100644
index ae4e2750ce8..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/impl/text_iarchive_impl.ipp
+++ /dev/null
@@ -1,128 +0,0 @@
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// text_iarchive_impl.ipp:
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-
-//  See http://www.boost.org for updates, documentation, and revision history.
-
-//////////////////////////////////////////////////////////////////////
-// implementation of basic_text_iprimitive overrides for the combination
-// of template parameters used to implement a text_iprimitive
-
-#include <cstddef> // size_t, NULL
-#include <boost/config.hpp>
-#if defined(BOOST_NO_STDC_NAMESPACE)
-namespace std{ 
-    using ::size_t; 
-} // namespace std
-#endif
-
-#include <boost/detail/workaround.hpp> // RogueWave
-
-#include <boost/archive/text_iarchive.hpp>
-
-namespace boost {
-namespace archive {
-
-template<class Archive>
-BOOST_ARCHIVE_DECL void
-text_iarchive_impl<Archive>::load(char *s)
-{
-    std::size_t size;
-    * this->This() >> size;
-    // skip separating space
-    is.get();
-    // Works on all tested platforms
-    is.read(s, size);
-    s[size] = '\0';
-}
-
-template<class Archive>
-BOOST_ARCHIVE_DECL void
-text_iarchive_impl<Archive>::load(std::string &s)
-{
-    std::size_t size;
-    * this->This() >> size;
-    // skip separating space
-    is.get();
-    // borland de-allocator fixup
-    #if BOOST_WORKAROUND(_RWSTD_VER, BOOST_TESTED_AT(20101))
-    if(NULL != s.data())
-    #endif
-        s.resize(size);
-    if(0 < size)
-        is.read(&(*s.begin()), size);
-}
-
-#ifndef BOOST_NO_CWCHAR
-#ifndef BOOST_NO_INTRINSIC_WCHAR_T
-template<class Archive>
-BOOST_ARCHIVE_DECL void
-text_iarchive_impl<Archive>::load(wchar_t *ws)
-{
-    std::size_t size;
-    * this->This() >> size;
-    // skip separating space
-    is.get();
-    is.read((char *)ws, size * sizeof(wchar_t)/sizeof(char));
-    ws[size] = L'\0';
-}
-#endif // BOOST_NO_INTRINSIC_WCHAR_T
-
-#ifndef BOOST_NO_STD_WSTRING
-template<class Archive>
-BOOST_ARCHIVE_DECL void
-text_iarchive_impl<Archive>::load(std::wstring &ws)
-{
-    std::size_t size;
-    * this->This() >> size;
-    // borland de-allocator fixup
-    #if BOOST_WORKAROUND(_RWSTD_VER, BOOST_TESTED_AT(20101))
-    if(NULL != ws.data())
-    #endif
-        ws.resize(size);
-    // skip separating space
-    is.get();
-    is.read((char *)ws.data(), size * sizeof(wchar_t)/sizeof(char));
-}
-
-#endif // BOOST_NO_STD_WSTRING
-#endif // BOOST_NO_CWCHAR
-
-template<class Archive>
-BOOST_ARCHIVE_DECL void
-text_iarchive_impl<Archive>::load_override(class_name_type & t){
-    basic_text_iarchive<Archive>::load_override(t);
-}
-
-template<class Archive>
-BOOST_ARCHIVE_DECL void
-text_iarchive_impl<Archive>::init(){
-    basic_text_iarchive<Archive>::init();
-}
-
-template<class Archive>
-BOOST_ARCHIVE_DECL 
-text_iarchive_impl<Archive>::text_iarchive_impl(
-    std::istream & is, 
-    unsigned int flags
-) :
-    basic_text_iprimitive<std::istream>(
-        is, 
-        0 != (flags & no_codecvt)
-    ),
-    basic_text_iarchive<Archive>(flags)
-{
-    if(0 == (flags & no_header))
-        #if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3205))
-        this->init();
-        #else
-        this->basic_text_iarchive<Archive>::init();
-        #endif
-}
-
-} // namespace archive
-} // namespace boost
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/impl/text_oarchive_impl.ipp b/contrib/libboost/boost_1_65_0/boost/archive/impl/text_oarchive_impl.ipp
deleted file mode 100644
index 37d8664a98c..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/impl/text_oarchive_impl.ipp
+++ /dev/null
@@ -1,122 +0,0 @@
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// text_oarchive_impl.ipp:
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-
-//  See http://www.boost.org for updates, documentation, and revision history.
-
-#include <string>
-#include <boost/config.hpp>
-#include <cstddef> // size_t
-
-#include <boost/config.hpp>
-#if defined(BOOST_NO_STDC_NAMESPACE)
-namespace std{ 
-    using ::size_t; 
-} // namespace std
-#endif
-
-#ifndef BOOST_NO_CWCHAR
-#include <cwchar>
-#ifdef BOOST_NO_STDC_NAMESPACE
-namespace std{ using ::wcslen; }
-#endif
-#endif
-
-#include <boost/archive/text_oarchive.hpp>
-
-namespace boost { 
-namespace archive {
-
-//////////////////////////////////////////////////////////////////////
-// implementation of basic_text_oprimitive overrides for the combination
-// of template parameters used to create a text_oprimitive
-
-template<class Archive>
-BOOST_ARCHIVE_DECL void
-text_oarchive_impl<Archive>::save(const char * s)
-{
-    const std::size_t len = std::ostream::traits_type::length(s);
-    *this->This() << len;
-    this->This()->newtoken();
-    os << s;
-}
-
-template<class Archive>
-BOOST_ARCHIVE_DECL void
-text_oarchive_impl<Archive>::save(const std::string &s)
-{
-    const std::size_t size = s.size();
-    *this->This() << size;
-    this->This()->newtoken();
-    os << s;
-}
-
-#ifndef BOOST_NO_CWCHAR
-#ifndef BOOST_NO_INTRINSIC_WCHAR_T
-template<class Archive>
-BOOST_ARCHIVE_DECL void
-text_oarchive_impl<Archive>::save(const wchar_t * ws)
-{
-    const std::size_t l = std::wcslen(ws);
-    * this->This() << l;
-    this->This()->newtoken();
-    os.write((const char *)ws, l * sizeof(wchar_t)/sizeof(char));
-}
-#endif
-
-#ifndef BOOST_NO_STD_WSTRING
-template<class Archive>
-BOOST_ARCHIVE_DECL void
-text_oarchive_impl<Archive>::save(const std::wstring &ws)
-{
-    const std::size_t l = ws.size();
-    * this->This() << l;
-    this->This()->newtoken();
-    os.write((const char *)(ws.data()), l * sizeof(wchar_t)/sizeof(char));
-}
-#endif
-#endif // BOOST_NO_CWCHAR
-
-template<class Archive>
-BOOST_ARCHIVE_DECL 
-text_oarchive_impl<Archive>::text_oarchive_impl(
-    std::ostream & os, 
-    unsigned int flags
-) :
-    basic_text_oprimitive<std::ostream>(
-        os, 
-        0 != (flags & no_codecvt)
-    ),
-    basic_text_oarchive<Archive>(flags)
-{
-    if(0 == (flags & no_header))
-        #if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3205))
-        this->init();
-        #else
-        this->basic_text_oarchive<Archive>::init();
-        #endif
-}
-
-template<class Archive>
-BOOST_ARCHIVE_DECL void
-text_oarchive_impl<Archive>::save_binary(const void *address, std::size_t count){
-    put('\n');
-    this->end_preamble();
-    #if ! defined(__MWERKS__)
-    this->basic_text_oprimitive<std::ostream>::save_binary(
-    #else
-    this->basic_text_oprimitive::save_binary(
-    #endif
-        address, 
-        count
-    );
-    this->delimiter = this->eol;
-}
-
-} // namespace archive
-} // namespace boost
-
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/impl/text_wiarchive_impl.ipp b/contrib/libboost/boost_1_65_0/boost/archive/impl/text_wiarchive_impl.ipp
deleted file mode 100644
index e85625ac326..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/impl/text_wiarchive_impl.ipp
+++ /dev/null
@@ -1,118 +0,0 @@
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// text_text_wiarchive_impl.ipp:
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-
-//  See http://www.boost.org for updates, documentation, and revision history.
-
-#include <cstddef> // size_t, NULL
-
-#include <boost/config.hpp>
-#if defined(BOOST_NO_STDC_NAMESPACE)
-namespace std{ 
-    using ::size_t; 
-} // namespace std
-#endif
-
-#include <boost/detail/workaround.hpp>  // fixup for RogueWave
-
-#ifndef BOOST_NO_STD_WSTREAMBUF
-#include <boost/archive/basic_text_iprimitive.hpp>
-
-namespace boost { 
-namespace archive {
-
-//////////////////////////////////////////////////////////////////////
-// implementation of wiprimtives functions
-//
-template<class Archive>
-BOOST_WARCHIVE_DECL void
-text_wiarchive_impl<Archive>::load(char *s)
-{
-    std::size_t size;
-    * this->This() >> size;
-    // skip separating space
-    is.get();
-    while(size-- > 0){
-        *s++ = is.narrow(is.get(), '\0');
-    }
-    *s = '\0';
-}
-
-template<class Archive>
-BOOST_WARCHIVE_DECL void
-text_wiarchive_impl<Archive>::load(std::string &s)
-{
-    std::size_t size;
-    * this->This() >> size;
-    // skip separating space
-    is.get();
-    #if BOOST_WORKAROUND(_RWSTD_VER, BOOST_TESTED_AT(20101))
-    if(NULL != s.data())
-    #endif
-        s.resize(0);
-    s.reserve(size);
-    while(size-- > 0){
-        char x = is.narrow(is.get(), '\0');
-        s += x;
-    }
-}
-
-#ifndef BOOST_NO_INTRINSIC_WCHAR_T
-template<class Archive>
-BOOST_WARCHIVE_DECL void
-text_wiarchive_impl<Archive>::load(wchar_t *s)
-{
-    std::size_t size;
-    * this->This() >> size;
-    // skip separating space
-    is.get();
-    // Works on all tested platforms
-    is.read(s, size);
-    s[size] = L'\0';
-}
-#endif
-
-#ifndef BOOST_NO_STD_WSTRING
-template<class Archive>
-BOOST_WARCHIVE_DECL void
-text_wiarchive_impl<Archive>::load(std::wstring &ws)
-{
-    std::size_t size;
-    * this->This() >> size;
-    // skip separating space
-    is.get();
-    // borland complains about resize
-    // borland de-allocator fixup
-    #if BOOST_WORKAROUND(_RWSTD_VER, BOOST_TESTED_AT(20101))
-    if(NULL != ws.data())
-    #endif
-        ws.resize(size);
-    // note breaking a rule here - is this a problem on some platform
-    is.read(const_cast<wchar_t *>(ws.data()), size);
-}
-#endif
-
-template<class Archive>
-BOOST_WARCHIVE_DECL 
-text_wiarchive_impl<Archive>::text_wiarchive_impl(
-    std::wistream & is, 
-    unsigned int flags
-) :
-    basic_text_iprimitive<std::wistream>(
-        is, 
-        0 != (flags & no_codecvt)
-    ),
-    basic_text_iarchive<Archive>(flags)
-{
-    if(0 == (flags & no_header))
-        basic_text_iarchive<Archive>::init();
-}
-
-} // archive
-} // boost
-
-#endif // BOOST_NO_STD_WSTREAMBUF
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/impl/text_woarchive_impl.ipp b/contrib/libboost/boost_1_65_0/boost/archive/impl/text_woarchive_impl.ipp
deleted file mode 100644
index 2b6d427cd3a..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/impl/text_woarchive_impl.ipp
+++ /dev/null
@@ -1,85 +0,0 @@
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// text_woarchive_impl.ipp:
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-
-//  See http://www.boost.org for updates, documentation, and revision history.
-
-#include <boost/config.hpp>
-#ifndef BOOST_NO_STD_WSTREAMBUF
-
-#include <cstring>
-#include <cstddef> // size_t
-#if defined(BOOST_NO_STDC_NAMESPACE) && ! defined(__LIBCOMO__)
-namespace std{ 
-    using ::strlen;
-    using ::size_t; 
-} // namespace std
-#endif
-
-#include <ostream>
-
-#include <boost/archive/text_woarchive.hpp>
-
-namespace boost {
-namespace archive {
-
-//////////////////////////////////////////////////////////////////////
-// implementation of woarchive functions
-//
-template<class Archive>
-BOOST_WARCHIVE_DECL void
-text_woarchive_impl<Archive>::save(const char *s)
-{
-    // note: superfluous local variable fixes borland warning
-    const std::size_t size = std::strlen(s);
-    * this->This() << size;
-    this->This()->newtoken();
-    while(*s != '\0')
-        os.put(os.widen(*s++));
-}
-
-template<class Archive>
-BOOST_WARCHIVE_DECL void
-text_woarchive_impl<Archive>::save(const std::string &s)
-{
-    const std::size_t size = s.size();
-    * this->This() << size;
-    this->This()->newtoken();
-    const char * cptr = s.data();
-    for(std::size_t i = size; i-- > 0;)
-        os.put(os.widen(*cptr++));
-}
-
-#ifndef BOOST_NO_INTRINSIC_WCHAR_T
-template<class Archive>
-BOOST_WARCHIVE_DECL void
-text_woarchive_impl<Archive>::save(const wchar_t *ws)
-{
-    const std::size_t size = std::wostream::traits_type::length(ws);
-    * this->This() << size;
-    this->This()->newtoken();
-    os.write(ws, size);
-}
-#endif
-
-#ifndef BOOST_NO_STD_WSTRING
-template<class Archive>
-BOOST_WARCHIVE_DECL void
-text_woarchive_impl<Archive>::save(const std::wstring &ws)
-{
-    const std::size_t size = ws.length();
-    * this->This() << size;
-    this->This()->newtoken();
-    os.write(ws.data(), size);
-}
-#endif
-
-} // namespace archive
-} // namespace boost
-
-#endif
-
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/impl/xml_iarchive_impl.ipp b/contrib/libboost/boost_1_65_0/boost/archive/impl/xml_iarchive_impl.ipp
deleted file mode 100644
index efc32e01632..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/impl/xml_iarchive_impl.ipp
+++ /dev/null
@@ -1,199 +0,0 @@
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// xml_iarchive_impl.cpp:
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-
-//  See http://www.boost.org for updates, documentation, and revision history.
-
-#include <boost/config.hpp>
-#include <cstring> // memcpy
-#include <cstddef> // NULL
-#include <exception>
-
-#if defined(BOOST_NO_STDC_NAMESPACE)
-namespace std{ 
-    using ::memcpy;
-} // namespace std
-#endif
-
-#ifndef BOOST_NO_CWCHAR
-#include <cwchar> // mbstate_t and mbrtowc
-#if defined(BOOST_NO_STDC_NAMESPACE)
-namespace std{ 
-    using ::mbstate_t;
-    using ::mbrtowc;
- } // namespace std
-#endif
-#endif // BOOST_NO_CWCHAR
-
-#include <boost/detail/workaround.hpp> // RogueWave and Dinkumware
-#if BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, == 1)
-#include <boost/archive/dinkumware.hpp>
-#endif
-
-#include <boost/core/no_exceptions_support.hpp>
-
-#include <boost/archive/xml_archive_exception.hpp>
-#include <boost/archive/iterators/dataflow_exception.hpp>
-#include <boost/archive/basic_xml_archive.hpp>
-#include <boost/archive/xml_iarchive.hpp>
-
-#include "basic_xml_grammar.hpp"
-
-namespace boost {
-namespace archive {
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// implemenations of functions specific to char archives
-
-// wide char stuff used by char archives
-
-#ifndef BOOST_NO_CWCHAR
-#ifndef BOOST_NO_STD_WSTRING
-template<class Archive>
-BOOST_ARCHIVE_DECL void
-xml_iarchive_impl<Archive>::load(std::wstring &ws){
-    std::string s;
-    bool result = gimpl->parse_string(is, s);
-    if(! result)
-        boost::serialization::throw_exception(
-            xml_archive_exception(xml_archive_exception::xml_archive_parsing_error)
-        );
-    
-    #if BOOST_WORKAROUND(_RWSTD_VER, BOOST_TESTED_AT(20101))
-    if(NULL != ws.data())
-    #endif
-    ws.resize(0);
-    std::mbstate_t mbs = std::mbstate_t();
-    const char * start = s.data();
-    const char * end = start + s.size();
-    while(start < end){
-        wchar_t wc;
-        std::size_t count = std::mbrtowc(&wc, start, end - start, &mbs);
-        if(count == static_cast<std::size_t>(-1))
-            boost::serialization::throw_exception(
-                iterators::dataflow_exception(
-                    iterators::dataflow_exception::invalid_conversion
-                )
-            );
-        if(count == static_cast<std::size_t>(-2))
-            continue;
-        start += count;
-        ws += wc;
-    }
-}
-#endif // BOOST_NO_STD_WSTRING
-
-#ifndef BOOST_NO_INTRINSIC_WCHAR_T
-template<class Archive>
-BOOST_ARCHIVE_DECL void
-xml_iarchive_impl<Archive>::load(wchar_t * ws){
-    std::string s;
-    bool result = gimpl->parse_string(is, s);
-    if(! result)
-        boost::serialization::throw_exception(
-            xml_archive_exception(
-                xml_archive_exception::xml_archive_parsing_error
-            )
-        );
-        
-    std::mbstate_t mbs = std::mbstate_t();
-    const char * start = s.data();
-    const char * end = start + s.size();
-    while(start < end){
-        wchar_t wc;
-        std::size_t length = std::mbrtowc(&wc, start, end - start, &mbs);
-        if(static_cast<std::size_t>(-1) == length)
-            boost::serialization::throw_exception(
-                iterators::dataflow_exception(
-                    iterators::dataflow_exception::invalid_conversion
-                )
-            );
-        if(static_cast<std::size_t>(-2) == length)
-            continue;
-
-        start += length;
-        *ws++ = wc;
-    }
-    *ws = L'\0';
-}
-#endif // BOOST_NO_INTRINSIC_WCHAR_T
-
-#endif // BOOST_NO_CWCHAR
-
-template<class Archive>
-BOOST_ARCHIVE_DECL void
-xml_iarchive_impl<Archive>::load(std::string &s){
-    bool result = gimpl->parse_string(is, s);
-    if(! result)
-        boost::serialization::throw_exception(
-            xml_archive_exception(xml_archive_exception::xml_archive_parsing_error)
-        );
-}
-
-template<class Archive>
-BOOST_ARCHIVE_DECL void
-xml_iarchive_impl<Archive>::load(char * s){
-    std::string tstring;
-    bool result = gimpl->parse_string(is, tstring);
-    if(! result)
-        boost::serialization::throw_exception(
-            xml_archive_exception(xml_archive_exception::xml_archive_parsing_error)
-        );
-    std::memcpy(s, tstring.data(), tstring.size());
-    s[tstring.size()] = 0;
-}
-
-template<class Archive>
-BOOST_ARCHIVE_DECL void
-xml_iarchive_impl<Archive>::load_override(class_name_type & t){
-    const std::string & s = gimpl->rv.class_name;
-    if(s.size() > BOOST_SERIALIZATION_MAX_KEY_SIZE - 1)
-        boost::serialization::throw_exception(
-            archive_exception(archive_exception::invalid_class_name)
-       );
-    char * tptr = t;
-    std::memcpy(tptr, s.data(), s.size());
-    tptr[s.size()] = '\0';
-}
-
-template<class Archive>
-BOOST_ARCHIVE_DECL void
-xml_iarchive_impl<Archive>::init(){
-    gimpl->init(is);
-    this->set_library_version(
-        library_version_type(gimpl->rv.version)
-    );
-}
-
-template<class Archive>
-BOOST_ARCHIVE_DECL
-xml_iarchive_impl<Archive>::xml_iarchive_impl(
-    std::istream &is_,
-    unsigned int flags
-) :
-    basic_text_iprimitive<std::istream>(
-        is_, 
-        0 != (flags & no_codecvt)
-    ),
-    basic_xml_iarchive<Archive>(flags),
-    gimpl(new xml_grammar())
-{
-    if(0 == (flags & no_header))
-        init();
-}
-
-template<class Archive>
-BOOST_ARCHIVE_DECL
-xml_iarchive_impl<Archive>::~xml_iarchive_impl(){
-    if(std::uncaught_exception())
-        return;
-    if(0 == (this->get_flags() & no_header)){
-        gimpl->windup(is);
-    }
-}
-} // namespace archive
-} // namespace boost
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/impl/xml_oarchive_impl.ipp b/contrib/libboost/boost_1_65_0/boost/archive/impl/xml_oarchive_impl.ipp
deleted file mode 100644
index 5ebd454e722..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/impl/xml_oarchive_impl.ipp
+++ /dev/null
@@ -1,142 +0,0 @@
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// xml_oarchive_impl.ipp:
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.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)
-
-#include <ostream>
-#include <iomanip>
-#include <algorithm> // std::copy
-#include <string>
-#include <exception>
-
-#include <cstring> // strlen
-#include <boost/config.hpp> // msvc 6.0 needs this to suppress warnings
-#if defined(BOOST_NO_STDC_NAMESPACE)
-namespace std{ 
-    using ::strlen; 
-} // namespace std
-#endif
-
-#include <boost/archive/iterators/xml_escape.hpp>
-#include <boost/archive/iterators/ostream_iterator.hpp>
-
-#ifndef BOOST_NO_CWCHAR
-#include <boost/archive/wcslen.hpp>
-#include <boost/archive/iterators/mb_from_wchar.hpp>
-#endif
-
-namespace boost {
-namespace archive {
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// implemenations of functions specific to char archives
-
-// wide char stuff used by char archives
-#ifndef BOOST_NO_CWCHAR
-// copy chars to output escaping to xml and translating wide chars to mb chars
-template<class InputIterator>
-void save_iterator(std::ostream &os, InputIterator begin, InputIterator end){
-    typedef boost::archive::iterators::mb_from_wchar<
-        boost::archive::iterators::xml_escape<InputIterator>
-    > translator;
-    std::copy(
-        translator(begin),
-        translator(end),
-        boost::archive::iterators::ostream_iterator<char>(os)
-    );
-}
-
-#ifndef BOOST_NO_STD_WSTRING
-template<class Archive>
-BOOST_ARCHIVE_DECL void
-xml_oarchive_impl<Archive>::save(const std::wstring & ws){
-//  at least one library doesn't typedef value_type for strings
-//  so rather than using string directly make a pointer iterator out of it
-//    save_iterator(os, ws.data(), ws.data() + std::wcslen(ws.data()));
-    save_iterator(os, ws.data(), ws.data() + ws.size());
-}
-#endif
-
-#ifndef BOOST_NO_INTRINSIC_WCHAR_T
-template<class Archive>
-BOOST_ARCHIVE_DECL void
-xml_oarchive_impl<Archive>::save(const wchar_t * ws){
-    save_iterator(os, ws, ws + std::wcslen(ws));
-}
-#endif
-
-#endif // BOOST_NO_CWCHAR
-
-template<class Archive>
-BOOST_ARCHIVE_DECL void
-xml_oarchive_impl<Archive>::save(const std::string & s){
-//  at least one library doesn't typedef value_type for strings
-//  so rather than using string directly make a pointer iterator out of it
-    typedef boost::archive::iterators::xml_escape<
-        const char * 
-    > xml_escape_translator;
-    std::copy(
-        xml_escape_translator(s.data()),
-        xml_escape_translator(s.data()+ s.size()),
-        boost::archive::iterators::ostream_iterator<char>(os)
-    );
-}
-
-template<class Archive>
-BOOST_ARCHIVE_DECL void
-xml_oarchive_impl<Archive>::save(const char * s){
-    typedef boost::archive::iterators::xml_escape<
-        const char * 
-    > xml_escape_translator;
-    std::copy(
-        xml_escape_translator(s),
-        xml_escape_translator(s + std::strlen(s)),
-        boost::archive::iterators::ostream_iterator<char>(os)
-    );
-}
-
-template<class Archive>
-BOOST_ARCHIVE_DECL
-xml_oarchive_impl<Archive>::xml_oarchive_impl(
-    std::ostream & os_, 
-    unsigned int flags
-) : 
-    basic_text_oprimitive<std::ostream>(
-        os_,
-        0 != (flags & no_codecvt)
-    ),
-    basic_xml_oarchive<Archive>(flags)
-{
-    if(0 == (flags & no_header))
-        this->init();
-}
-
-template<class Archive>
-BOOST_ARCHIVE_DECL void
-xml_oarchive_impl<Archive>::save_binary(const void *address, std::size_t count){
-    this->end_preamble();
-    #if ! defined(__MWERKS__)
-    this->basic_text_oprimitive<std::ostream>::save_binary(
-    #else
-    this->basic_text_oprimitive::save_binary(
-    #endif
-        address, 
-        count
-    );
-    this->indent_next = true;
-}
-
-template<class Archive>
-BOOST_ARCHIVE_DECL
-xml_oarchive_impl<Archive>::~xml_oarchive_impl(){
-    if(std::uncaught_exception())
-        return;
-    if(0 == (this->get_flags() & no_header))
-        this->windup();
-}
-
-} // namespace archive
-} // namespace boost
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/impl/xml_wiarchive_impl.ipp b/contrib/libboost/boost_1_65_0/boost/archive/impl/xml_wiarchive_impl.ipp
deleted file mode 100644
index ee66c1263e6..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/impl/xml_wiarchive_impl.ipp
+++ /dev/null
@@ -1,189 +0,0 @@
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// xml_wiarchive_impl.ipp:
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-
-//  See http://www.boost.org for updates, documentation, and revision history.
-
-#include <cstring>
-#if defined(BOOST_NO_STDC_NAMESPACE)
-namespace std{ 
-    using ::memcpy; 
-} //std
-#endif
-
-#include <boost/config.hpp> // msvc 6.0 needs this to suppress warnings
-#ifndef BOOST_NO_STD_WSTREAMBUF
-
-#include <boost/assert.hpp>
-#include <algorithm> // std::copy
-#include <exception> // uncaught exception
-#include <boost/detail/workaround.hpp> // Dinkumware and RogueWave
-#if BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, == 1)
-#include <boost/archive/dinkumware.hpp>
-#endif
-
-#include <boost/io/ios_state.hpp>
-#include <boost/core/no_exceptions_support.hpp>
-#include <boost/serialization/string.hpp>
-
-#include <boost/archive/basic_xml_archive.hpp>
-#include <boost/archive/xml_wiarchive.hpp>
-
-#include <boost/archive/xml_archive_exception.hpp>
-#include <boost/archive/iterators/mb_from_wchar.hpp>
-
-#include <boost/archive/detail/utf8_codecvt_facet.hpp>
-
-#include "basic_xml_grammar.hpp"
-
-namespace boost {
-namespace archive {
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// implemenations of functions specific to wide char archives
-
-namespace { // anonymous
-
-void copy_to_ptr(char * s, const std::wstring & ws){
-    std::copy(
-        iterators::mb_from_wchar<std::wstring::const_iterator>(
-            ws.begin()
-        ), 
-        iterators::mb_from_wchar<std::wstring::const_iterator>(
-            ws.end()
-        ), 
-        s
-    );
-    s[ws.size()] = 0;
-}
-
-} // anonymous
-
-template<class Archive>
-BOOST_WARCHIVE_DECL void
-xml_wiarchive_impl<Archive>::load(std::string & s){
-    std::wstring ws;
-    bool result = gimpl->parse_string(is, ws);
-    if(! result)
-        boost::serialization::throw_exception(
-            xml_archive_exception(xml_archive_exception::xml_archive_parsing_error)
-        );
-    #if BOOST_WORKAROUND(_RWSTD_VER, BOOST_TESTED_AT(20101))
-    if(NULL != s.data())
-    #endif
-        s.resize(0);
-    s.reserve(ws.size());
-    std::copy(
-        iterators::mb_from_wchar<std::wstring::iterator>(
-            ws.begin()
-        ), 
-        iterators::mb_from_wchar<std::wstring::iterator>(
-            ws.end()
-        ), 
-        std::back_inserter(s)
-    );
-}
-
-#ifndef BOOST_NO_STD_WSTRING
-template<class Archive>
-BOOST_WARCHIVE_DECL void
-xml_wiarchive_impl<Archive>::load(std::wstring & ws){
-    bool result = gimpl->parse_string(is, ws);
-    if(! result)
-        boost::serialization::throw_exception(
-            xml_archive_exception(xml_archive_exception::xml_archive_parsing_error)
-        );
-}
-#endif
-
-template<class Archive>
-BOOST_WARCHIVE_DECL void
-xml_wiarchive_impl<Archive>::load(char * s){
-    std::wstring ws;
-    bool result = gimpl->parse_string(is, ws);
-    if(! result)
-        boost::serialization::throw_exception(
-            xml_archive_exception(xml_archive_exception::xml_archive_parsing_error)
-        );
-    copy_to_ptr(s, ws);
-}
-
-#ifndef BOOST_NO_INTRINSIC_WCHAR_T
-template<class Archive>
-BOOST_WARCHIVE_DECL void
-xml_wiarchive_impl<Archive>::load(wchar_t * ws){
-    std::wstring twstring;
-    bool result = gimpl->parse_string(is, twstring);
-    if(! result)
-        boost::serialization::throw_exception(
-            xml_archive_exception(xml_archive_exception::xml_archive_parsing_error)
-        );
-    std::memcpy(ws, twstring.c_str(), twstring.size());
-    ws[twstring.size()] = L'\0';
-}
-#endif
-
-template<class Archive>
-BOOST_WARCHIVE_DECL void
-xml_wiarchive_impl<Archive>::load_override(class_name_type & t){
-    const std::wstring & ws = gimpl->rv.class_name;
-    if(ws.size() > BOOST_SERIALIZATION_MAX_KEY_SIZE - 1)
-        boost::serialization::throw_exception(
-            archive_exception(archive_exception::invalid_class_name)
-        );
-    copy_to_ptr(t, ws);
-}
-
-template<class Archive>
-BOOST_WARCHIVE_DECL void
-xml_wiarchive_impl<Archive>::init(){
-    gimpl->init(is);
-    this->set_library_version(
-        library_version_type(gimpl->rv.version)
-    );
-}
-
-template<class Archive>
-BOOST_WARCHIVE_DECL
-xml_wiarchive_impl<Archive>::xml_wiarchive_impl(
-    std::wistream &is_,
-    unsigned int flags
-) :
-    basic_text_iprimitive<std::wistream>(
-        is_, 
-        true // don't change the codecvt - use the one below
-    ),
-    basic_xml_iarchive<Archive>(flags),
-    gimpl(new xml_wgrammar())
-{
-    if(0 == (flags & no_codecvt)){
-        std::locale l = std::locale(
-            is_.getloc(),
-            new boost::archive::detail::utf8_codecvt_facet
-        );
-        // libstdc++ crashes without this
-        is_.sync();
-        is_.imbue(l);
-    }
-    if(0 == (flags & no_header))
-        init();
-}
-
-template<class Archive>
-BOOST_WARCHIVE_DECL
-xml_wiarchive_impl<Archive>::~xml_wiarchive_impl(){
-    if(std::uncaught_exception())
-        return;
-    if(0 == (this->get_flags() & no_header)){
-        gimpl->windup(is);
-    }
-}
-
-} // namespace archive
-} // namespace boost
-
-#endif  // BOOST_NO_STD_WSTREAMBUF
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/impl/xml_woarchive_impl.ipp b/contrib/libboost/boost_1_65_0/boost/archive/impl/xml_woarchive_impl.ipp
deleted file mode 100644
index 01b1a052d51..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/impl/xml_woarchive_impl.ipp
+++ /dev/null
@@ -1,171 +0,0 @@
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// xml_woarchive_impl.ipp:
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.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)
-
-#include <boost/config.hpp>
-#ifndef BOOST_NO_STD_WSTREAMBUF
-
-#include <ostream>
-#include <string>
-#include <algorithm> // std::copy
-#include <locale>
-#include <exception>
-
-#include <cstring> // strlen
-#include <cstdlib> // mbtowc
-#ifndef BOOST_NO_CWCHAR
-#include <cwchar>  // wcslen
-#endif
-
-#include <boost/config.hpp>
-#if defined(BOOST_NO_STDC_NAMESPACE)
-namespace std{ 
-    using ::strlen; 
-    #if ! defined(BOOST_NO_INTRINSIC_WCHAR_T)
-        using ::mbtowc; 
-        using ::wcslen;
-    #endif
-} // namespace std
-#endif
-
-#include <boost/archive/xml_woarchive.hpp>
-#include <boost/archive/detail/utf8_codecvt_facet.hpp>
-
-#include <boost/serialization/throw_exception.hpp>
-
-#include <boost/archive/iterators/xml_escape.hpp>
-#include <boost/archive/iterators/wchar_from_mb.hpp>
-#include <boost/archive/iterators/ostream_iterator.hpp>
-#include <boost/archive/iterators/dataflow_exception.hpp>
-
-namespace boost {
-namespace archive {
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// implemenations of functions specific to wide char archives
-
-// copy chars to output escaping to xml and widening characters as we go
-template<class InputIterator>
-void save_iterator(std::wostream &os, InputIterator begin, InputIterator end){
-    typedef iterators::wchar_from_mb<
-        iterators::xml_escape<InputIterator>
-    > xmbtows;
-    std::copy(
-        xmbtows(begin),
-        xmbtows(end),
-        boost::archive::iterators::ostream_iterator<wchar_t>(os)
-    );
-}
-
-template<class Archive>
-BOOST_WARCHIVE_DECL void
-xml_woarchive_impl<Archive>::save(const std::string & s){
-    // note: we don't use s.begin() and s.end() because dinkumware
-    // doesn't have string::value_type defined. So use a wrapper
-    // around these values to implement the definitions.
-    const char * begin = s.data();
-    const char * end = begin + s.size();
-    save_iterator(os, begin, end);
-}
-
-#ifndef BOOST_NO_STD_WSTRING
-template<class Archive>
-BOOST_WARCHIVE_DECL void
-xml_woarchive_impl<Archive>::save(const std::wstring & ws){
-#if 0
-    typedef iterators::xml_escape<std::wstring::const_iterator> xmbtows;
-    std::copy(
-        xmbtows(ws.begin()),
-        xmbtows(ws.end()),
-        boost::archive::iterators::ostream_iterator<wchar_t>(os)
-    );
-#endif
-    typedef iterators::xml_escape<const wchar_t *> xmbtows;
-    std::copy(
-        xmbtows(ws.data()),
-        xmbtows(ws.data() + ws.size()),
-        boost::archive::iterators::ostream_iterator<wchar_t>(os)
-    );
-}
-#endif //BOOST_NO_STD_WSTRING
-
-template<class Archive>
-BOOST_WARCHIVE_DECL void
-xml_woarchive_impl<Archive>::save(const char * s){
-   save_iterator(os, s, s + std::strlen(s));
-}
-
-#ifndef BOOST_NO_INTRINSIC_WCHAR_T
-template<class Archive>
-BOOST_WARCHIVE_DECL void
-xml_woarchive_impl<Archive>::save(const wchar_t * ws){
-    os << ws;
-    typedef iterators::xml_escape<const wchar_t *> xmbtows;
-    std::copy(
-        xmbtows(ws),
-        xmbtows(ws + std::wcslen(ws)),
-        boost::archive::iterators::ostream_iterator<wchar_t>(os)
-    );
-}
-#endif
-
-template<class Archive>
-BOOST_WARCHIVE_DECL
-xml_woarchive_impl<Archive>::xml_woarchive_impl(
-    std::wostream & os_,
-    unsigned int flags
-) :
-    basic_text_oprimitive<std::wostream>(
-        os_,
-        true // don't change the codecvt - use the one below
-    ),
-    basic_xml_oarchive<Archive>(flags)
-{
-    if(0 == (flags & no_codecvt)){
-        std::locale l = std::locale(
-            os_.getloc(),
-            new boost::archive::detail::utf8_codecvt_facet
-        );
-        os_.flush();
-        os_.imbue(l);
-    }
-    if(0 == (flags & no_header))
-        this->init();
-}
-
-template<class Archive>
-BOOST_WARCHIVE_DECL
-xml_woarchive_impl<Archive>::~xml_woarchive_impl(){
-    if(std::uncaught_exception())
-        return;
-    if(0 == (this->get_flags() & no_header)){
-        save(L"</boost_serialization>\n");
-    }
-}
-
-template<class Archive>
-BOOST_WARCHIVE_DECL void
-xml_woarchive_impl<Archive>::save_binary(
-    const void *address,
-    std::size_t count
-){
-    this->end_preamble();
-    #if ! defined(__MWERKS__)
-    this->basic_text_oprimitive<std::wostream>::save_binary(
-    #else
-    this->basic_text_oprimitive::save_binary(
-    #endif
-        address, 
-        count
-    );
-    this->indent_next = true;
-}
-
-} // namespace archive
-} // namespace boost
-
-#endif //BOOST_NO_STD_WSTREAMBUF
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/iterators/base64_exception.hpp b/contrib/libboost/boost_1_65_0/boost/archive/iterators/base64_exception.hpp
deleted file mode 100644
index 8f9208b60ea..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/iterators/base64_exception.hpp
+++ /dev/null
@@ -1,68 +0,0 @@
-#ifndef BOOST_ARCHIVE_ITERATORS_BASE64_EXCEPTION_HPP
-#define BOOST_ARCHIVE_ITERATORS_BASE64_EXCEPTION_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// base64_exception.hpp:
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/config.hpp>
-#ifndef BOOST_NO_EXCEPTIONS
-#include <exception>
-
-#include <boost/assert.hpp>
-
-namespace boost {
-namespace archive {
-namespace iterators {
-
-//////////////////////////////////////////////////////////////////////
-// exceptions thrown by base64s
-//
-class base64_exception : public std::exception
-{
-public:
-    typedef enum {
-        invalid_code,       // attempt to encode a value > 6 bits
-        invalid_character,  // decode a value not in base64 char set
-        other_exception
-    } exception_code;
-    exception_code code;
-
-    base64_exception(exception_code c = other_exception) : code(c)
-    {}
-
-    virtual const char *what( ) const throw( )
-    {
-        const char *msg = "unknown exception code";
-        switch(code){
-        case invalid_code:
-            msg = "attempt to encode a value > 6 bits";
-            break;
-        case invalid_character:
-            msg = "attempt to decode a value not in base64 char set";
-            break;
-        default:
-            BOOST_ASSERT(false);
-            break;
-        }
-        return msg;
-    }
-};
-
-} // namespace iterators
-} // namespace archive
-} // namespace boost
-
-#endif //BOOST_NO_EXCEPTIONS
-#endif //BOOST_ARCHIVE_ITERATORS_ARCHIVE_EXCEPTION_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/iterators/base64_from_binary.hpp b/contrib/libboost/boost_1_65_0/boost/archive/iterators/base64_from_binary.hpp
deleted file mode 100644
index ee849944397..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/iterators/base64_from_binary.hpp
+++ /dev/null
@@ -1,109 +0,0 @@
-#ifndef BOOST_ARCHIVE_ITERATORS_BASE64_FROM_BINARY_HPP
-#define BOOST_ARCHIVE_ITERATORS_BASE64_FROM_BINARY_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// base64_from_binary.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/assert.hpp>
-
-#include <cstddef> // size_t
-#if defined(BOOST_NO_STDC_NAMESPACE)
-namespace std{ 
-    using ::size_t; 
-} // namespace std
-#endif
-
-#include <boost/iterator/transform_iterator.hpp>
-#include <boost/archive/iterators/dataflow_exception.hpp>
-
-namespace boost { 
-namespace archive {
-namespace iterators {
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// convert binary integers to base64 characters
-
-namespace detail {
-
-template<class CharType>
-struct from_6_bit {
-    typedef CharType result_type;
-    CharType operator()(CharType t) const{
-        static const char * lookup_table =
-            "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
-            "abcdefghijklmnopqrstuvwxyz"
-            "0123456789"
-            "+/";
-        BOOST_ASSERT(t < 64);
-        return lookup_table[static_cast<size_t>(t)];
-    }
-};
-
-} // namespace detail
-
-// note: what we would like to do is
-// template<class Base, class CharType = typename Base::value_type>
-//  typedef transform_iterator<
-//      from_6_bit<CharType>,
-//      transform_width<Base, 6, sizeof(Base::value_type) * 8, CharType>
-//  > base64_from_binary;
-// but C++ won't accept this.  Rather than using a "type generator" and
-// using a different syntax, make a derivation which should be equivalent.
-//
-// Another issue addressed here is that the transform_iterator doesn't have
-// a templated constructor.  This makes it incompatible with the dataflow
-// ideal.  This is also addressed here.
-
-//template<class Base, class CharType = typename Base::value_type>
-template<
-    class Base, 
-    class CharType = typename boost::iterator_value<Base>::type
->
-class base64_from_binary : 
-    public transform_iterator<
-        detail::from_6_bit<CharType>,
-        Base
-    >
-{
-    friend class boost::iterator_core_access;
-    typedef transform_iterator<
-        typename detail::from_6_bit<CharType>,
-        Base
-    > super_t;
-
-public:
-    // make composible buy using templated constructor
-    template<class T>
-    base64_from_binary(T start) :
-        super_t(
-            Base(static_cast< T >(start)),
-            detail::from_6_bit<CharType>()
-        )
-    {}
-    // intel 7.1 doesn't like default copy constructor
-    base64_from_binary(const base64_from_binary & rhs) : 
-        super_t(
-            Base(rhs.base_reference()),
-            detail::from_6_bit<CharType>()
-        )
-    {}
-//    base64_from_binary(){};
-};
-
-} // namespace iterators
-} // namespace archive
-} // namespace boost
-
-#endif // BOOST_ARCHIVE_ITERATORS_BASE64_FROM_BINARY_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/iterators/binary_from_base64.hpp b/contrib/libboost/boost_1_65_0/boost/archive/iterators/binary_from_base64.hpp
deleted file mode 100644
index 89b8f889da3..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/iterators/binary_from_base64.hpp
+++ /dev/null
@@ -1,118 +0,0 @@
-#ifndef BOOST_ARCHIVE_ITERATORS_BINARY_FROM_BASE64_HPP
-#define BOOST_ARCHIVE_ITERATORS_BINARY_FROM_BASE64_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// binary_from_base64.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/assert.hpp>
-
-#include <boost/serialization/throw_exception.hpp>
-#include <boost/static_assert.hpp>
-
-#include <boost/iterator/transform_iterator.hpp>
-#include <boost/archive/iterators/dataflow_exception.hpp>
-
-namespace boost { 
-namespace archive {
-namespace iterators {
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// convert base64 characters to binary data
-
-namespace detail {
-
-template<class CharType>
-struct to_6_bit {
-    typedef CharType result_type;
-    CharType operator()(CharType t) const{
-        static const signed char lookup_table[] = {
-            -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
-            -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
-            -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,62,-1,-1,-1,63,
-            52,53,54,55,56,57,58,59,60,61,-1,-1,-1, 0,-1,-1, // render '=' as 0
-            -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,
-            15,16,17,18,19,20,21,22,23,24,25,-1,-1,-1,-1,-1,
-            -1,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,
-            41,42,43,44,45,46,47,48,49,50,51,-1,-1,-1,-1,-1
-        };
-        // metrowerks trips this assertion - how come?
-        #if ! defined(__MWERKS__)
-        BOOST_STATIC_ASSERT(128 == sizeof(lookup_table));
-        #endif
-        signed char value = -1;
-        if((unsigned)t <= 127)
-            value = lookup_table[(unsigned)t];
-        if(-1 == value)
-            boost::serialization::throw_exception(
-                dataflow_exception(dataflow_exception::invalid_base64_character)
-            );
-        return value;
-    }
-};
-
-} // namespace detail
-
-// note: what we would like to do is
-// template<class Base, class CharType = typename Base::value_type>
-//  typedef transform_iterator<
-//      from_6_bit<CharType>,
-//      transform_width<Base, 6, sizeof(Base::value_type) * 8, CharType>
-//  > base64_from_binary;
-// but C++ won't accept this.  Rather than using a "type generator" and
-// using a different syntax, make a derivation which should be equivalent.
-//
-// Another issue addressed here is that the transform_iterator doesn't have
-// a templated constructor.  This makes it incompatible with the dataflow
-// ideal.  This is also addressed here.
-
-template<
-    class Base, 
-    class CharType = typename boost::iterator_value<Base>::type
->
-class binary_from_base64 : public
-    transform_iterator<
-        detail::to_6_bit<CharType>,
-        Base
-    >
-{
-    friend class boost::iterator_core_access;
-    typedef transform_iterator<
-        detail::to_6_bit<CharType>,
-        Base
-    > super_t;
-public:
-    // make composible buy using templated constructor
-    template<class T>
-    binary_from_base64(T  start) :
-        super_t(
-            Base(static_cast< T >(start)),
-            detail::to_6_bit<CharType>()
-        )
-    {}
-    // intel 7.1 doesn't like default copy constructor
-    binary_from_base64(const binary_from_base64 & rhs) : 
-        super_t(
-            Base(rhs.base_reference()),
-            detail::to_6_bit<CharType>()
-        )
-    {}
-//    binary_from_base64(){};
-};
-
-} // namespace iterators
-} // namespace archive
-} // namespace boost
-
-#endif // BOOST_ARCHIVE_ITERATORS_BINARY_FROM_BASE64_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/iterators/dataflow.hpp b/contrib/libboost/boost_1_65_0/boost/archive/iterators/dataflow.hpp
deleted file mode 100644
index 07733d5fd62..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/iterators/dataflow.hpp
+++ /dev/null
@@ -1,102 +0,0 @@
-#ifndef BOOST_ARCHIVE_ITERATORS_DATAFLOW_HPP
-#define BOOST_ARCHIVE_ITERATORS_DATAFLOW_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// dataflow.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/assert.hpp>
-
-#include <boost/mpl/eval_if.hpp>
-#include <boost/mpl/if.hpp>
-#include <boost/mpl/apply.hpp>
-#include <boost/mpl/plus.hpp>
-#include <boost/mpl/int.hpp>
-
-#include <boost/type_traits/is_convertible.hpp>
-#include <boost/type_traits/is_base_and_derived.hpp>
-#include <boost/type_traits/is_pointer.hpp>
-#include <boost/iterator/iterator_adaptor.hpp>
-#include <boost/iterator/iterator_traits.hpp>
-#include <boost/static_assert.hpp>
-
-namespace boost { 
-namespace archive {
-namespace iterators {
-
-// poor man's tri-state
-struct tri_state {
-    enum state_enum {
-        is_false = false,
-        is_true = true,
-        is_indeterminant
-    } m_state;
-    // convert to bool
-    operator bool (){
-        BOOST_ASSERT(is_indeterminant != m_state);
-        return is_true == m_state ? true : false;
-    }
-    // assign from bool
-    tri_state & operator=(bool rhs) {
-        m_state = rhs ? is_true : is_false;
-        return *this;
-    }
-    tri_state(bool rhs) :
-        m_state(rhs ? is_true : is_false)
-    {}
-    tri_state(state_enum state) :
-        m_state(state)
-    {}
-    bool operator==(const tri_state & rhs) const {
-        return m_state == rhs.m_state;
-    }
-    bool operator!=(const tri_state & rhs) const {
-        return m_state != rhs.m_state;
-    }
-};
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// implement functions common to dataflow iterators
-template<class Derived>
-class dataflow {
-    bool m_eoi;
-protected:
-    // test for iterator equality
-    tri_state equal(const Derived & rhs) const {
-        if(m_eoi && rhs.m_eoi)
-            return true;
-        if(m_eoi || rhs.m_eoi)
-            return false;
-        return tri_state(tri_state::is_indeterminant);
-    }
-    void eoi(bool tf){
-        m_eoi = tf;
-    }
-    bool eoi() const {
-        return m_eoi;
-    }
-public:
-    dataflow(bool tf) :
-        m_eoi(tf)
-    {}
-    dataflow() : // used for iterator end
-        m_eoi(true)
-    {}
-};
-
-} // namespace iterators
-} // namespace archive
-} // namespace boost
-
-#endif // BOOST_ARCHIVE_ITERATORS_DATAFLOW_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/iterators/dataflow_exception.hpp b/contrib/libboost/boost_1_65_0/boost/archive/iterators/dataflow_exception.hpp
deleted file mode 100644
index e3e18605b38..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/iterators/dataflow_exception.hpp
+++ /dev/null
@@ -1,80 +0,0 @@
-#ifndef BOOST_ARCHIVE_ITERATORS_DATAFLOW_EXCEPTION_HPP
-#define BOOST_ARCHIVE_ITERATORS_DATAFLOW_EXCEPTION_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// dataflow_exception.hpp:
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/config.hpp>
-#ifndef BOOST_NO_EXCEPTIONS
-#include <exception>
-#endif //BOOST_NO_EXCEPTIONS
-
-#include <boost/assert.hpp>
-
-namespace boost {
-namespace archive {
-namespace iterators {
-
-//////////////////////////////////////////////////////////////////////
-// exceptions thrown by dataflows
-//
-class dataflow_exception : public std::exception
-{
-public:
-    typedef enum {
-        invalid_6_bitcode,
-        invalid_base64_character,
-        invalid_xml_escape_sequence,
-        comparison_not_permitted,
-        invalid_conversion,
-        other_exception
-    } exception_code;
-    exception_code code;
-
-    dataflow_exception(exception_code c = other_exception) : code(c)
-    {}
-
-    virtual const char *what( ) const throw( )
-    {
-        const char *msg = "unknown exception code";
-        switch(code){
-        case invalid_6_bitcode:
-            msg = "attempt to encode a value > 6 bits";
-            break;
-        case invalid_base64_character:
-            msg = "attempt to decode a value not in base64 char set";
-            break;
-        case invalid_xml_escape_sequence:
-            msg = "invalid xml escape_sequence";
-            break;
-        case comparison_not_permitted:
-            msg = "cannot invoke iterator comparison now";
-            break;
-        case invalid_conversion:
-            msg = "invalid multbyte/wide char conversion";
-            break;
-        default:
-            BOOST_ASSERT(false);
-            break;
-        }
-        return msg;
-    }
-};
-
-} // namespace iterators
-} // namespace archive
-} // namespace boost
-
-#endif //BOOST_ARCHIVE_ITERATORS_DATAFLOW_EXCEPTION_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/iterators/escape.hpp b/contrib/libboost/boost_1_65_0/boost/archive/iterators/escape.hpp
deleted file mode 100644
index 103b31e0fef..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/iterators/escape.hpp
+++ /dev/null
@@ -1,115 +0,0 @@
-#ifndef BOOST_ARCHIVE_ITERATORS_ESCAPE_HPP
-#define BOOST_ARCHIVE_ITERATORS_ESCAPE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// escape.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/assert.hpp>
-#include <cstddef> // NULL
-
-#include <boost/iterator/iterator_adaptor.hpp>
-#include <boost/iterator/iterator_traits.hpp>
-
-namespace boost { 
-namespace archive {
-namespace iterators {
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// insert escapes into text
-
-template<class Derived, class Base>
-class escape : 
-    public boost::iterator_adaptor<
-        Derived, 
-        Base, 
-        typename boost::iterator_value<Base>::type,
-        single_pass_traversal_tag,
-        typename boost::iterator_value<Base>::type
-    >
-{
-    typedef typename boost::iterator_value<Base>::type base_value_type;
-    typedef typename boost::iterator_reference<Base>::type reference_type;
-    friend class boost::iterator_core_access;
-
-    typedef typename boost::iterator_adaptor<
-        Derived, 
-        Base, 
-        base_value_type,
-        single_pass_traversal_tag,
-        base_value_type
-    > super_t;
-
-    typedef escape<Derived, Base> this_t;
-
-    void dereference_impl() {
-        m_current_value = static_cast<Derived *>(this)->fill(m_bnext, m_bend);
-        m_full = true;
-    }
-
-    //Access the value referred to 
-    reference_type dereference() const {
-        if(!m_full)
-            const_cast<this_t *>(this)->dereference_impl();
-        return m_current_value;
-    }
-
-    bool equal(const this_t & rhs) const {
-        if(m_full){
-            if(! rhs.m_full)
-                const_cast<this_t *>(& rhs)->dereference_impl();
-        }
-        else{
-            if(rhs.m_full)
-                const_cast<this_t *>(this)->dereference_impl();
-        }
-        if(m_bnext != rhs.m_bnext)
-            return false;
-        if(this->base_reference() != rhs.base_reference())
-            return false;
-        return true;
-    }
-
-   void increment(){
-        if(++m_bnext < m_bend){
-            m_current_value = *m_bnext;
-            return;
-        }
-        ++(this->base_reference());
-        m_bnext = NULL;
-        m_bend = NULL;
-        m_full = false;
-    }
-
-    // buffer to handle pending characters
-    const base_value_type *m_bnext;
-    const base_value_type *m_bend;
-    bool m_full;
-    base_value_type m_current_value;
-public:
-    escape(Base base) : 
-        super_t(base),
-        m_bnext(NULL),
-        m_bend(NULL),
-        m_full(false),
-        m_current_value(0)
-    {
-    }
-};
-
-} // namespace iterators
-} // namespace archive
-} // namespace boost
-
-#endif // BOOST_ARCHIVE_ITERATORS_ESCAPE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/iterators/insert_linebreaks.hpp b/contrib/libboost/boost_1_65_0/boost/archive/iterators/insert_linebreaks.hpp
deleted file mode 100644
index 2504b030db1..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/iterators/insert_linebreaks.hpp
+++ /dev/null
@@ -1,99 +0,0 @@
-#ifndef BOOST_ARCHIVE_ITERATORS_INSERT_LINEBREAKS_HPP
-#define BOOST_ARCHIVE_ITERATORS_INSERT_LINEBREAKS_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// insert_linebreaks.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/assert.hpp>
-
-#include <boost/config.hpp>
-#if defined(BOOST_NO_STDC_NAMESPACE)
-namespace std{ using ::memcpy; }
-#endif
-
-#include <boost/iterator/iterator_adaptor.hpp>
-#include <boost/iterator/iterator_traits.hpp>
-
-namespace boost { 
-namespace archive {
-namespace iterators {
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// insert line break every N characters
-template<
-    class Base, 
-    int N, 
-    class CharType = typename boost::iterator_value<Base>::type
->
-class insert_linebreaks : 
-    public iterator_adaptor<
-        insert_linebreaks<Base, N, CharType>,
-        Base,
-        CharType,
-        single_pass_traversal_tag,
-        CharType
-    >
-{
-private:
-    friend class boost::iterator_core_access;
-    typedef iterator_adaptor<
-        insert_linebreaks<Base, N, CharType>,
-        Base,
-        CharType,
-        single_pass_traversal_tag,
-        CharType
-    > super_t;
-
-    bool equal(const insert_linebreaks<Base, N, CharType> & rhs) const {
-        return
-//            m_count == rhs.m_count
-//            && base_reference() == rhs.base_reference()
-            this->base_reference() == rhs.base_reference()
-        ;
-    }
-
-    void increment() {
-        if(m_count == N){
-            m_count = 0;
-            return;
-        }
-        ++m_count;
-        ++(this->base_reference());
-    }
-    CharType dereference() const {
-        if(m_count == N)
-            return '\n';
-        return * (this->base_reference());
-    }
-    unsigned int m_count;
-public:
-    // make composible buy using templated constructor
-    template<class T>
-    insert_linebreaks(T  start) :
-        super_t(Base(static_cast< T >(start))),
-        m_count(0)
-    {}
-    // intel 7.1 doesn't like default copy constructor
-    insert_linebreaks(const insert_linebreaks & rhs) : 
-        super_t(rhs.base_reference()),
-        m_count(rhs.m_count)
-    {}
-};
-
-} // namespace iterators
-} // namespace archive
-} // namespace boost
-
-#endif // BOOST_ARCHIVE_ITERATORS_INSERT_LINEBREAKS_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/iterators/istream_iterator.hpp b/contrib/libboost/boost_1_65_0/boost/archive/iterators/istream_iterator.hpp
deleted file mode 100644
index a187f605e69..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/iterators/istream_iterator.hpp
+++ /dev/null
@@ -1,92 +0,0 @@
-#ifndef BOOST_ARCHIVE_ITERATORS_ISTREAM_ITERATOR_HPP
-#define BOOST_ARCHIVE_ITERATORS_ISTREAM_ITERATOR_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// istream_iterator.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-// note: this is a custom version of the standard istream_iterator.
-// This is necessary as the standard version doesn't work as expected
-// for wchar_t based streams on systems for which wchar_t not a true
-// type but rather a synonym for some integer type.
-
-#include <cstddef> // NULL
-#include <istream>
-#include <boost/iterator/iterator_facade.hpp>
-
-namespace boost { 
-namespace archive {
-namespace iterators {
-
-// given a type, make an input iterator based on a pointer to that type
-template<class Elem = char>
-class istream_iterator :  
-    public boost::iterator_facade<
-        istream_iterator<Elem>,
-        Elem,
-        std::input_iterator_tag,
-        Elem
-    >
-{
-    friend class boost::iterator_core_access;
-    typedef istream_iterator this_t ;
-    typedef typename boost::iterator_facade<
-        istream_iterator<Elem>,
-        Elem,
-        std::input_iterator_tag,
-        Elem
-    > super_t;
-    typedef typename std::basic_istream<Elem> istream_type;
- 
-    bool equal(const this_t & rhs) const {
-        // note: only  works for comparison against end of stream
-        return m_istream == rhs.m_istream;
-    }
-
-    //Access the value referred to 
-    Elem dereference() const {
-        return static_cast<Elem>(m_istream->peek());
-    }
-
-    void increment(){
-        if(NULL != m_istream){
-            m_istream->ignore(1);
-        }
-    }
-
-    istream_type *m_istream;
-    Elem m_current_value;
-public:
-    istream_iterator(istream_type & is) :
-        m_istream(& is)
-    {
-        //increment();
-    }
-
-    istream_iterator() :
-        m_istream(NULL),
-        m_current_value(NULL)
-    {}
-
-    istream_iterator(const istream_iterator<Elem> & rhs) :
-        m_istream(rhs.m_istream),
-        m_current_value(rhs.m_current_value)
-    {}
-};
-
-} // namespace iterators
-} // namespace archive
-} // namespace boost
-
-#endif // BOOST_ARCHIVE_ITERATORS_ISTREAM_ITERATOR_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/iterators/mb_from_wchar.hpp b/contrib/libboost/boost_1_65_0/boost/archive/iterators/mb_from_wchar.hpp
deleted file mode 100644
index 05df71c258e..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/iterators/mb_from_wchar.hpp
+++ /dev/null
@@ -1,139 +0,0 @@
-#ifndef BOOST_ARCHIVE_ITERATORS_MB_FROM_WCHAR_HPP
-#define BOOST_ARCHIVE_ITERATORS_MB_FROM_WCHAR_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// mb_from_wchar.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/assert.hpp>
-#include <cstddef> // size_t
-#ifndef BOOST_NO_CWCHAR
-#include <cwchar> //  mbstate_t
-#endif
-#include <boost/config.hpp>
-#if defined(BOOST_NO_STDC_NAMESPACE)
-namespace std{ 
-    using ::mbstate_t;
-} // namespace std
-#endif
-
-#include <boost/archive/detail/utf8_codecvt_facet.hpp>
-#include <boost/iterator/iterator_adaptor.hpp>
-
-namespace boost { 
-namespace archive {
-namespace iterators {
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// class used by text archives to translate wide strings and to char
-// strings of the currently selected locale
-template<class Base>    // the input iterator
-class mb_from_wchar
-    : public boost::iterator_adaptor<
-        mb_from_wchar<Base>, 
-        Base, 
-        wchar_t,
-        single_pass_traversal_tag,
-        char
-    >
-{
-    friend class boost::iterator_core_access;
-
-    typedef typename boost::iterator_adaptor<
-        mb_from_wchar<Base>, 
-        Base, 
-        wchar_t,
-        single_pass_traversal_tag,
-        char
-    > super_t;
-
-    typedef mb_from_wchar<Base> this_t;
-
-    char dereference_impl() {
-        if(! m_full){
-            fill();
-            m_full = true;
-        }
-        return m_buffer[m_bnext];
-    }
-
-    char dereference() const {
-        return (const_cast<this_t *>(this))->dereference_impl();
-    }
-    // test for iterator equality
-    bool equal(const mb_from_wchar<Base> & rhs) const {
-        // once the value is filled, the base_reference has been incremented
-        // so don't permit comparison anymore.
-        return 
-            0 == m_bend
-            && 0 == m_bnext
-            && this->base_reference() == rhs.base_reference()
-        ;
-    }
-
-    void fill(){
-        wchar_t value = * this->base_reference();
-        const wchar_t *wend;
-        char *bend;
-        std::codecvt_base::result r = m_codecvt_facet.out(
-            m_mbs,
-            & value, & value + 1, wend,
-            m_buffer, m_buffer + sizeof(m_buffer), bend
-        );
-        BOOST_ASSERT(std::codecvt_base::ok == r);
-        m_bnext = 0;
-        m_bend = bend - m_buffer;
-    }
-
-    void increment(){
-        if(++m_bnext < m_bend)
-            return;
-        m_bend = 
-        m_bnext = 0;
-        ++(this->base_reference());
-        m_full = false;
-    }
-
-    boost::archive::detail::utf8_codecvt_facet m_codecvt_facet;
-    std::mbstate_t m_mbs;
-    // buffer to handle pending characters
-    char m_buffer[9 /* MB_CUR_MAX */];
-    std::size_t m_bend;
-    std::size_t m_bnext;
-    bool m_full;
-
-public:
-    // make composible buy using templated constructor
-    template<class T>
-    mb_from_wchar(T start) :
-        super_t(Base(static_cast< T >(start))),
-        m_mbs(std::mbstate_t()),
-        m_bend(0),
-        m_bnext(0),
-        m_full(false)
-    {}
-    // intel 7.1 doesn't like default copy constructor
-    mb_from_wchar(const mb_from_wchar & rhs) : 
-        super_t(rhs.base_reference()),
-        m_bend(rhs.m_bend),
-        m_bnext(rhs.m_bnext),
-        m_full(rhs.m_full)
-    {}
-};
-
-} // namespace iterators
-} // namespace archive
-} // namespace boost
-
-#endif // BOOST_ARCHIVE_ITERATORS_MB_FROM_WCHAR_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/iterators/ostream_iterator.hpp b/contrib/libboost/boost_1_65_0/boost/archive/iterators/ostream_iterator.hpp
deleted file mode 100644
index 49a9b99034b..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/iterators/ostream_iterator.hpp
+++ /dev/null
@@ -1,83 +0,0 @@
-#ifndef BOOST_ARCHIVE_ITERATORS_OSTREAM_ITERATOR_HPP
-#define BOOST_ARCHIVE_ITERATORS_OSTREAM_ITERATOR_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// ostream_iterator.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-// note: this is a custom version of the standard ostream_iterator.
-// This is necessary as the standard version doesn't work as expected
-// for wchar_t based streams on systems for which wchar_t not a true
-// type but rather a synonym for some integer type.
-
-#include <ostream>
-#include <boost/iterator/iterator_facade.hpp>
-
-namespace boost { 
-namespace archive {
-namespace iterators {
-
-// given a type, make an input iterator based on a pointer to that type
-template<class Elem>
-class ostream_iterator :  
-    public boost::iterator_facade<
-        ostream_iterator<Elem>,
-        Elem,
-        std::output_iterator_tag,
-        ostream_iterator<Elem> &
-    >
-{
-    friend class boost::iterator_core_access;
-    typedef ostream_iterator this_t ;
-    typedef Elem char_type;
-    typedef std::basic_ostream<char_type> ostream_type;
-
-    //emulate the behavior of std::ostream 
-    ostream_iterator & dereference() const {
-        return const_cast<ostream_iterator &>(*this);
-    }
-    bool equal(const this_t & rhs) const {
-        return m_ostream == rhs.m_ostream;
-    }
-    void increment(){}
-protected:
-    ostream_type *m_ostream;
-    void put_val(char_type e){
-        if(NULL != m_ostream){
-            m_ostream->put(e);
-            if(! m_ostream->good())
-                m_ostream = NULL;
-        }
-    }
-public:
-    this_t & operator=(char_type c){
-        put_val(c);
-        return *this;
-    }
-    ostream_iterator(ostream_type & os) :
-        m_ostream (& os)
-    {}
-    ostream_iterator() :
-        m_ostream (NULL)
-    {}
-    ostream_iterator(const ostream_iterator & rhs) :
-        m_ostream (rhs.m_ostream)
-    {}
-};
-
-} // namespace iterators
-} // namespace archive
-} // namespace boost
-
-#endif // BOOST_ARCHIVE_ITERATORS_OSTREAM_ITERATOR_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/iterators/remove_whitespace.hpp b/contrib/libboost/boost_1_65_0/boost/archive/iterators/remove_whitespace.hpp
deleted file mode 100644
index c3580ab258a..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/iterators/remove_whitespace.hpp
+++ /dev/null
@@ -1,167 +0,0 @@
-#ifndef BOOST_ARCHIVE_ITERATORS_REMOVE_WHITESPACE_HPP
-#define BOOST_ARCHIVE_ITERATORS_REMOVE_WHITESPACE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// remove_whitespace.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/assert.hpp>
-
-#include <boost/iterator/iterator_adaptor.hpp>
-#include <boost/iterator/filter_iterator.hpp>
-#include <boost/iterator/iterator_traits.hpp>
-
-// here is the default standard implementation of the functor used
-// by the filter iterator to remove spaces.  Unfortunately usage
-// of this implementation in combination with spirit trips a bug
-// VC 6.5.  The only way I can find to work around it is to 
-// implement a special non-standard version for this platform
-
-#ifndef BOOST_NO_CWCTYPE
-#include <cwctype> // iswspace
-#if defined(BOOST_NO_STDC_NAMESPACE)
-namespace std{ using ::iswspace; }
-#endif
-#endif
-
-#include <cctype> // isspace
-#if defined(BOOST_NO_STDC_NAMESPACE)
-namespace std{ using ::isspace; }
-#endif
-
-#if defined(__STD_RWCOMPILER_H__) || defined(_RWSTD_VER)
-// this is required for the RW STL on Linux and Tru64.
-#undef isspace
-#undef iswspace
-#endif
-
-namespace { // anonymous
-
-template<class CharType>
-struct remove_whitespace_predicate;
-
-template<>
-struct remove_whitespace_predicate<char>
-{
-    bool operator()(unsigned char t){
-        return ! std::isspace(t);
-    }
-};
-
-#ifndef BOOST_NO_CWCHAR
-template<>
-struct remove_whitespace_predicate<wchar_t>
-{
-    bool operator()(wchar_t t){
-        return ! std::iswspace(t);
-    }
-};
-#endif
-
-} // namespace anonymous
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// convert base64 file data (including whitespace and padding) to binary
-
-namespace boost { 
-namespace archive {
-namespace iterators {
-
-// custom version of filter iterator which doesn't look ahead further than
-// necessary
-
-template<class Predicate, class Base>
-class filter_iterator
-    : public boost::iterator_adaptor<
-        filter_iterator<Predicate, Base>,
-        Base,
-        use_default,
-        single_pass_traversal_tag
-    >
-{
-    friend class boost::iterator_core_access;
-    typedef typename boost::iterator_adaptor<
-        filter_iterator<Predicate, Base>,
-        Base,
-        use_default,
-        single_pass_traversal_tag
-    > super_t;
-    typedef filter_iterator<Predicate, Base> this_t;
-    typedef typename super_t::reference reference_type;
-
-    reference_type dereference_impl(){
-        if(! m_full){
-            while(! m_predicate(* this->base_reference()))
-                ++(this->base_reference());
-            m_full = true;
-        }
-        return * this->base_reference();
-    }
-
-    reference_type dereference() const {
-        return const_cast<this_t *>(this)->dereference_impl();
-    }
-
-    Predicate m_predicate;
-    bool m_full;
-public:
-    // note: this function is public only because comeau compiler complained
-    // I don't know if this is because the compiler is wrong or what
-    void increment(){
-        m_full = false;
-        ++(this->base_reference());
-    }
-    filter_iterator(Base start) : 
-        super_t(start), 
-        m_full(false)
-    {}
-    filter_iterator(){}
-};
-
-template<class Base>
-class remove_whitespace : 
-    public filter_iterator<
-        remove_whitespace_predicate<
-            typename boost::iterator_value<Base>::type
-            //typename Base::value_type
-        >,
-        Base
-    >
-{
-    friend class boost::iterator_core_access;
-    typedef filter_iterator<
-        remove_whitespace_predicate<
-            typename boost::iterator_value<Base>::type
-            //typename Base::value_type
-        >,
-        Base
-    > super_t;
-public:
-//    remove_whitespace(){} // why is this needed?
-    // make composible buy using templated constructor
-    template<class T>
-    remove_whitespace(T start) :
-        super_t(Base(static_cast< T >(start)))
-    {}
-    // intel 7.1 doesn't like default copy constructor
-    remove_whitespace(const remove_whitespace & rhs) : 
-        super_t(rhs.base_reference())
-    {}
-};
-
-} // namespace iterators
-} // namespace archive
-} // namespace boost
-
-#endif // BOOST_ARCHIVE_ITERATORS_REMOVE_WHITESPACE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/iterators/transform_width.hpp b/contrib/libboost/boost_1_65_0/boost/archive/iterators/transform_width.hpp
deleted file mode 100644
index 09c050a9274..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/iterators/transform_width.hpp
+++ /dev/null
@@ -1,177 +0,0 @@
-#ifndef BOOST_ARCHIVE_ITERATORS_TRANSFORM_WIDTH_HPP
-#define BOOST_ARCHIVE_ITERATORS_TRANSFORM_WIDTH_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// transform_width.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-// iterator which takes elements of x bits and returns elements of y bits.
-// used to change streams of 8 bit characters into streams of 6 bit characters.
-// and vice-versa for implementing base64 encodeing/decoding. Be very careful
-// when using and end iterator.  end is only reliable detected when the input
-// stream length is some common multiple of x and y.  E.G. Base64 6 bit
-// character and 8 bit bytes. Lowest common multiple is 24 => 4 6 bit characters
-// or 3 8 bit characters
-
-#include <boost/iterator/iterator_adaptor.hpp>
-#include <boost/iterator/iterator_traits.hpp>
-
-#include <algorithm> // std::min
-
-namespace boost { 
-namespace archive {
-namespace iterators {
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// class used by text archives to translate char strings to wchar_t
-// strings of the currently selected locale
-template<
-    class Base, 
-    int BitsOut, 
-    int BitsIn, 
-    class CharType = typename boost::iterator_value<Base>::type // output character
->
-class transform_width : 
-    public boost::iterator_adaptor<
-        transform_width<Base, BitsOut, BitsIn, CharType>,
-        Base,
-        CharType,
-        single_pass_traversal_tag,
-        CharType
-    >
-{
-    friend class boost::iterator_core_access;
-    typedef typename boost::iterator_adaptor<
-        transform_width<Base, BitsOut, BitsIn, CharType>,
-        Base,
-        CharType,
-        single_pass_traversal_tag,
-        CharType
-    > super_t;
-
-    typedef transform_width<Base, BitsOut, BitsIn, CharType> this_t;
-    typedef typename iterator_value<Base>::type base_value_type;
-
-    void fill();
-
-    CharType dereference() const {
-        if(!m_buffer_out_full)
-            const_cast<this_t *>(this)->fill();
-        return m_buffer_out;
-    }
-
-    bool equal_impl(const this_t & rhs){
-        if(BitsIn < BitsOut) // discard any left over bits
-            return this->base_reference() == rhs.base_reference();
-        else{
-            // BitsIn > BitsOut  // zero fill
-            if(this->base_reference() == rhs.base_reference()){
-                m_end_of_sequence = true;
-                return 0 == m_remaining_bits;
-            }
-            return false;
-        }
-    }
-
-    // standard iterator interface
-    bool equal(const this_t & rhs) const {
-        return const_cast<this_t *>(this)->equal_impl(rhs);
-    }
-
-    void increment(){
-        m_buffer_out_full = false;
-    }
-
-    bool m_buffer_out_full;
-    CharType m_buffer_out;
-
-    // last read element from input
-    base_value_type m_buffer_in;
-
-    // number of bits to left in the input buffer.
-    unsigned int m_remaining_bits;
-
-    // flag to indicate we've reached end of data.
-    bool m_end_of_sequence;
-
-public:
-    // make composible buy using templated constructor
-    template<class T>
-    transform_width(T start) : 
-        super_t(Base(static_cast< T >(start))),
-        m_buffer_out_full(false),
-        m_buffer_out(0),
-        // To disable GCC warning, but not truly necessary 
-	    //(m_buffer_in will be initialized later before being 
-	    //used because m_remaining_bits == 0)
-        m_buffer_in(0), 
-        m_remaining_bits(0),
-        m_end_of_sequence(false)
-    {}
-    // intel 7.1 doesn't like default copy constructor
-    transform_width(const transform_width & rhs) : 
-        super_t(rhs.base_reference()),
-        m_buffer_out_full(rhs.m_buffer_out_full),
-        m_buffer_out(rhs.m_buffer_out),
-        m_buffer_in(rhs.m_buffer_in),
-        m_remaining_bits(rhs.m_remaining_bits),
-        m_end_of_sequence(false)
-    {}
-};
-
-template<
-    class Base, 
-    int BitsOut, 
-    int BitsIn, 
-    class CharType
->
-void transform_width<Base, BitsOut, BitsIn, CharType>::fill() {
-    unsigned int missing_bits = BitsOut;
-    m_buffer_out = 0;
-    do{
-        if(0 == m_remaining_bits){
-            if(m_end_of_sequence){
-                m_buffer_in = 0;
-                m_remaining_bits = missing_bits;
-            }
-            else{
-                m_buffer_in = * this->base_reference()++;
-                m_remaining_bits = BitsIn;
-            }
-        }
-
-        // append these bits to the next output
-        // up to the size of the output
-        unsigned int i = (std::min)(missing_bits, m_remaining_bits);
-        // shift interesting bits to least significant position
-        base_value_type j = m_buffer_in >> (m_remaining_bits - i);
-        // and mask off the un interesting higher bits
-        // note presumption of twos complement notation
-        j &= (1 << i) - 1;
-        // append then interesting bits to the output value
-        m_buffer_out <<= i;
-        m_buffer_out |= j;
-
-        // and update counters
-        missing_bits -= i;
-        m_remaining_bits -= i;
-    }while(0 < missing_bits);
-    m_buffer_out_full = true;
-}
-
-} // namespace iterators
-} // namespace archive
-} // namespace boost
-
-#endif // BOOST_ARCHIVE_ITERATORS_TRANSFORM_WIDTH_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/iterators/unescape.hpp b/contrib/libboost/boost_1_65_0/boost/archive/iterators/unescape.hpp
deleted file mode 100644
index abf62406088..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/iterators/unescape.hpp
+++ /dev/null
@@ -1,89 +0,0 @@
-#ifndef BOOST_ARCHIVE_ITERATORS_UNESCAPE_HPP
-#define BOOST_ARCHIVE_ITERATORS_UNESCAPE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// unescape.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/assert.hpp>
-
-#include <boost/iterator/iterator_adaptor.hpp>
-#include <boost/pointee.hpp>
-
-namespace boost { 
-namespace archive {
-namespace iterators {
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// class used by text archives to translate char strings to wchar_t
-// strings of the currently selected locale
-template<class Derived, class Base>
-class unescape 
-    : public boost::iterator_adaptor<
-        unescape<Derived, Base>,
-        Base, 
-        typename pointee<Base>::type,
-        single_pass_traversal_tag,
-        typename pointee<Base>::type
-    >
-{
-    friend class boost::iterator_core_access;
-    typedef typename boost::iterator_adaptor<
-        unescape<Derived, Base>, 
-        Base, 
-        typename pointee<Base>::type,
-        single_pass_traversal_tag,
-        typename pointee<Base>::type
-    > super_t;
-
-    typedef unescape<Derived, Base> this_t;
-public:
-    typedef typename this_t::value_type value_type;
-    typedef typename this_t::reference reference;
-private:
-    value_type dereference_impl() {
-        if(! m_full){
-            m_current_value = static_cast<Derived *>(this)->drain();
-            m_full = true;
-        }
-        return m_current_value;
-    }
-
-    reference dereference() const {
-        return const_cast<this_t *>(this)->dereference_impl();
-    }
-
-    value_type m_current_value;
-    bool m_full;
-
-    void increment(){
-        ++(this->base_reference());
-        dereference_impl();
-        m_full = false;
-    };
-
-public:
-
-    unescape(Base base) : 
-        super_t(base),
-        m_full(false)
-    {}
-
-};
-
-} // namespace iterators
-} // namespace archive
-} // namespace boost
-
-#endif // BOOST_ARCHIVE_ITERATORS_UNESCAPE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/iterators/wchar_from_mb.hpp b/contrib/libboost/boost_1_65_0/boost/archive/iterators/wchar_from_mb.hpp
deleted file mode 100644
index 2af8f6401f2..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/iterators/wchar_from_mb.hpp
+++ /dev/null
@@ -1,194 +0,0 @@
-#ifndef BOOST_ARCHIVE_ITERATORS_WCHAR_FROM_MB_HPP
-#define BOOST_ARCHIVE_ITERATORS_WCHAR_FROM_MB_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// wchar_from_mb.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/assert.hpp>
-#include <cctype>
-#include <cstddef> // size_t
-#ifndef BOOST_NO_CWCHAR
-#include <cwchar>  // mbstate_t
-#endif
-#include <algorithm> // copy
-
-#include <boost/config.hpp>
-#if defined(BOOST_NO_STDC_NAMESPACE)
-namespace std{ 
-    using ::mbstate_t;
-} // namespace std
-#endif
-#include <boost/array.hpp>
-#include <boost/iterator/iterator_adaptor.hpp>
-#include <boost/archive/detail/utf8_codecvt_facet.hpp>
-#include <boost/archive/iterators/dataflow_exception.hpp>
-#include <boost/serialization/throw_exception.hpp>
-
-#include <iostream>
-
-namespace boost { 
-namespace archive {
-namespace iterators {
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// class used by text archives to translate char strings to wchar_t
-// strings of the currently selected locale
-template<class Base>
-class wchar_from_mb 
-    : public boost::iterator_adaptor<
-        wchar_from_mb<Base>, 
-        Base, 
-        wchar_t,
-        single_pass_traversal_tag,
-        wchar_t
-    >
-{
-    friend class boost::iterator_core_access;
-    typedef typename boost::iterator_adaptor<
-        wchar_from_mb<Base>, 
-        Base, 
-        wchar_t,
-        single_pass_traversal_tag,
-        wchar_t
-    > super_t;
-
-    typedef wchar_from_mb<Base> this_t;
-
-    void drain();
-
-    wchar_t dereference() const {
-        if(m_output.m_next == m_output.m_next_available)
-            return static_cast<wchar_t>(0);
-        return * m_output.m_next;
-    }
-
-    void increment(){
-        if(m_output.m_next == m_output.m_next_available)
-            return;
-        if(++m_output.m_next == m_output.m_next_available){
-            if(m_input.m_done)
-                return;
-            drain();
-        }
-    }
-
-    bool equal(this_t const & rhs) const {
-        return dereference() == rhs.dereference();
-    }
-
-    boost::archive::detail::utf8_codecvt_facet m_codecvt_facet;
-    std::mbstate_t m_mbs;
-
-    template<typename T>
-    struct sliding_buffer {
-        boost::array<T, 32> m_buffer;
-        typename boost::array<T, 32>::const_iterator m_next_available;
-        typename boost::array<T, 32>::iterator m_next;
-        bool m_done;
-        // default ctor
-        sliding_buffer() :
-            m_next_available(m_buffer.begin()),
-            m_next(m_buffer.begin()),
-            m_done(false)
-        {}
-        // copy ctor
-        sliding_buffer(const sliding_buffer & rhs) :
-            m_next_available(
-                std::copy(
-                    rhs.m_buffer.begin(),
-                    rhs.m_next_available,
-                    m_buffer.begin()
-                )
-            ),
-            m_next(
-                m_buffer.begin() + (rhs.m_next - rhs.m_buffer.begin())
-            ),
-            m_done(rhs.m_done)
-        {}
-    };
-
-    sliding_buffer<typename iterator_value<Base>::type> m_input;
-    sliding_buffer<typename iterator_value<this_t>::type> m_output;
-
-public:
-    // make composible buy using templated constructor
-    template<class T>
-    wchar_from_mb(T start) : 
-        super_t(Base(static_cast< T >(start))),
-        m_mbs(std::mbstate_t())
-    {
-        BOOST_ASSERT(std::mbsinit(&m_mbs));
-        drain();
-    }
-    // default constructor used as an end iterator
-    wchar_from_mb(){}
-
-    // copy ctor
-    wchar_from_mb(const wchar_from_mb & rhs) :
-        super_t(rhs.base_reference()),
-        m_mbs(rhs.m_mbs),
-        m_input(rhs.m_input),
-        m_output(rhs.m_output)
-    {}
-};
-
-template<class Base>
-void wchar_from_mb<Base>::drain(){
-    BOOST_ASSERT(! m_input.m_done);
-    for(;;){
-        typename boost::iterators::iterator_reference<Base>::type c = *(this->base_reference());
-        // a null character in a multibyte stream is takes as end of string
-        if(0 == c){
-            m_input.m_done = true;
-            break;
-        }
-        ++(this->base_reference());
-        * const_cast<typename iterator_value<Base>::type *>(
-            (m_input.m_next_available++)
-        ) = c;
-        // if input buffer is full - we're done for now
-        if(m_input.m_buffer.end() == m_input.m_next_available)
-            break;
-    }
-    const typename boost::iterators::iterator_value<Base>::type * input_new_start;
-    typename iterator_value<this_t>::type * next_available;
-
-    std::codecvt_base::result r = m_codecvt_facet.in(
-        m_mbs,
-        m_input.m_buffer.begin(),
-        m_input.m_next_available,
-        input_new_start,
-        m_output.m_buffer.begin(),
-        m_output.m_buffer.end(),
-        next_available
-    );
-    BOOST_ASSERT(std::codecvt_base::ok == r);
-    m_output.m_next_available = next_available;
-    m_output.m_next = m_output.m_buffer.begin();
-
-    // we're done with some of the input so shift left.
-    m_input.m_next_available = std::copy(
-        input_new_start,
-        m_input.m_next_available,
-        m_input.m_buffer.begin()
-    );
-    m_input.m_next = m_input.m_buffer.begin();
-}
-
-} // namespace iterators
-} // namespace archive
-} // namespace boost
-
-#endif // BOOST_ARCHIVE_ITERATORS_WCHAR_FROM_MB_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/iterators/xml_escape.hpp b/contrib/libboost/boost_1_65_0/boost/archive/iterators/xml_escape.hpp
deleted file mode 100644
index c838a73b864..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/iterators/xml_escape.hpp
+++ /dev/null
@@ -1,121 +0,0 @@
-#ifndef BOOST_ARCHIVE_ITERATORS_XML_ESCAPE_HPP
-#define BOOST_ARCHIVE_ITERATORS_XML_ESCAPE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// xml_escape.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/assert.hpp>
-#include <boost/archive/iterators/escape.hpp>
-
-namespace boost { 
-namespace archive {
-namespace iterators {
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// insert escapes into xml text
-
-template<class Base>
-class xml_escape 
-    : public escape<xml_escape<Base>, Base>
-{
-    friend class boost::iterator_core_access;
-
-    typedef escape<xml_escape<Base>, Base> super_t;
-
-public:
-    char fill(const char * & bstart, const char * & bend);
-    wchar_t fill(const wchar_t * & bstart, const wchar_t * & bend);
-
-    template<class T>
-    xml_escape(T start) :
-        super_t(Base(static_cast< T >(start)))
-    {}
-    // intel 7.1 doesn't like default copy constructor
-    xml_escape(const xml_escape & rhs) : 
-        super_t(rhs.base_reference())
-    {}
-};
-
-template<class Base>
-char xml_escape<Base>::fill(
-    const char * & bstart, 
-    const char * & bend
-){
-    char current_value = * this->base_reference();
-    switch(current_value){
-    case '<':
-        bstart = "&lt;";
-        bend = bstart + 4;
-        break;
-    case '>':
-        bstart = "&gt;";
-        bend = bstart + 4;
-        break;
-    case '&':
-        bstart = "&amp;";
-        bend = bstart + 5;
-        break;
-    case '"':
-        bstart = "&quot;";
-        bend = bstart + 6;
-        break;
-    case '\'':
-        bstart = "&apos;";
-        bend = bstart + 6;
-        break;
-    default:
-        return current_value;
-    }
-    return *bstart;
-}
-
-template<class Base>
-wchar_t xml_escape<Base>::fill(
-    const wchar_t * & bstart, 
-    const wchar_t * & bend
-){
-    wchar_t current_value = * this->base_reference();
-    switch(current_value){
-    case '<':
-        bstart = L"&lt;";
-        bend = bstart + 4;
-        break;
-    case '>':
-        bstart = L"&gt;";
-        bend = bstart + 4;
-        break;
-    case '&':
-        bstart = L"&amp;";
-        bend = bstart + 5;
-        break;
-    case '"':
-        bstart = L"&quot;";
-        bend = bstart + 6;
-        break;
-    case '\'':
-        bstart = L"&apos;";
-        bend = bstart + 6;
-        break;
-    default:
-        return current_value;
-    }
-    return *bstart;
-}
-
-} // namespace iterators
-} // namespace archive
-} // namespace boost
-
-#endif // BOOST_ARCHIVE_ITERATORS_XML_ESCAPE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/iterators/xml_unescape.hpp b/contrib/libboost/boost_1_65_0/boost/archive/iterators/xml_unescape.hpp
deleted file mode 100644
index 69977404567..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/iterators/xml_unescape.hpp
+++ /dev/null
@@ -1,125 +0,0 @@
-#ifndef BOOST_ARCHIVE_ITERATORS_XML_UNESCAPE_HPP
-#define BOOST_ARCHIVE_ITERATORS_XML_UNESCAPE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// xml_unescape.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/assert.hpp>
-
-#include <boost/serialization/throw_exception.hpp>
-
-#include <boost/archive/iterators/unescape.hpp>
-#include <boost/archive/iterators/dataflow_exception.hpp>
-
-namespace boost { 
-namespace archive {
-namespace iterators {
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// replace &??? xml escape sequences with the corresponding characters
-template<class Base>
-class xml_unescape 
-    : public unescape<xml_unescape<Base>, Base>
-{
-    friend class boost::iterator_core_access;
-    typedef xml_unescape<Base> this_t;
-    typedef unescape<this_t, Base> super_t;
-    typedef typename boost::iterator_reference<this_t> reference_type;
-
-    reference_type dereference() const {
-        return unescape<xml_unescape<Base>, Base>::dereference();
-    }
-public:
-    // workaround msvc 7.1 ICU crash
-    #if defined(BOOST_MSVC)
-        typedef int value_type;
-    #else
-        typedef typename this_t::value_type value_type;
-    #endif
-
-    void drain_residue(const char *literal);
-    value_type drain();
-
-    template<class T>
-    xml_unescape(T start) : 
-        super_t(Base(static_cast< T >(start)))
-    {}
-    // intel 7.1 doesn't like default copy constructor
-    xml_unescape(const xml_unescape & rhs) : 
-        super_t(rhs.base_reference())
-    {}
-};
-
-template<class Base>
-void xml_unescape<Base>::drain_residue(const char * literal){
-    do{
-        if(* literal != * ++(this->base_reference()))
-            boost::serialization::throw_exception(
-                dataflow_exception(
-                    dataflow_exception::invalid_xml_escape_sequence
-                )
-            );
-    }
-    while('\0' != * ++literal);
-}
-
-// note key constraint on this function is that can't "look ahead" any
-// more than necessary into base iterator.  Doing so would alter the base
-// iterator refenence which would make subsequent iterator comparisons
-// incorrect and thereby break the composiblity of iterators.
-template<class Base>
-typename xml_unescape<Base>::value_type 
-//int 
-xml_unescape<Base>::drain(){
-    value_type retval = * this->base_reference();
-    if('&' != retval){
-        return retval;
-    }
-    retval = * ++(this->base_reference());
-    switch(retval){
-    case 'l': // &lt;
-        drain_residue("t;");
-        retval = '<';
-        break;
-    case 'g': // &gt;
-        drain_residue("t;");
-        retval = '>';
-        break;
-    case 'a':
-        retval = * ++(this->base_reference());
-        switch(retval){
-        case 'p': // &apos;
-            drain_residue("os;");
-            retval = '\'';
-            break;
-        case 'm': // &amp;
-            drain_residue("p;");
-            retval = '&';
-            break;
-        }
-        break;
-    case 'q':
-        drain_residue("uot;");
-        retval = '"';
-        break;
-    }
-    return retval;
-}
-
-} // namespace iterators
-} // namespace archive
-} // namespace boost
-
-#endif // BOOST_ARCHIVE_ITERATORS_XML_UNESCAPE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/iterators/xml_unescape_exception.hpp b/contrib/libboost/boost_1_65_0/boost/archive/iterators/xml_unescape_exception.hpp
deleted file mode 100644
index 71a64378c20..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/iterators/xml_unescape_exception.hpp
+++ /dev/null
@@ -1,49 +0,0 @@
-#ifndef BOOST_ARCHIVE_ITERATORS_XML_UNESCAPE_EXCEPTION_HPP
-#define BOOST_ARCHIVE_ITERATORS_XML_UNESCAPE_EXCEPTION_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// xml_unescape_exception.hpp:
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/config.hpp>
-#ifndef BOOST_NO_EXCEPTIONS
-#include <exception>
-
-#include <boost/assert.hpp>
-
-namespace boost {
-namespace archive {
-namespace iterators {
-
-//////////////////////////////////////////////////////////////////////
-// exceptions thrown by xml_unescapes
-//
-class xml_unescape_exception : public std::exception
-{
-public:
-    xml_unescape_exception()
-    {}
-
-    virtual const char *what( ) const throw( )
-    {
-        return "xml contained un-recognized escape code";
-    }
-};
-
-} // namespace iterators
-} // namespace archive
-} // namespace boost
-
-#endif //BOOST_NO_EXCEPTIONS
-#endif //BOOST_ARCHIVE_ITERATORS_XML_UNESCAPE_EXCEPTION_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/polymorphic_binary_iarchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/polymorphic_binary_iarchive.hpp
deleted file mode 100644
index 4a898a8ad16..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/polymorphic_binary_iarchive.hpp
+++ /dev/null
@@ -1,54 +0,0 @@
-#ifndef BOOST_ARCHIVE_POLYMORPHIC_BINARY_IARCHIVE_HPP
-#define BOOST_ARCHIVE_POLYMORPHIC_BINARY_IARCHIVE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// polymorphic_binary_iarchive.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/config.hpp>
-#include <boost/archive/binary_iarchive.hpp>
-#include <boost/archive/detail/polymorphic_iarchive_route.hpp>
-
-#ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable : 4511 4512)
-#endif
-
-namespace boost { 
-namespace archive {
-
-class polymorphic_binary_iarchive : 
-    public detail::polymorphic_iarchive_route<binary_iarchive>
-{
-public:
-    polymorphic_binary_iarchive(std::istream & is, unsigned int flags = 0) :
-        detail::polymorphic_iarchive_route<binary_iarchive>(is, flags)
-    {}
-    ~polymorphic_binary_iarchive(){}
-};
-
-} // namespace archive
-} // namespace boost
-
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
-
-// required by export
-BOOST_SERIALIZATION_REGISTER_ARCHIVE(
-    boost::archive::polymorphic_binary_iarchive
-)
-
-#endif // BOOST_ARCHIVE_POLYMORPHIC_BINARY_IARCHIVE_HPP
-
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/polymorphic_binary_oarchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/polymorphic_binary_oarchive.hpp
deleted file mode 100644
index 931b243feb8..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/polymorphic_binary_oarchive.hpp
+++ /dev/null
@@ -1,43 +0,0 @@
-#ifndef BOOST_ARCHIVE_POLYMORPHIC_BINARY_OARCHIVE_HPP
-#define BOOST_ARCHIVE_POLYMORPHIC_BINARY_OARCHIVE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// polymorphic_binary_oarchive.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/config.hpp>
-#include <boost/archive/binary_oarchive.hpp>
-#include <boost/archive/detail/polymorphic_oarchive_route.hpp>
-
-namespace boost { 
-namespace archive {
-
-typedef detail::polymorphic_oarchive_route<
-    binary_oarchive_impl<
-        binary_oarchive, 
-        std::ostream::char_type, 
-        std::ostream::traits_type
-    >
- > polymorphic_binary_oarchive;
-
-} // namespace archive
-} // namespace boost
-
-// required by export
-BOOST_SERIALIZATION_REGISTER_ARCHIVE(
-    boost::archive::polymorphic_binary_oarchive
-)
-
-#endif // BOOST_ARCHIVE_POLYMORPHIC_BINARY_OARCHIVE_HPP
-
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/polymorphic_iarchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/polymorphic_iarchive.hpp
deleted file mode 100644
index d3c59a9f0f4..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/polymorphic_iarchive.hpp
+++ /dev/null
@@ -1,168 +0,0 @@
-#ifndef BOOST_ARCHIVE_POLYMORPHIC_IARCHIVE_HPP
-#define BOOST_ARCHIVE_POLYMORPHIC_IARCHIVE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// polymorphic_iarchive.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <cstddef> // std::size_t
-#include <climits> // ULONG_MAX 
-#include <string>
-
-#include <boost/config.hpp>
-#if defined(BOOST_NO_STDC_NAMESPACE)
-namespace std{
-    using ::size_t;
-} // namespace std
-#endif
-
-#include <boost/cstdint.hpp>
-
-#include <boost/archive/detail/iserializer.hpp>
-#include <boost/archive/detail/interface_iarchive.hpp>
-#include <boost/serialization/nvp.hpp>
-#include <boost/archive/detail/register_archive.hpp>
-
-#include <boost/archive/detail/decl.hpp>
-#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
-
-namespace boost {
-namespace serialization {
-    class extended_type_info;
-} // namespace serialization
-namespace archive {
-namespace detail {
-    class basic_iarchive;
-    class basic_iserializer;
-}
-
-class polymorphic_iarchive;
-
-class BOOST_SYMBOL_VISIBLE polymorphic_iarchive_impl :
-    public detail::interface_iarchive<polymorphic_iarchive>
-{
-#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
-public:
-#else
-    friend class detail::interface_iarchive<polymorphic_iarchive>;
-    friend class load_access;
-#endif
-    // primitive types the only ones permitted by polymorphic archives
-    virtual void load(bool & t) = 0;
-
-    virtual void load(char & t) = 0;
-    virtual void load(signed char & t) = 0;
-    virtual void load(unsigned char & t) = 0;
-    #ifndef BOOST_NO_CWCHAR
-    #ifndef BOOST_NO_INTRINSIC_WCHAR_T
-    virtual void load(wchar_t & t) = 0;
-    #endif
-    #endif
-    virtual void load(short & t) = 0;
-    virtual void load(unsigned short & t) = 0;
-    virtual void load(int & t) = 0;
-    virtual void load(unsigned int & t) = 0;
-    virtual void load(long & t) = 0;
-    virtual void load(unsigned long & t) = 0;
-
-    #if defined(BOOST_HAS_LONG_LONG)
-    virtual void load(boost::long_long_type & t) = 0;
-    virtual void load(boost::ulong_long_type & t) = 0;
-    #elif defined(BOOST_HAS_MS_INT64)
-    virtual void load(__int64 & t) = 0;
-    virtual void load(unsigned __int64 & t) = 0;
-    #endif
-
-    virtual void load(float & t) = 0;
-    virtual void load(double & t) = 0;
-
-    // string types are treated as primitives
-    virtual void load(std::string & t) = 0;
-    #ifndef BOOST_NO_STD_WSTRING
-    virtual void load(std::wstring & t) = 0;
-    #endif
-
-    // used for xml and other tagged formats
-    virtual void load_start(const char * name) = 0;
-    virtual void load_end(const char * name) = 0;
-    virtual void register_basic_serializer(const detail::basic_iserializer & bis) = 0;
-    virtual detail::helper_collection & get_helper_collection() = 0;
-
-    // msvc and borland won't automatically pass these to the base class so
-    // make it explicit here
-    template<class T>
-    void load_override(T & t)
-    {
-        archive::load(* this->This(), t);
-    }
-    // special treatment for name-value pairs.
-    template<class T>
-    void load_override(
-        const boost::serialization::nvp< T > & t
-    ){
-        load_start(t.name());
-        archive::load(* this->This(), t.value());
-        load_end(t.name());
-    }
-protected:
-    virtual ~polymorphic_iarchive_impl(){};
-public:
-    // utility function implemented by all legal archives
-    virtual void set_library_version(library_version_type archive_library_version) = 0;
-    virtual library_version_type get_library_version() const = 0;
-    virtual unsigned int get_flags() const = 0;
-    virtual void delete_created_pointers() = 0;
-    virtual void reset_object_address(
-        const void * new_address,
-        const void * old_address
-    ) = 0;
-
-    virtual void load_binary(void * t, std::size_t size) = 0;
-
-    // these are used by the serialization library implementation.
-    virtual void load_object(
-        void *t,
-        const detail::basic_iserializer & bis
-    ) = 0;
-    virtual const detail::basic_pointer_iserializer * load_pointer(
-        void * & t,
-        const detail::basic_pointer_iserializer * bpis_ptr,
-        const detail::basic_pointer_iserializer * (*finder)(
-            const boost::serialization::extended_type_info & type
-        )
-    ) = 0;
-};
-
-} // namespace archive
-} // namespace boost
-
-#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
-
-namespace boost {
-namespace archive {
-
-class BOOST_SYMBOL_VISIBLE polymorphic_iarchive :
-    public polymorphic_iarchive_impl
-{
-public:
-    virtual ~polymorphic_iarchive(){};
-};
-
-} // namespace archive
-} // namespace boost
-
-// required by export
-BOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::polymorphic_iarchive)
-
-#endif // BOOST_ARCHIVE_POLYMORPHIC_IARCHIVE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/polymorphic_oarchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/polymorphic_oarchive.hpp
deleted file mode 100644
index edac4edb1e8..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/polymorphic_oarchive.hpp
+++ /dev/null
@@ -1,154 +0,0 @@
-#ifndef BOOST_ARCHIVE_POLYMORPHIC_OARCHIVE_HPP
-#define BOOST_ARCHIVE_POLYMORPHIC_OARCHIVE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// polymorphic_oarchive.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <cstddef> // size_t
-#include <climits> // ULONG_MAX 
-#include <string>
-
-#include <boost/config.hpp>
-#if defined(BOOST_NO_STDC_NAMESPACE)
-namespace std{
-    using ::size_t;
-} // namespace std
-#endif
-
-#include <boost/cstdint.hpp>
-#include <boost/archive/detail/oserializer.hpp>
-#include <boost/archive/detail/interface_oarchive.hpp>
-#include <boost/serialization/nvp.hpp>
-#include <boost/archive/detail/register_archive.hpp>
-
-#include <boost/archive/detail/decl.hpp>
-#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
-
-namespace boost {
-namespace serialization {
-    class extended_type_info;
-} // namespace serialization
-namespace archive {
-namespace detail {
-    class basic_oarchive;
-    class basic_oserializer;
-}
-
-class polymorphic_oarchive;
-
-class BOOST_SYMBOL_VISIBLE polymorphic_oarchive_impl :
-    public detail::interface_oarchive<polymorphic_oarchive>
-{
-#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
-public:
-#else
-    friend class detail::interface_oarchive<polymorphic_oarchive>;
-    friend class save_access;
-#endif
-    // primitive types the only ones permitted by polymorphic archives
-    virtual void save(const bool t) = 0;
-
-    virtual void save(const char t) = 0;
-    virtual void save(const signed char t) = 0;
-    virtual void save(const unsigned char t) = 0;
-    #ifndef BOOST_NO_CWCHAR
-    #ifndef BOOST_NO_INTRINSIC_WCHAR_T
-    virtual void save(const wchar_t t) = 0;
-    #endif
-    #endif
-    virtual void save(const short t) = 0;
-    virtual void save(const unsigned short t) = 0;
-    virtual void save(const int t) = 0;
-    virtual void save(const unsigned int t) = 0;
-    virtual void save(const long t) = 0;
-    virtual void save(const unsigned long t) = 0;
-
-    #if defined(BOOST_HAS_LONG_LONG)
-    virtual void save(const boost::long_long_type t) = 0;
-    virtual void save(const boost::ulong_long_type t) = 0;
-    #elif defined(BOOST_HAS_MS_INT64)
-    virtual void save(const __int64 t) = 0;
-    virtual void save(const unsigned __int64 t) = 0;
-    #endif
-
-    virtual void save(const float t) = 0;
-    virtual void save(const double t) = 0;
-
-    // string types are treated as primitives
-    virtual void save(const std::string & t) = 0;
-    #ifndef BOOST_NO_STD_WSTRING
-    virtual void save(const std::wstring & t) = 0;
-    #endif
-
-    virtual void save_null_pointer() = 0;
-    // used for xml and other tagged formats
-    virtual void save_start(const char * name) = 0;
-    virtual void save_end(const char * name) = 0;
-    virtual void register_basic_serializer(const detail::basic_oserializer & bos) = 0;
-    virtual detail::helper_collection & get_helper_collection() = 0;
-
-    virtual void end_preamble() = 0;
-
-    // msvc and borland won't automatically pass these to the base class so
-    // make it explicit here
-    template<class T>
-    void save_override(T & t)
-    {
-        archive::save(* this->This(), t);
-    }
-    // special treatment for name-value pairs.
-    template<class T>
-    void save_override(
-            const ::boost::serialization::nvp< T > & t
-        ){
-        save_start(t.name());
-        archive::save(* this->This(), t.const_value());
-        save_end(t.name());
-    }
-protected:
-    virtual ~polymorphic_oarchive_impl(){};
-public:
-    // utility functions implemented by all legal archives
-    virtual unsigned int get_flags() const = 0;
-    virtual library_version_type get_library_version() const = 0;
-    virtual void save_binary(const void * t, std::size_t size) = 0;
-
-    virtual void save_object(
-        const void *x,
-        const detail::basic_oserializer & bos
-    ) = 0;
-    virtual void save_pointer(
-        const void * t,
-        const detail::basic_pointer_oserializer * bpos_ptr
-    ) = 0;
-};
-
-// note: preserve naming symmetry
-class BOOST_SYMBOL_VISIBLE polymorphic_oarchive : 
-    public polymorphic_oarchive_impl
-{
-public:
-    virtual ~polymorphic_oarchive(){};
-};
-
-} // namespace archive
-} // namespace boost
-
-// required by export
-BOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::polymorphic_oarchive)
-
-#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
-
-#endif // BOOST_ARCHIVE_POLYMORPHIC_OARCHIVE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/polymorphic_text_iarchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/polymorphic_text_iarchive.hpp
deleted file mode 100644
index 7bef2927865..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/polymorphic_text_iarchive.hpp
+++ /dev/null
@@ -1,54 +0,0 @@
-#ifndef BOOST_ARCHIVE_POLYMORPHIC_TEXT_IARCHIVE_HPP
-#define BOOST_ARCHIVE_POLYMORPHIC_TEXT_IARCHIVE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// polymorphic_text_iarchive.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/config.hpp>
-#include <boost/archive/text_iarchive.hpp>
-#include <boost/archive/detail/polymorphic_iarchive_route.hpp>
-
-#ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable : 4511 4512)
-#endif
-
-namespace boost { 
-namespace archive {
-
-class polymorphic_text_iarchive : 
-    public detail::polymorphic_iarchive_route<text_iarchive>
-{
-public:
-    polymorphic_text_iarchive(std::istream & is, unsigned int flags = 0) :
-        detail::polymorphic_iarchive_route<text_iarchive>(is, flags)
-    {}
-    ~polymorphic_text_iarchive(){}
-};
-
-} // namespace archive
-} // namespace boost
-
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
-
-// required by export
-BOOST_SERIALIZATION_REGISTER_ARCHIVE(
-    boost::archive::polymorphic_text_iarchive
-)
-
-#endif // BOOST_ARCHIVE_POLYMORPHIC_TEXT_IARCHIVE_HPP
-
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/polymorphic_text_oarchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/polymorphic_text_oarchive.hpp
deleted file mode 100644
index 457aad9fd75..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/polymorphic_text_oarchive.hpp
+++ /dev/null
@@ -1,39 +0,0 @@
-#ifndef BOOST_ARCHIVE_POLYMORPHIC_TEXT_OARCHIVE_HPP
-#define BOOST_ARCHIVE_POLYMORPHIC_TEXT_OARCHIVE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// polymorphic_text_oarchive.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/config.hpp>
-#include <boost/archive/text_oarchive.hpp>
-#include <boost/archive/detail/polymorphic_oarchive_route.hpp>
-
-namespace boost { 
-namespace archive {
-
-typedef detail::polymorphic_oarchive_route<
-    text_oarchive_impl<text_oarchive> 
-> polymorphic_text_oarchive;
-
-} // namespace archive
-} // namespace boost
-
-// required by export
-BOOST_SERIALIZATION_REGISTER_ARCHIVE(
-    boost::archive::polymorphic_text_oarchive
-)
-
-#endif // BOOST_ARCHIVE_POLYMORPHIC_TEXT_OARCHIVE_HPP
-
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/polymorphic_text_wiarchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/polymorphic_text_wiarchive.hpp
deleted file mode 100644
index 8466f05d6a6..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/polymorphic_text_wiarchive.hpp
+++ /dev/null
@@ -1,59 +0,0 @@
-#ifndef BOOST_ARCHIVE_POLYMORPHIC_TEXT_WIARCHIVE_HPP
-#define BOOST_ARCHIVE_POLYMORPHIC_TEXT_WIARCHIVE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// polymorphic_text_wiarchive.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/config.hpp>
-#ifdef BOOST_NO_STD_WSTREAMBUF
-#error "wide char i/o not supported on this platform"
-#else
-
-#include <boost/archive/text_wiarchive.hpp>
-#include <boost/archive/detail/polymorphic_iarchive_route.hpp>
-
-#ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable : 4511 4512)
-#endif
-
-namespace boost { 
-namespace archive {
-
-class polymorphic_text_wiarchive : 
-    public detail::polymorphic_iarchive_route<text_wiarchive>
-{
-public:
-    polymorphic_text_wiarchive(std::wistream & is, unsigned int flags = 0) :
-        detail::polymorphic_iarchive_route<text_wiarchive>(is, flags)
-    {}
-    ~polymorphic_text_wiarchive(){}
-};
-
-} // namespace archive
-} // namespace boost
-
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
-
-// required by export
-BOOST_SERIALIZATION_REGISTER_ARCHIVE(
-    boost::archive::polymorphic_text_wiarchive
-)
-
-#endif // BOOST_NO_STD_WSTREAMBUF
-#endif // BOOST_ARCHIVE_POLYMORPHIC_TEXT_WIARCHIVE_HPP
-
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/polymorphic_text_woarchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/polymorphic_text_woarchive.hpp
deleted file mode 100644
index 295625d1bcf..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/polymorphic_text_woarchive.hpp
+++ /dev/null
@@ -1,44 +0,0 @@
-#ifndef BOOST_ARCHIVE_POLYMORPHIC_TEXT_WOARCHIVE_HPP
-#define BOOST_ARCHIVE_POLYMORPHIC_TEXT_WOARCHIVE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// polymorphic_text_oarchive.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/config.hpp>
-#ifdef BOOST_NO_STD_WSTREAMBUF
-#error "wide char i/o not supported on this platform"
-#else
-
-#include <boost/archive/text_woarchive.hpp>
-#include <boost/archive/detail/polymorphic_oarchive_route.hpp>
-
-namespace boost { 
-namespace archive {
-
-typedef detail::polymorphic_oarchive_route<
-    text_woarchive_impl<text_woarchive> 
-> polymorphic_text_woarchive;
-
-} // namespace archive
-} // namespace boost
-
-// required by export
-BOOST_SERIALIZATION_REGISTER_ARCHIVE(
-    boost::archive::polymorphic_text_woarchive
-)
-
-#endif // BOOST_NO_STD_WSTREAMBUF 
-#endif // BOOST_ARCHIVE_POLYMORPHIC_TEXT_WOARCHIVE_HPP
-
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/polymorphic_xml_iarchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/polymorphic_xml_iarchive.hpp
deleted file mode 100644
index 4dc3f894b38..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/polymorphic_xml_iarchive.hpp
+++ /dev/null
@@ -1,54 +0,0 @@
-#ifndef BOOST_ARCHIVE_POLYMORPHIC_XML_IARCHIVE_HPP
-#define BOOST_ARCHIVE_POLYMORPHIC_XML_IARCHIVE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// polymorphic_xml_iarchive.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/config.hpp>
-#include <boost/archive/xml_iarchive.hpp>
-#include <boost/archive/detail/polymorphic_iarchive_route.hpp>
-
-#ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable : 4511 4512)
-#endif
-
-namespace boost { 
-namespace archive {
-
-class polymorphic_xml_iarchive : 
-    public detail::polymorphic_iarchive_route<xml_iarchive>
-{
-public:
-    polymorphic_xml_iarchive(std::istream & is, unsigned int flags = 0) :
-        detail::polymorphic_iarchive_route<xml_iarchive>(is, flags)
-    {}
-    ~polymorphic_xml_iarchive(){}
-};
-
-} // namespace archive
-} // namespace boost
-
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
-
-// required by export
-BOOST_SERIALIZATION_REGISTER_ARCHIVE(
-    boost::archive::polymorphic_xml_iarchive
-)
-
-#endif // BOOST_ARCHIVE_POLYMORPHIC_XML_IARCHIVE_HPP
-
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/polymorphic_xml_oarchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/polymorphic_xml_oarchive.hpp
deleted file mode 100644
index 514f9e530a8..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/polymorphic_xml_oarchive.hpp
+++ /dev/null
@@ -1,39 +0,0 @@
-#ifndef BOOST_ARCHIVE_POLYMORPHIC_XML_OARCHIVE_HPP
-#define BOOST_ARCHIVE_POLYMORPHIC_XML_OARCHIVE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// polymorphic_xml_oarchive.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/config.hpp>
-#include <boost/archive/xml_oarchive.hpp>
-#include <boost/archive/detail/polymorphic_oarchive_route.hpp>
-
-namespace boost { 
-namespace archive {
-
-typedef detail::polymorphic_oarchive_route<
-    xml_oarchive_impl<xml_oarchive> 
-> polymorphic_xml_oarchive;
-
-} // namespace archive
-} // namespace boost
-
-// required by export
-BOOST_SERIALIZATION_REGISTER_ARCHIVE(
-    boost::archive::polymorphic_xml_oarchive
-)
-
-#endif // BOOST_ARCHIVE_POLYMORPHIC_XML_OARCHIVE_HPP
-
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/polymorphic_xml_wiarchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/polymorphic_xml_wiarchive.hpp
deleted file mode 100644
index d4ab731267f..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/polymorphic_xml_wiarchive.hpp
+++ /dev/null
@@ -1,50 +0,0 @@
-#ifndef BOOST_ARCHIVE_POLYMORPHIC_XML_WIARCHIVE_HPP
-#define BOOST_ARCHIVE_POLYMORPHIC_XML_WIARCHIVE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// polymorphic_xml_wiarchive.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/config.hpp>
-#ifdef BOOST_NO_STD_WSTREAMBUF
-#error "wide char i/o not supported on this platform"
-#else
-
-#include <boost/archive/xml_wiarchive.hpp>
-#include <boost/archive/detail/polymorphic_iarchive_route.hpp>
-
-namespace boost { 
-namespace archive {
-
-class polymorphic_xml_wiarchive : 
-    public detail::polymorphic_iarchive_route<xml_wiarchive>
-{
-public:
-    polymorphic_xml_wiarchive(std::wistream & is, unsigned int flags = 0) :
-        detail::polymorphic_iarchive_route<xml_wiarchive>(is, flags)
-    {}
-    ~polymorphic_xml_wiarchive(){}
-};
-
-} // namespace archive
-} // namespace boost
-
-// required by export
-BOOST_SERIALIZATION_REGISTER_ARCHIVE(
-    boost::archive::polymorphic_xml_wiarchive
-)
-
-#endif // BOOST_NO_STD_WSTREAMBUF 
-#endif // BOOST_ARCHIVE_POLYMORPHIC_XML_WIARCHIVE_HPP
-
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/polymorphic_xml_woarchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/polymorphic_xml_woarchive.hpp
deleted file mode 100644
index dd8963fbb14..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/polymorphic_xml_woarchive.hpp
+++ /dev/null
@@ -1,44 +0,0 @@
-#ifndef BOOST_ARCHIVE_POLYMORPHIC_XML_WOARCHIVE_HPP
-#define BOOST_ARCHIVE_POLYMORPHIC_XML_WOARCHIVE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// polymorphic_xml_oarchive.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/config.hpp>
-#ifdef BOOST_NO_STD_WSTREAMBUF
-#error "wide char i/o not supported on this platform"
-#else
-
-#include <boost/archive/xml_woarchive.hpp>
-#include <boost/archive/detail/polymorphic_oarchive_route.hpp>
-
-namespace boost { 
-namespace archive {
-
-typedef detail::polymorphic_oarchive_route<
-        xml_woarchive_impl<xml_woarchive> 
-> polymorphic_xml_woarchive;
-
-} // namespace archive
-} // namespace boost
-
-// required by export
-BOOST_SERIALIZATION_REGISTER_ARCHIVE(
-    boost::archive::polymorphic_xml_woarchive
-)
-
-#endif // BOOST_NO_STD_WSTREAMBUF
-#endif // BOOST_ARCHIVE_POLYMORPHIC_XML_WOARCHIVE_HPP
-
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/text_iarchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/text_iarchive.hpp
deleted file mode 100644
index d9d60adf0b8..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/text_iarchive.hpp
+++ /dev/null
@@ -1,132 +0,0 @@
-#ifndef BOOST_ARCHIVE_TEXT_IARCHIVE_HPP
-#define BOOST_ARCHIVE_TEXT_IARCHIVE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// text_iarchive.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <istream>
-
-#include <boost/config.hpp>
-#include <boost/archive/detail/auto_link_archive.hpp>
-#include <boost/archive/basic_text_iprimitive.hpp>
-#include <boost/archive/basic_text_iarchive.hpp>
-#include <boost/archive/detail/register_archive.hpp>
-#include <boost/serialization/item_version_type.hpp>
-
-#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
-
-#ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable : 4511 4512)
-#endif
-
-namespace boost { 
-namespace archive {
-
-namespace detail {
-    template<class Archive> class interface_iarchive;
-} // namespace detail
-
-template<class Archive>
-class BOOST_SYMBOL_VISIBLE text_iarchive_impl :
-    public basic_text_iprimitive<std::istream>,
-    public basic_text_iarchive<Archive>
-{
-#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
-public:
-#else
-protected:
-    friend class detail::interface_iarchive<Archive>;
-    friend class load_access;
-#endif
-    template<class T>
-    void load(T & t){
-        basic_text_iprimitive<std::istream>::load(t);
-    }
-    void load(version_type & t){
-        unsigned int v;
-        load(v);
-        t = version_type(v);
-    }
-    void load(boost::serialization::item_version_type & t){
-        unsigned int v;
-        load(v);
-        t = boost::serialization::item_version_type(v);
-    }
-    BOOST_ARCHIVE_DECL void 
-    load(char * t);
-    #ifndef BOOST_NO_INTRINSIC_WCHAR_T
-    BOOST_ARCHIVE_DECL void 
-    load(wchar_t * t);
-    #endif
-    BOOST_ARCHIVE_DECL void 
-    load(std::string &s);
-    #ifndef BOOST_NO_STD_WSTRING
-    BOOST_ARCHIVE_DECL void 
-    load(std::wstring &ws);
-    #endif
-    template<class T>
-    void load_override(T & t){
-        basic_text_iarchive<Archive>::load_override(t);
-    }
-    BOOST_ARCHIVE_DECL void
-    load_override(class_name_type & t);
-    BOOST_ARCHIVE_DECL void
-    init();
-    BOOST_ARCHIVE_DECL 
-    text_iarchive_impl(std::istream & is, unsigned int flags);
-    // don't import inline definitions! leave this as a reminder.
-    //BOOST_ARCHIVE_DECL 
-    ~text_iarchive_impl(){};
-};
-
-} // namespace archive
-} // namespace boost
-
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
-
-#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
-
-#ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable : 4511 4512)
-#endif
-
-namespace boost { 
-namespace archive {
-
-class BOOST_SYMBOL_VISIBLE text_iarchive : 
-    public text_iarchive_impl<text_iarchive>{
-public:
-    text_iarchive(std::istream & is_, unsigned int flags = 0) :
-        // note: added _ to suppress useless gcc warning
-        text_iarchive_impl<text_iarchive>(is_, flags)
-    {}
-    ~text_iarchive(){}
-};
-
-} // namespace archive
-} // namespace boost
-
-// required by export
-BOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::text_iarchive)
-
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
-
-#endif // BOOST_ARCHIVE_TEXT_IARCHIVE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/text_oarchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/text_oarchive.hpp
deleted file mode 100644
index 9ba0dafffb4..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/text_oarchive.hpp
+++ /dev/null
@@ -1,121 +0,0 @@
-#ifndef BOOST_ARCHIVE_TEXT_OARCHIVE_HPP
-#define BOOST_ARCHIVE_TEXT_OARCHIVE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// text_oarchive.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <ostream>
-#include <cstddef> // std::size_t
-
-#include <boost/config.hpp>
-#if defined(BOOST_NO_STDC_NAMESPACE)
-namespace std{ 
-    using ::size_t; 
-} // namespace std
-#endif
-
-#include <boost/archive/detail/auto_link_archive.hpp>
-#include <boost/archive/basic_text_oprimitive.hpp>
-#include <boost/archive/basic_text_oarchive.hpp>
-#include <boost/archive/detail/register_archive.hpp>
-#include <boost/serialization/item_version_type.hpp>
-
-#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
-
-#ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable : 4511 4512)
-#endif
-
-namespace boost { 
-namespace archive {
-
-namespace detail {
-    template<class Archive> class interface_oarchive;
-} // namespace detail
-
-template<class Archive>
-class BOOST_SYMBOL_VISIBLE text_oarchive_impl :
-     /* protected ? */ public basic_text_oprimitive<std::ostream>,
-     public basic_text_oarchive<Archive>
-{
-#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
-public:
-#else
-protected:
-    friend class detail::interface_oarchive<Archive>;
-    friend class basic_text_oarchive<Archive>;
-    friend class save_access;
-#endif
-    template<class T>
-    void save(const T & t){
-        this->newtoken();
-        basic_text_oprimitive<std::ostream>::save(t);
-    }
-    void save(const version_type & t){
-        save(static_cast<const unsigned int>(t));
-    }
-    void save(const boost::serialization::item_version_type & t){
-        save(static_cast<const unsigned int>(t));
-    }
-    BOOST_ARCHIVE_DECL void 
-    save(const char * t);
-    #ifndef BOOST_NO_INTRINSIC_WCHAR_T
-    BOOST_ARCHIVE_DECL void 
-    save(const wchar_t * t);
-    #endif
-    BOOST_ARCHIVE_DECL void 
-    save(const std::string &s);
-    #ifndef BOOST_NO_STD_WSTRING
-    BOOST_ARCHIVE_DECL void 
-    save(const std::wstring &ws);
-    #endif
-    BOOST_ARCHIVE_DECL 
-    text_oarchive_impl(std::ostream & os, unsigned int flags);
-    // don't import inline definitions! leave this as a reminder.
-    //BOOST_ARCHIVE_DECL 
-    ~text_oarchive_impl(){};
-public:
-    BOOST_ARCHIVE_DECL void 
-    save_binary(const void *address, std::size_t count);
-};
-
-// do not derive from this class.  If you want to extend this functionality
-// via inhertance, derived from text_oarchive_impl instead.  This will
-// preserve correct static polymorphism.
-class BOOST_SYMBOL_VISIBLE text_oarchive : 
-    public text_oarchive_impl<text_oarchive>
-{
-public:
-    text_oarchive(std::ostream & os_, unsigned int flags = 0) :
-        // note: added _ to suppress useless gcc warning
-        text_oarchive_impl<text_oarchive>(os_, flags)
-    {}
-    ~text_oarchive(){}
-};
-
-} // namespace archive
-} // namespace boost
-
-// required by export
-BOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::text_oarchive)
-
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
-
-#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
-
-#endif // BOOST_ARCHIVE_TEXT_OARCHIVE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/text_wiarchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/text_wiarchive.hpp
deleted file mode 100644
index 3adf068a51a..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/text_wiarchive.hpp
+++ /dev/null
@@ -1,137 +0,0 @@
-#ifndef BOOST_ARCHIVE_TEXT_WIARCHIVE_HPP
-#define BOOST_ARCHIVE_TEXT_WIARCHIVE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// text_wiarchive.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/config.hpp>
-#ifdef BOOST_NO_STD_WSTREAMBUF
-#error "wide char i/o not supported on this platform"
-#else
-
-#include <istream>
-
-#include <boost/archive/detail/auto_link_warchive.hpp>
-#include <boost/archive/basic_text_iprimitive.hpp>
-#include <boost/archive/basic_text_iarchive.hpp>
-#include <boost/archive/detail/register_archive.hpp>
-#include <boost/serialization/item_version_type.hpp>
-
-#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
-
-#ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable : 4511 4512)
-#endif
-
-namespace boost { 
-namespace archive {
-
-namespace detail {
-    template<class Archive> class interface_iarchive;
-} // namespace detail
-
-template<class Archive>
-class BOOST_SYMBOL_VISIBLE text_wiarchive_impl :
-    public basic_text_iprimitive<std::wistream>,
-    public basic_text_iarchive<Archive>
-{
-#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
-public:
-#else
-protected:
-    #if BOOST_WORKAROUND(BOOST_MSVC, < 1500)
-        // for some inexplicable reason insertion of "class" generates compile erro
-        // on msvc 7.1
-        friend detail::interface_iarchive<Archive>;
-        friend load_access;
-    #else
-        friend class detail::interface_iarchive<Archive>;
-        friend class load_access;
-    #endif
-#endif
-    template<class T>
-    void load(T & t){
-        basic_text_iprimitive<std::wistream>::load(t);
-    }
-    void load(version_type & t){
-        unsigned int v;
-        load(v);
-        t = version_type(v);
-    }
-    void load(boost::serialization::item_version_type & t){
-        unsigned int v;
-        load(v);
-        t = boost::serialization::item_version_type(v);
-    }
-    BOOST_WARCHIVE_DECL void
-    load(char * t);
-    #ifndef BOOST_NO_INTRINSIC_WCHAR_T
-    BOOST_WARCHIVE_DECL void
-    load(wchar_t * t);
-    #endif
-    BOOST_WARCHIVE_DECL void
-    load(std::string &s);
-    #ifndef BOOST_NO_STD_WSTRING
-    BOOST_WARCHIVE_DECL void
-    load(std::wstring &ws);
-    #endif
-    template<class T>
-    void load_override(T & t){
-        basic_text_iarchive<Archive>::load_override(t);
-    }
-    BOOST_WARCHIVE_DECL 
-    text_wiarchive_impl(std::wistream & is, unsigned int flags);
-    ~text_wiarchive_impl(){};
-};
-
-} // namespace archive
-} // namespace boost
-
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
-
-#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
-
-#ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable : 4511 4512)
-#endif
-
-namespace boost { 
-namespace archive {
-
-class BOOST_SYMBOL_VISIBLE text_wiarchive : 
-    public text_wiarchive_impl<text_wiarchive>{
-public:
-    text_wiarchive(std::wistream & is, unsigned int flags = 0) :
-        text_wiarchive_impl<text_wiarchive>(is, flags)
-    {}
-    ~text_wiarchive(){}
-};
-
-} // namespace archive
-} // namespace boost
-
-// required by export
-BOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::text_wiarchive)
-
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
-
-#endif // BOOST_NO_STD_WSTREAMBUF
-#endif // BOOST_ARCHIVE_TEXT_WIARCHIVE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/text_woarchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/text_woarchive.hpp
deleted file mode 100644
index b6b4f8ed59a..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/text_woarchive.hpp
+++ /dev/null
@@ -1,155 +0,0 @@
-#ifndef BOOST_ARCHIVE_TEXT_WOARCHIVE_HPP
-#define BOOST_ARCHIVE_TEXT_WOARCHIVE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// text_woarchive.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/config.hpp>
-
-#ifdef BOOST_NO_STD_WSTREAMBUF
-#error "wide char i/o not supported on this platform"
-#else
-
-#include <ostream>
-#include <cstddef> // size_t
-
-#if defined(BOOST_NO_STDC_NAMESPACE)
-namespace std{ 
-    using ::size_t; 
-} // namespace std
-#endif
-
-#include <boost/archive/detail/auto_link_warchive.hpp>
-#include <boost/archive/basic_text_oprimitive.hpp>
-#include <boost/archive/basic_text_oarchive.hpp>
-#include <boost/archive/detail/register_archive.hpp>
-#include <boost/serialization/item_version_type.hpp>
-
-#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
-
-#ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable : 4511 4512)
-#endif
-
-namespace boost { 
-namespace archive {
-
-namespace detail {
-    template<class Archive> class interface_oarchive;
-} // namespace detail
-
-template<class Archive>
-class BOOST_SYMBOL_VISIBLE text_woarchive_impl :
-    public basic_text_oprimitive<std::wostream>,
-    public basic_text_oarchive<Archive>
-{
-#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
-public:
-#else
-protected:
-    #if BOOST_WORKAROUND(BOOST_MSVC, < 1500)
-        // for some inexplicable reason insertion of "class" generates compile erro
-        // on msvc 7.1
-        friend detail::interface_oarchive<Archive>;
-        friend basic_text_oarchive<Archive>;
-        friend save_access;
-    #else
-        friend class detail::interface_oarchive<Archive>;
-        friend class basic_text_oarchive<Archive>;
-        friend class save_access;
-    #endif
-#endif
-    template<class T>
-    void save(const T & t){
-        this->newtoken();
-        basic_text_oprimitive<std::wostream>::save(t);
-    }
-    void save(const version_type & t){
-        save(static_cast<const unsigned int>(t));
-    }
-    void save(const boost::serialization::item_version_type & t){
-        save(static_cast<const unsigned int>(t));
-    }
-    BOOST_WARCHIVE_DECL void
-    save(const char * t);
-    #ifndef BOOST_NO_INTRINSIC_WCHAR_T
-    BOOST_WARCHIVE_DECL void
-    save(const wchar_t * t);
-    #endif
-    BOOST_WARCHIVE_DECL void
-    save(const std::string &s);
-    #ifndef BOOST_NO_STD_WSTRING
-    BOOST_WARCHIVE_DECL void
-    save(const std::wstring &ws);
-    #endif
-    text_woarchive_impl(std::wostream & os, unsigned int flags) :
-        basic_text_oprimitive<std::wostream>(
-            os, 
-            0 != (flags & no_codecvt)
-        ),
-        basic_text_oarchive<Archive>(flags)
-    {
-        if(0 == (flags & no_header))
-            basic_text_oarchive<Archive>::init();
-    }
-public:
-    void save_binary(const void *address, std::size_t count){
-        put(static_cast<wchar_t>('\n'));
-        this->end_preamble();
-        #if ! defined(__MWERKS__)
-        this->basic_text_oprimitive<std::wostream>::save_binary(
-        #else
-        this->basic_text_oprimitive::save_binary(
-        #endif
-            address, 
-            count
-        );
-        put(static_cast<wchar_t>('\n'));
-        this->delimiter = this->none;
-    }
-
-};
-
-// we use the following because we can't use
-// typedef text_oarchive_impl<text_oarchive_impl<...> > text_oarchive;
-
-// do not derive from this class.  If you want to extend this functionality
-// via inhertance, derived from text_oarchive_impl instead.  This will
-// preserve correct static polymorphism.
-class BOOST_SYMBOL_VISIBLE text_woarchive : 
-    public text_woarchive_impl<text_woarchive>
-{
-public:
-    text_woarchive(std::wostream & os, unsigned int flags = 0) :
-        text_woarchive_impl<text_woarchive>(os, flags)
-    {}
-    ~text_woarchive(){}
-};
-
-} // namespace archive
-} // namespace boost
-
-// required by export
-BOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::text_woarchive)
-
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
-
-#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
-
-#endif // BOOST_NO_STD_WSTREAMBUF
-#endif // BOOST_ARCHIVE_TEXT_WOARCHIVE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/tmpdir.hpp b/contrib/libboost/boost_1_65_0/boost/archive/tmpdir.hpp
deleted file mode 100644
index 400d23b9f68..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/tmpdir.hpp
+++ /dev/null
@@ -1,50 +0,0 @@
-#ifndef BOOST_ARCHIVE_TMPDIR_HPP
-#define BOOST_ARCHIVE_TMPDIR_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// tmpdir.hpp:
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <cstdlib> // getenv
-#include <cstddef> // NULL
-//#include <boost/assert.hpp>
-
-#include <boost/config.hpp>
-#ifdef BOOST_NO_STDC_NAMESPACE
-namespace std {
-    using ::getenv;
-}
-#endif
-
-namespace boost {
-namespace archive {
-
-inline const char * tmpdir(){
-    const char *dirname;
-    dirname = std::getenv("TMP");
-    if(NULL == dirname)
-        dirname = std::getenv("TMPDIR");
-    if(NULL == dirname)
-        dirname = std::getenv("TEMP");
-    if(NULL == dirname){
-        //BOOST_ASSERT(false); // no temp directory found
-        dirname = ".";
-    }
-    return dirname;
-}
-
-} // archive
-} // boost
-
-#endif // BOOST_ARCHIVE_TMPDIR_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/wcslen.hpp b/contrib/libboost/boost_1_65_0/boost/archive/wcslen.hpp
deleted file mode 100644
index 0b60004f095..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/wcslen.hpp
+++ /dev/null
@@ -1,58 +0,0 @@
-#ifndef BOOST_ARCHIVE_WCSLEN_HPP
-#define BOOST_ARCHIVE_WCSLEN_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// wcslen.hpp:
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <cstddef> // size_t
-#include <boost/config.hpp>
-#if defined(BOOST_NO_STDC_NAMESPACE)
-namespace std{ 
-    using ::size_t; 
-} // namespace std
-#endif
-
-#ifndef BOOST_NO_CWCHAR
-
-// a couple of libraries which include wchar_t don't include
-// wcslen
-
-#if defined(BOOST_DINKUMWARE_STDLIB) && BOOST_DINKUMWARE_STDLIB < 306 \
-|| defined(__LIBCOMO__) 
-
-namespace std {
-inline std::size_t wcslen(const wchar_t * ws)
-{
-    const wchar_t * eows = ws;
-    while(* eows != 0)
-        ++eows;
-    return eows - ws;
-}
-} // namespace std
-
-#else
-
-#ifndef BOOST_NO_CWCHAR
-#include <cwchar>
-#endif
-#ifdef BOOST_NO_STDC_NAMESPACE
-namespace std{ using ::wcslen; }
-#endif
-
-#endif // wcslen
-
-#endif //BOOST_NO_CWCHAR
-
-#endif //BOOST_ARCHIVE_WCSLEN_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/xml_archive_exception.hpp b/contrib/libboost/boost_1_65_0/boost/archive/xml_archive_exception.hpp
deleted file mode 100644
index 82c53ef5d3e..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/xml_archive_exception.hpp
+++ /dev/null
@@ -1,57 +0,0 @@
-#ifndef BOOST_ARCHIVE_XML_ARCHIVE_EXCEPTION_HPP
-#define BOOST_ARCHIVE_XML_ARCHIVE_EXCEPTION_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// xml_archive_exception.hpp:
-
-// (C) Copyright 2007 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <exception>
-#include <boost/assert.hpp>
-
-#include <boost/config.hpp> 
-#include <boost/archive/detail/decl.hpp>
-#include <boost/archive/archive_exception.hpp>
-
-#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
-
-namespace boost {
-namespace archive {
-
-//////////////////////////////////////////////////////////////////////
-// exceptions thrown by xml archives
-//
-class BOOST_SYMBOL_VISIBLE xml_archive_exception : 
-    public virtual boost::archive::archive_exception
-{
-public:
-    typedef enum {
-        xml_archive_parsing_error,    // see save_register
-        xml_archive_tag_mismatch,
-        xml_archive_tag_name_error
-    } exception_code;
-    BOOST_ARCHIVE_DECL xml_archive_exception(
-        exception_code c, 
-        const char * e1 = NULL,
-        const char * e2 = NULL
-    );
-    BOOST_ARCHIVE_DECL xml_archive_exception(xml_archive_exception const &) ;
-    virtual BOOST_ARCHIVE_DECL ~xml_archive_exception() BOOST_NOEXCEPT_OR_NOTHROW ;
-};
-
-}// namespace archive
-}// namespace boost
-
-#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
-
-#endif //BOOST_XML_ARCHIVE_ARCHIVE_EXCEPTION_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/xml_iarchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/xml_iarchive.hpp
deleted file mode 100644
index abd2f9fc4e3..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/xml_iarchive.hpp
+++ /dev/null
@@ -1,142 +0,0 @@
-#ifndef BOOST_ARCHIVE_XML_IARCHIVE_HPP
-#define BOOST_ARCHIVE_XML_IARCHIVE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// xml_iarchive.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <istream>
-
-#include <boost/scoped_ptr.hpp>
-#include <boost/archive/detail/auto_link_archive.hpp>
-#include <boost/archive/basic_text_iprimitive.hpp>
-#include <boost/archive/basic_xml_iarchive.hpp>
-#include <boost/archive/detail/register_archive.hpp>
-#include <boost/serialization/item_version_type.hpp>
-
-#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
-
-#ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable : 4511 4512)
-#endif
-
-namespace boost { 
-namespace archive {
-
-namespace detail {
-    template<class Archive> class interface_iarchive;
-} // namespace detail
-
-template<class CharType>
-class basic_xml_grammar;
-typedef basic_xml_grammar<char> xml_grammar;
-
-template<class Archive>
-class BOOST_SYMBOL_VISIBLE xml_iarchive_impl : 
-    public basic_text_iprimitive<std::istream>,
-    public basic_xml_iarchive<Archive>
-{
-#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
-public:
-#else
-protected:
-    friend class detail::interface_iarchive<Archive>;
-    friend class basic_xml_iarchive<Archive>;
-    friend class load_access;
-#endif
-    // use boost:scoped_ptr to implement automatic deletion;
-    boost::scoped_ptr<xml_grammar> gimpl;
-
-    std::istream & get_is(){
-        return is;
-    }
-    template<class T>
-    void load(T & t){
-        basic_text_iprimitive<std::istream>::load(t);
-    }
-    void 
-    load(version_type & t){
-        unsigned int v;
-        load(v);
-        t = version_type(v);
-    }
-    void 
-    load(boost::serialization::item_version_type & t){
-        unsigned int v;
-        load(v);
-        t = boost::serialization::item_version_type(v);
-    }
-    BOOST_ARCHIVE_DECL void
-    load(char * t);
-    #ifndef BOOST_NO_INTRINSIC_WCHAR_T
-    BOOST_ARCHIVE_DECL void
-    load(wchar_t * t);
-    #endif
-    BOOST_ARCHIVE_DECL void
-    load(std::string &s);
-    #ifndef BOOST_NO_STD_WSTRING
-    BOOST_ARCHIVE_DECL void
-    load(std::wstring &ws);
-    #endif
-    template<class T>
-    void load_override(T & t){
-        basic_xml_iarchive<Archive>::load_override(t);
-    }
-    BOOST_ARCHIVE_DECL void
-    load_override(class_name_type & t);
-    BOOST_ARCHIVE_DECL void
-    init();
-    BOOST_ARCHIVE_DECL 
-    xml_iarchive_impl(std::istream & is, unsigned int flags);
-    BOOST_ARCHIVE_DECL
-    ~xml_iarchive_impl();
-};
-
-} // namespace archive
-} // namespace boost
-
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
-
-#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
-#ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable : 4511 4512)
-#endif
-
-namespace boost { 
-namespace archive {
-
-class BOOST_SYMBOL_VISIBLE xml_iarchive : 
-    public xml_iarchive_impl<xml_iarchive>{
-public:
-    xml_iarchive(std::istream & is, unsigned int flags = 0) :
-        xml_iarchive_impl<xml_iarchive>(is, flags)
-    {}
-    ~xml_iarchive(){};
-};
-
-} // namespace archive
-} // namespace boost
-
-// required by export
-BOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::xml_iarchive)
-
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
-
-#endif // BOOST_ARCHIVE_XML_IARCHIVE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/xml_oarchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/xml_oarchive.hpp
deleted file mode 100644
index eea12680372..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/xml_oarchive.hpp
+++ /dev/null
@@ -1,137 +0,0 @@
-#ifndef BOOST_ARCHIVE_XML_OARCHIVE_HPP
-#define BOOST_ARCHIVE_XML_OARCHIVE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// xml_oarchive.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <ostream>
-
-#include <cstddef> // size_t
-#include <boost/config.hpp>
-#if defined(BOOST_NO_STDC_NAMESPACE)
-namespace std{ 
-    using ::size_t; 
-} // namespace std
-#endif
-
-#include <boost/archive/detail/auto_link_archive.hpp>
-#include <boost/archive/basic_text_oprimitive.hpp>
-#include <boost/archive/basic_xml_oarchive.hpp>
-#include <boost/archive/detail/register_archive.hpp>
-#include <boost/serialization/item_version_type.hpp>
-
-#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
-
-#ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable : 4511 4512)
-#endif
-
-namespace boost {
-namespace archive {
-
-namespace detail {
-    template<class Archive> class interface_oarchive;
-} // namespace detail
-
-template<class Archive>
-class BOOST_SYMBOL_VISIBLE xml_oarchive_impl : 
-    public basic_text_oprimitive<std::ostream>,
-    public basic_xml_oarchive<Archive>
-{
-#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
-public:
-#else
-protected:
-    friend class detail::interface_oarchive<Archive>;
-    friend class basic_xml_oarchive<Archive>;
-    friend class save_access;
-#endif
-    template<class T>
-    void save(const T & t){
-        basic_text_oprimitive<std::ostream>::save(t);
-    }
-    void 
-    save(const version_type & t){
-        save(static_cast<const unsigned int>(t));
-    }
-    void 
-    save(const boost::serialization::item_version_type & t){
-        save(static_cast<const unsigned int>(t));
-    }
-    BOOST_ARCHIVE_DECL void 
-    save(const char * t);
-    #ifndef BOOST_NO_INTRINSIC_WCHAR_T
-    BOOST_ARCHIVE_DECL void
-    save(const wchar_t * t);
-    #endif
-    BOOST_ARCHIVE_DECL void
-    save(const std::string &s);
-    #ifndef BOOST_NO_STD_WSTRING
-    BOOST_ARCHIVE_DECL void
-    save(const std::wstring &ws);
-    #endif
-    BOOST_ARCHIVE_DECL 
-    xml_oarchive_impl(std::ostream & os, unsigned int flags);
-    BOOST_ARCHIVE_DECL 
-    ~xml_oarchive_impl();
-public:
-    BOOST_ARCHIVE_DECL
-    void save_binary(const void *address, std::size_t count);
-};
-
-} // namespace archive
-} // namespace boost
-
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
-
-#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
-#ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable : 4511 4512)
-#endif
-
-namespace boost { 
-namespace archive {
-
-// we use the following because we can't use
-// typedef xml_oarchive_impl<xml_oarchive_impl<...> > xml_oarchive;
-
-// do not derive from this class.  If you want to extend this functionality
-// via inhertance, derived from xml_oarchive_impl instead.  This will
-// preserve correct static polymorphism.
-class BOOST_SYMBOL_VISIBLE xml_oarchive : 
-    public xml_oarchive_impl<xml_oarchive>
-{
-public:
-    xml_oarchive(std::ostream & os, unsigned int flags = 0) :
-        xml_oarchive_impl<xml_oarchive>(os, flags)
-    {}
-    ~xml_oarchive(){}
-};
-
-} // namespace archive
-} // namespace boost
-
-// required by export
-BOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::xml_oarchive)
-
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
-
-#endif // BOOST_ARCHIVE_XML_OARCHIVE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/xml_wiarchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/xml_wiarchive.hpp
deleted file mode 100644
index ac24289ac11..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/xml_wiarchive.hpp
+++ /dev/null
@@ -1,149 +0,0 @@
-#ifndef BOOST_ARCHIVE_XML_WIARCHIVE_HPP
-#define BOOST_ARCHIVE_XML_WIARCHIVE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// xml_wiarchive.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/config.hpp>
-#ifdef BOOST_NO_STD_WSTREAMBUF
-#error "wide char i/o not supported on this platform"
-#else
-
-#include <istream>
-
-#include <boost/smart_ptr/scoped_ptr.hpp>
-#include <boost/archive/detail/auto_link_warchive.hpp>
-#include <boost/archive/basic_text_iprimitive.hpp>
-#include <boost/archive/basic_xml_iarchive.hpp>
-#include <boost/archive/detail/register_archive.hpp>
-#include <boost/serialization/item_version_type.hpp>
-// #include <boost/archive/detail/utf8_codecvt_facet.hpp>
-
-#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
-
-#ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable : 4511 4512)
-#endif
-
-namespace boost {
-namespace archive {
-
-namespace detail {
-    template<class Archive> class interface_iarchive;
-} // namespace detail
-
-template<class CharType>
-class basic_xml_grammar;
-typedef basic_xml_grammar<wchar_t> xml_wgrammar;
-
-template<class Archive>
-class BOOST_SYMBOL_VISIBLE xml_wiarchive_impl : 
-    public basic_text_iprimitive<std::wistream>,
-    public basic_xml_iarchive<Archive>
-{
-#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
-public:
-#else
-protected:
-    friend class detail::interface_iarchive<Archive>;
-    friend class basic_xml_iarchive<Archive>;
-    friend class load_access;
-#endif
-    boost::scoped_ptr<xml_wgrammar> gimpl;
-    std::wistream & get_is(){
-        return is;
-    }
-    template<class T>
-    void 
-    load(T & t){
-        basic_text_iprimitive<std::wistream>::load(t);
-    }
-    void 
-    load(version_type & t){
-        unsigned int v;
-        load(v);
-        t = version_type(v);
-    }
-    void 
-    load(boost::serialization::item_version_type & t){
-        unsigned int v;
-        load(v);
-        t = boost::serialization::item_version_type(v);
-    }
-    BOOST_WARCHIVE_DECL void
-    load(char * t);
-    #ifndef BOOST_NO_INTRINSIC_WCHAR_T
-    BOOST_WARCHIVE_DECL void
-    load(wchar_t * t);
-    #endif
-    BOOST_WARCHIVE_DECL void
-    load(std::string &s);
-    #ifndef BOOST_NO_STD_WSTRING
-    BOOST_WARCHIVE_DECL void
-    load(std::wstring &ws);
-    #endif
-    template<class T>
-    void load_override(T & t){
-        basic_xml_iarchive<Archive>::load_override(t);
-    }
-    BOOST_WARCHIVE_DECL void
-    load_override(class_name_type & t);
-    BOOST_WARCHIVE_DECL void 
-    init();
-    BOOST_WARCHIVE_DECL 
-    xml_wiarchive_impl(std::wistream & is, unsigned int flags) ;
-    BOOST_WARCHIVE_DECL 
-    ~xml_wiarchive_impl();
-};
-
-} // namespace archive
-} // namespace boost
-
-#ifdef BOOST_MSVC
-#  pragma warning(pop) 
-#endif
-
-#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
-
-#ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable : 4511 4512)
-#endif
-
-namespace boost { 
-namespace archive {
-
-class BOOST_SYMBOL_VISIBLE xml_wiarchive :
-    public xml_wiarchive_impl<xml_wiarchive>{
-public:
-    xml_wiarchive(std::wistream & is, unsigned int flags = 0) :
-        xml_wiarchive_impl<xml_wiarchive>(is, flags)
-    {}
-    ~xml_wiarchive(){}
-};
-
-} // namespace archive
-} // namespace boost
-
-// required by export
-BOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::xml_wiarchive)
-
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
-
-#endif // BOOST_NO_STD_WSTREAMBUF
-#endif // BOOST_ARCHIVE_XML_WIARCHIVE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/xml_woarchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/xml_woarchive.hpp
deleted file mode 100644
index cb7ce68cb6f..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/xml_woarchive.hpp
+++ /dev/null
@@ -1,134 +0,0 @@
-#ifndef BOOST_ARCHIVE_XML_WOARCHIVE_HPP
-#define BOOST_ARCHIVE_XML_WOARCHIVE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// xml_woarchive.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/config.hpp>
-#ifdef BOOST_NO_STD_WSTREAMBUF
-#error "wide char i/o not supported on this platform"
-#else
-#include <cstddef> // size_t
-#if defined(BOOST_NO_STDC_NAMESPACE)
-namespace std{ 
-    using ::size_t; 
-} // namespace std
-#endif
-
-#include <ostream>
-
-//#include <boost/smart_ptr/scoped_ptr.hpp>
-#include <boost/archive/detail/auto_link_warchive.hpp>
-#include <boost/archive/basic_text_oprimitive.hpp>
-#include <boost/archive/basic_xml_oarchive.hpp>
-#include <boost/archive/detail/register_archive.hpp>
-#include <boost/serialization/item_version_type.hpp>
-//#include <boost/archive/detail/utf8_codecvt_facet.hpp>
-
-#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
-
-#ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable : 4511 4512)
-#endif
-
-namespace boost {
-namespace archive {
-
-namespace detail {
-    template<class Archive> class interface_oarchive;
-} // namespace detail
-
-template<class Archive>
-class BOOST_SYMBOL_VISIBLE xml_woarchive_impl :
-    public basic_text_oprimitive<std::wostream>,
-    public basic_xml_oarchive<Archive>
-{
-#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
-public:
-#else
-protected:
-    friend class detail::interface_oarchive<Archive>;
-    friend class basic_xml_oarchive<Archive>;
-    friend class save_access;
-#endif
-    //void end_preamble(){
-    //    basic_xml_oarchive<Archive>::end_preamble();
-    //}
-    template<class T>
-    void
-    save(const T & t){
-        basic_text_oprimitive<std::wostream>::save(t);
-    }
-    void
-    save(const version_type & t){
-        save(static_cast<const unsigned int>(t));
-    }
-    void 
-    save(const boost::serialization::item_version_type & t){
-        save(static_cast<const unsigned int>(t));
-    }
-    BOOST_WARCHIVE_DECL void
-    save(const char * t);
-    #ifndef BOOST_NO_INTRINSIC_WCHAR_T
-    BOOST_WARCHIVE_DECL void 
-    save(const wchar_t * t);
-    #endif
-    BOOST_WARCHIVE_DECL void 
-    save(const std::string &s);
-    #ifndef BOOST_NO_STD_WSTRING
-    BOOST_WARCHIVE_DECL void
-    save(const std::wstring &ws);
-    #endif
-    BOOST_WARCHIVE_DECL 
-    xml_woarchive_impl(std::wostream & os, unsigned int flags);
-    BOOST_WARCHIVE_DECL
-    ~xml_woarchive_impl();
-public:
-    BOOST_WARCHIVE_DECL void
-    save_binary(const void *address, std::size_t count);
-
-};
-
-// we use the following because we can't use
-// typedef xml_woarchive_impl<xml_woarchive_impl<...> > xml_woarchive;
-
-// do not derive from this class.  If you want to extend this functionality
-// via inhertance, derived from xml_woarchive_impl instead.  This will
-// preserve correct static polymorphism.
-class BOOST_SYMBOL_VISIBLE xml_woarchive :
-    public xml_woarchive_impl<xml_woarchive>
-{
-public:
-    xml_woarchive(std::wostream & os, unsigned int flags = 0) :
-        xml_woarchive_impl<xml_woarchive>(os, flags)
-    {}
-    ~xml_woarchive(){}
-};
-
-} // namespace archive
-} // namespace boost
-
-// required by export
-BOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::xml_woarchive)
-
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
-
-#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
-
-#endif // BOOST_NO_STD_WSTREAMBUF
-#endif // BOOST_ARCHIVE_XML_OARCHIVE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/foreach_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/foreach_fwd.hpp
deleted file mode 100644
index 4e0bb370c2f..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/foreach_fwd.hpp
+++ /dev/null
@@ -1,51 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-// foreach.hpp header file
-//
-// Copyright 2010 Eric Niebler.
-// Distributed under the Boost Software License, Version 1.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/foreach for documentation
-//
-// Credits:
-// Kazutoshi Satoda: for suggesting the need for a _fwd header for foreach's
-//                      customization points.
-
-#ifndef BOOST_FOREACH_FWD_HPP
-#define BOOST_FOREACH_FWD_HPP
-
-// This must be at global scope, hence the uglified name
-enum boost_foreach_argument_dependent_lookup_hack
-{
-    boost_foreach_argument_dependent_lookup_hack_value
-};
-
-namespace boost
-{
-
-namespace foreach
-{
-    ///////////////////////////////////////////////////////////////////////////////
-    // boost::foreach::tag
-    //
-    typedef boost_foreach_argument_dependent_lookup_hack tag;
-
-    ///////////////////////////////////////////////////////////////////////////////
-    // boost::foreach::is_lightweight_proxy
-    //   Specialize this for user-defined collection types if they are inexpensive to copy.
-    //   This tells BOOST_FOREACH it can avoid the rvalue/lvalue detection stuff.
-    template<typename T>
-    struct is_lightweight_proxy;
-
-    ///////////////////////////////////////////////////////////////////////////////
-    // boost::foreach::is_noncopyable
-    //   Specialize this for user-defined collection types if they cannot be copied.
-    //   This also tells BOOST_FOREACH to avoid the rvalue/lvalue detection stuff.
-    template<typename T>
-    struct is_noncopyable;
-
-} // namespace foreach
-
-} // namespace boost
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/composite_key.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/composite_key.hpp
deleted file mode 100644
index 787cdf83195..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/composite_key.hpp
+++ /dev/null
@@ -1,1513 +0,0 @@
-/* Copyright 2003-2015 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_COMPOSITE_KEY_HPP
-#define BOOST_MULTI_INDEX_COMPOSITE_KEY_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <boost/functional/hash_fwd.hpp>
-#include <boost/multi_index/detail/access_specifier.hpp>
-#include <boost/mpl/eval_if.hpp>
-#include <boost/mpl/identity.hpp>
-#include <boost/mpl/if.hpp>
-#include <boost/mpl/or.hpp>
-#include <boost/preprocessor/cat.hpp>
-#include <boost/preprocessor/control/expr_if.hpp>
-#include <boost/preprocessor/list/at.hpp>
-#include <boost/preprocessor/repetition/enum.hpp>
-#include <boost/preprocessor/repetition/enum_params.hpp> 
-#include <boost/static_assert.hpp>
-#include <boost/tuple/tuple.hpp>
-#include <boost/type_traits/is_same.hpp>
-#include <boost/utility/enable_if.hpp>
-#include <functional>
-
-#if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
-#include <boost/ref.hpp>
-#endif
-
-#if !defined(BOOST_NO_SFINAE)
-#include <boost/type_traits/is_convertible.hpp>
-#endif
-
-#if !defined(BOOST_NO_CXX11_HDR_TUPLE)&&\
-    !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-#include <boost/multi_index/detail/cons_stdtuple.hpp>
-#endif
-
-/* A composite key stores n key extractors and "computes" the
- * result on a given value as a packed reference to the value and
- * the composite key itself. Actual invocations to the component
- * key extractors are lazily performed when executing an operation
- * on composite_key results (equality, comparison, hashing.)
- * As the other key extractors in Boost.MultiIndex, composite_key<T,...>
- * is  overloaded to work on chained pointers to T and reference_wrappers
- * of T.
- */
-
-/* This user_definable macro limits the number of elements of a composite
- * key; useful for shortening resulting symbol names (MSVC++ 6.0, for
- * instance has problems coping with very long symbol names.)
- * NB: This cannot exceed the maximum number of arguments of
- * boost::tuple. In Boost 1.32, the limit is 10.
- */
-
-#if !defined(BOOST_MULTI_INDEX_LIMIT_COMPOSITE_KEY_SIZE)
-#define BOOST_MULTI_INDEX_LIMIT_COMPOSITE_KEY_SIZE 10
-#endif
-
-/* maximum number of key extractors in a composite key */
-
-#if BOOST_MULTI_INDEX_LIMIT_COMPOSITE_KEY_SIZE<10 /* max length of a tuple */
-#define BOOST_MULTI_INDEX_COMPOSITE_KEY_SIZE \
-  BOOST_MULTI_INDEX_LIMIT_COMPOSITE_KEY_SIZE
-#else
-#define BOOST_MULTI_INDEX_COMPOSITE_KEY_SIZE 10
-#endif
-
-/* BOOST_PP_ENUM of BOOST_MULTI_INDEX_COMPOSITE_KEY_SIZE elements */
-
-#define BOOST_MULTI_INDEX_CK_ENUM(macro,data)                                \
-  BOOST_PP_ENUM(BOOST_MULTI_INDEX_COMPOSITE_KEY_SIZE,macro,data)
-
-/* BOOST_PP_ENUM_PARAMS of BOOST_MULTI_INDEX_COMPOSITE_KEY_SIZE elements */
-
-#define BOOST_MULTI_INDEX_CK_ENUM_PARAMS(param)                              \
-  BOOST_PP_ENUM_PARAMS(BOOST_MULTI_INDEX_COMPOSITE_KEY_SIZE,param)
-
-/* if n==0 ->   text0
- * otherwise -> textn=tuples::null_type
- */
-
-#define BOOST_MULTI_INDEX_CK_TEMPLATE_PARM(z,n,text)                         \
-  typename BOOST_PP_CAT(text,n) BOOST_PP_EXPR_IF(n,=tuples::null_type)
-
-/* const textn& kn=textn() */
-
-#define BOOST_MULTI_INDEX_CK_CTOR_ARG(z,n,text)                              \
-  const BOOST_PP_CAT(text,n)& BOOST_PP_CAT(k,n) = BOOST_PP_CAT(text,n)()
-
-/* typename list(0)<list(1),n>::type */
-
-#define BOOST_MULTI_INDEX_CK_APPLY_METAFUNCTION_N(z,n,list)                  \
-  BOOST_DEDUCED_TYPENAME BOOST_PP_LIST_AT(list,0)<                           \
-    BOOST_PP_LIST_AT(list,1),n                                               \
-  >::type
-
-namespace boost{
-
-template<class T> class reference_wrapper; /* fwd decl. */
-
-namespace multi_index{
-
-namespace detail{
-
-/* n-th key extractor of a composite key */
-
-template<typename CompositeKey,int N>
-struct nth_key_from_value
-{
-  typedef typename CompositeKey::key_extractor_tuple key_extractor_tuple;
-  typedef typename mpl::eval_if_c<
-    N<tuples::length<key_extractor_tuple>::value,
-    tuples::element<N,key_extractor_tuple>,
-    mpl::identity<tuples::null_type>
-  >::type                                            type;
-};
-
-/* nth_composite_key_##name<CompositeKey,N>::type yields
- * functor<nth_key_from_value<CompositeKey,N> >, or tuples::null_type
- * if N exceeds the length of the composite key.
- */
-
-#define BOOST_MULTI_INDEX_CK_NTH_COMPOSITE_KEY_FUNCTOR(name,functor)         \
-template<typename KeyFromValue>                                              \
-struct BOOST_PP_CAT(key_,name)                                               \
-{                                                                            \
-  typedef functor<typename KeyFromValue::result_type> type;                  \
-};                                                                           \
-                                                                             \
-template<>                                                                   \
-struct BOOST_PP_CAT(key_,name)<tuples::null_type>                            \
-{                                                                            \
-  typedef tuples::null_type type;                                            \
-};                                                                           \
-                                                                             \
-template<typename CompositeKey,int  N>                                       \
-struct BOOST_PP_CAT(nth_composite_key_,name)                                 \
-{                                                                            \
-  typedef typename nth_key_from_value<CompositeKey,N>::type key_from_value;  \
-  typedef typename BOOST_PP_CAT(key_,name)<key_from_value>::type type;       \
-};
-
-/* nth_composite_key_equal_to
- * nth_composite_key_less
- * nth_composite_key_greater
- * nth_composite_key_hash
- */
-
-BOOST_MULTI_INDEX_CK_NTH_COMPOSITE_KEY_FUNCTOR(equal_to,std::equal_to)
-BOOST_MULTI_INDEX_CK_NTH_COMPOSITE_KEY_FUNCTOR(less,std::less)
-BOOST_MULTI_INDEX_CK_NTH_COMPOSITE_KEY_FUNCTOR(greater,std::greater)
-BOOST_MULTI_INDEX_CK_NTH_COMPOSITE_KEY_FUNCTOR(hash,boost::hash)
-
-/* used for defining equality and comparison ops of composite_key_result */
-
-#define BOOST_MULTI_INDEX_CK_IDENTITY_ENUM_MACRO(z,n,text) text
-
-struct generic_operator_equal
-{
-  template<typename T,typename Q>
-  bool operator()(const T& x,const Q& y)const{return x==y;}
-};
-
-typedef tuple<
-  BOOST_MULTI_INDEX_CK_ENUM(
-    BOOST_MULTI_INDEX_CK_IDENTITY_ENUM_MACRO,
-    detail::generic_operator_equal)>          generic_operator_equal_tuple;
-
-struct generic_operator_less
-{
-  template<typename T,typename Q>
-  bool operator()(const T& x,const Q& y)const{return x<y;}
-};
-
-typedef tuple<
-  BOOST_MULTI_INDEX_CK_ENUM(
-    BOOST_MULTI_INDEX_CK_IDENTITY_ENUM_MACRO,
-    detail::generic_operator_less)>           generic_operator_less_tuple;
-
-/* Metaprogramming machinery for implementing equality, comparison and
- * hashing operations of composite_key_result.
- *
- * equal_* checks for equality between composite_key_results and
- * between those and tuples, accepting a tuple of basic equality functors.
- * compare_* does lexicographical comparison.
- * hash_* computes a combination of elementwise hash values.
- */
-
-template
-<
-  typename KeyCons1,typename Value1,
-  typename KeyCons2, typename Value2,
-  typename EqualCons
->
-struct equal_ckey_ckey; /* fwd decl. */
-
-template
-<
-  typename KeyCons1,typename Value1,
-  typename KeyCons2, typename Value2,
-  typename EqualCons
->
-struct equal_ckey_ckey_terminal
-{
-  static bool compare(
-    const KeyCons1&,const Value1&,
-    const KeyCons2&,const Value2&,
-    const EqualCons&)
-  {
-    return true;
-  }
-};
-
-template
-<
-  typename KeyCons1,typename Value1,
-  typename KeyCons2, typename Value2,
-  typename EqualCons
->
-struct equal_ckey_ckey_normal
-{
-  static bool compare(
-    const KeyCons1& c0,const Value1& v0,
-    const KeyCons2& c1,const Value2& v1,
-    const EqualCons& eq)
-  {
-    if(!eq.get_head()(c0.get_head()(v0),c1.get_head()(v1)))return false;
-    return equal_ckey_ckey<
-      BOOST_DEDUCED_TYPENAME KeyCons1::tail_type,Value1,
-      BOOST_DEDUCED_TYPENAME KeyCons2::tail_type,Value2,
-      BOOST_DEDUCED_TYPENAME EqualCons::tail_type
-    >::compare(c0.get_tail(),v0,c1.get_tail(),v1,eq.get_tail());
-  }
-};
-
-template
-<
-  typename KeyCons1,typename Value1,
-  typename KeyCons2, typename Value2,
-  typename EqualCons
->
-struct equal_ckey_ckey:
-  mpl::if_<
-    mpl::or_<
-      is_same<KeyCons1,tuples::null_type>,
-      is_same<KeyCons2,tuples::null_type>
-    >,
-    equal_ckey_ckey_terminal<KeyCons1,Value1,KeyCons2,Value2,EqualCons>,
-    equal_ckey_ckey_normal<KeyCons1,Value1,KeyCons2,Value2,EqualCons>
-  >::type
-{
-};
-
-template
-<
-  typename KeyCons,typename Value,
-  typename ValCons,typename EqualCons
->
-struct equal_ckey_cval; /* fwd decl. */
-
-template
-<
-  typename KeyCons,typename Value,
-  typename ValCons,typename EqualCons
->
-struct equal_ckey_cval_terminal
-{
-  static bool compare(
-    const KeyCons&,const Value&,const ValCons&,const EqualCons&)
-  {
-    return true;
-  }
-
-  static bool compare(
-    const ValCons&,const KeyCons&,const Value&,const EqualCons&)
-  {
-    return true;
-  }
-};
-
-template
-<
-  typename KeyCons,typename Value,
-  typename ValCons,typename EqualCons
->
-struct equal_ckey_cval_normal
-{
-  static bool compare(
-    const KeyCons& c,const Value& v,const ValCons& vc,
-    const EqualCons& eq)
-  {
-    if(!eq.get_head()(c.get_head()(v),vc.get_head()))return false;
-    return equal_ckey_cval<
-      BOOST_DEDUCED_TYPENAME KeyCons::tail_type,Value,
-      BOOST_DEDUCED_TYPENAME ValCons::tail_type,
-      BOOST_DEDUCED_TYPENAME EqualCons::tail_type
-    >::compare(c.get_tail(),v,vc.get_tail(),eq.get_tail());
-  }
-
-  static bool compare(
-    const ValCons& vc,const KeyCons& c,const Value& v,
-    const EqualCons& eq)
-  {
-    if(!eq.get_head()(vc.get_head(),c.get_head()(v)))return false;
-    return equal_ckey_cval<
-      BOOST_DEDUCED_TYPENAME KeyCons::tail_type,Value,
-      BOOST_DEDUCED_TYPENAME ValCons::tail_type,
-      BOOST_DEDUCED_TYPENAME EqualCons::tail_type
-    >::compare(vc.get_tail(),c.get_tail(),v,eq.get_tail());
-  }
-};
-
-template
-<
-  typename KeyCons,typename Value,
-  typename ValCons,typename EqualCons
->
-struct equal_ckey_cval:
-  mpl::if_<
-    mpl::or_<
-      is_same<KeyCons,tuples::null_type>,
-      is_same<ValCons,tuples::null_type>
-    >,
-    equal_ckey_cval_terminal<KeyCons,Value,ValCons,EqualCons>,
-    equal_ckey_cval_normal<KeyCons,Value,ValCons,EqualCons>
-  >::type
-{
-};
-
-template
-<
-  typename KeyCons1,typename Value1,
-  typename KeyCons2, typename Value2,
-  typename CompareCons
->
-struct compare_ckey_ckey; /* fwd decl. */
-
-template
-<
-  typename KeyCons1,typename Value1,
-  typename KeyCons2, typename Value2,
-  typename CompareCons
->
-struct compare_ckey_ckey_terminal
-{
-  static bool compare(
-    const KeyCons1&,const Value1&,
-    const KeyCons2&,const Value2&,
-    const CompareCons&)
-  {
-    return false;
-  }
-};
-
-template
-<
-  typename KeyCons1,typename Value1,
-  typename KeyCons2, typename Value2,
-  typename CompareCons
->
-struct compare_ckey_ckey_normal
-{
-  static bool compare(
-    const KeyCons1& c0,const Value1& v0,
-    const KeyCons2& c1,const Value2& v1,
-    const CompareCons& comp)
-  {
-    if(comp.get_head()(c0.get_head()(v0),c1.get_head()(v1)))return true;
-    if(comp.get_head()(c1.get_head()(v1),c0.get_head()(v0)))return false;
-    return compare_ckey_ckey<
-      BOOST_DEDUCED_TYPENAME KeyCons1::tail_type,Value1,
-      BOOST_DEDUCED_TYPENAME KeyCons2::tail_type,Value2,
-      BOOST_DEDUCED_TYPENAME CompareCons::tail_type
-    >::compare(c0.get_tail(),v0,c1.get_tail(),v1,comp.get_tail());
-  }
-};
-
-template
-<
-  typename KeyCons1,typename Value1,
-  typename KeyCons2, typename Value2,
-  typename CompareCons
->
-struct compare_ckey_ckey:
-  mpl::if_<
-    mpl::or_<
-      is_same<KeyCons1,tuples::null_type>,
-      is_same<KeyCons2,tuples::null_type>
-    >,
-    compare_ckey_ckey_terminal<KeyCons1,Value1,KeyCons2,Value2,CompareCons>,
-    compare_ckey_ckey_normal<KeyCons1,Value1,KeyCons2,Value2,CompareCons>
-  >::type
-{
-};
-
-template
-<
-  typename KeyCons,typename Value,
-  typename ValCons,typename CompareCons
->
-struct compare_ckey_cval; /* fwd decl. */
-
-template
-<
-  typename KeyCons,typename Value,
-  typename ValCons,typename CompareCons
->
-struct compare_ckey_cval_terminal
-{
-  static bool compare(
-    const KeyCons&,const Value&,const ValCons&,const CompareCons&)
-  {
-    return false;
-  }
-
-  static bool compare(
-    const ValCons&,const KeyCons&,const Value&,const CompareCons&)
-  {
-    return false;
-  }
-};
-
-template
-<
-  typename KeyCons,typename Value,
-  typename ValCons,typename CompareCons
->
-struct compare_ckey_cval_normal
-{
-  static bool compare(
-    const KeyCons& c,const Value& v,const ValCons& vc,
-    const CompareCons& comp)
-  {
-    if(comp.get_head()(c.get_head()(v),vc.get_head()))return true;
-    if(comp.get_head()(vc.get_head(),c.get_head()(v)))return false;
-    return compare_ckey_cval<
-      BOOST_DEDUCED_TYPENAME KeyCons::tail_type,Value,
-      BOOST_DEDUCED_TYPENAME ValCons::tail_type,
-      BOOST_DEDUCED_TYPENAME CompareCons::tail_type
-    >::compare(c.get_tail(),v,vc.get_tail(),comp.get_tail());
-  }
-
-  static bool compare(
-    const ValCons& vc,const KeyCons& c,const Value& v,
-    const CompareCons& comp)
-  {
-    if(comp.get_head()(vc.get_head(),c.get_head()(v)))return true;
-    if(comp.get_head()(c.get_head()(v),vc.get_head()))return false;
-    return compare_ckey_cval<
-      BOOST_DEDUCED_TYPENAME KeyCons::tail_type,Value,
-      BOOST_DEDUCED_TYPENAME ValCons::tail_type,
-      BOOST_DEDUCED_TYPENAME CompareCons::tail_type
-    >::compare(vc.get_tail(),c.get_tail(),v,comp.get_tail());
-  }
-};
-
-template
-<
-  typename KeyCons,typename Value,
-  typename ValCons,typename CompareCons
->
-struct compare_ckey_cval:
-  mpl::if_<
-    mpl::or_<
-      is_same<KeyCons,tuples::null_type>,
-      is_same<ValCons,tuples::null_type>
-    >,
-    compare_ckey_cval_terminal<KeyCons,Value,ValCons,CompareCons>,
-    compare_ckey_cval_normal<KeyCons,Value,ValCons,CompareCons>
-  >::type
-{
-};
-
-template<typename KeyCons,typename Value,typename HashCons>
-struct hash_ckey; /* fwd decl. */
-
-template<typename KeyCons,typename Value,typename HashCons>
-struct hash_ckey_terminal
-{
-  static std::size_t hash(
-    const KeyCons&,const Value&,const HashCons&,std::size_t carry)
-  {
-    return carry;
-  }
-};
-
-template<typename KeyCons,typename Value,typename HashCons>
-struct hash_ckey_normal
-{
-  static std::size_t hash(
-    const KeyCons& c,const Value& v,const HashCons& h,std::size_t carry=0)
-  {
-    /* same hashing formula as boost::hash_combine */
-
-    carry^=h.get_head()(c.get_head()(v))+0x9e3779b9+(carry<<6)+(carry>>2);
-    return hash_ckey<
-      BOOST_DEDUCED_TYPENAME KeyCons::tail_type,Value,
-      BOOST_DEDUCED_TYPENAME HashCons::tail_type
-    >::hash(c.get_tail(),v,h.get_tail(),carry);
-  }
-};
-
-template<typename KeyCons,typename Value,typename HashCons>
-struct hash_ckey:
-  mpl::if_<
-    is_same<KeyCons,tuples::null_type>,
-    hash_ckey_terminal<KeyCons,Value,HashCons>,
-    hash_ckey_normal<KeyCons,Value,HashCons>
-  >::type
-{
-};
-
-template<typename ValCons,typename HashCons>
-struct hash_cval; /* fwd decl. */
-
-template<typename ValCons,typename HashCons>
-struct hash_cval_terminal
-{
-  static std::size_t hash(const ValCons&,const HashCons&,std::size_t carry)
-  {
-    return carry;
-  }
-};
-
-template<typename ValCons,typename HashCons>
-struct hash_cval_normal
-{
-  static std::size_t hash(
-    const ValCons& vc,const HashCons& h,std::size_t carry=0)
-  {
-    carry^=h.get_head()(vc.get_head())+0x9e3779b9+(carry<<6)+(carry>>2);
-    return hash_cval<
-      BOOST_DEDUCED_TYPENAME ValCons::tail_type,
-      BOOST_DEDUCED_TYPENAME HashCons::tail_type
-    >::hash(vc.get_tail(),h.get_tail(),carry);
-  }
-};
-
-template<typename ValCons,typename HashCons>
-struct hash_cval:
-  mpl::if_<
-    is_same<ValCons,tuples::null_type>,
-    hash_cval_terminal<ValCons,HashCons>,
-    hash_cval_normal<ValCons,HashCons>
-  >::type
-{
-};
-
-} /* namespace multi_index::detail */
-
-/* composite_key_result */
-
-#if defined(BOOST_MSVC)
-#pragma warning(push)
-#pragma warning(disable:4512)
-#endif
-
-template<typename CompositeKey>
-struct composite_key_result
-{
-  typedef CompositeKey                            composite_key_type;
-  typedef typename composite_key_type::value_type value_type;
-
-  composite_key_result(
-    const composite_key_type& composite_key_,const value_type& value_):
-    composite_key(composite_key_),value(value_)
-  {}
-
-  const composite_key_type& composite_key;
-  const value_type&         value;
-};
-
-#if defined(BOOST_MSVC)
-#pragma warning(pop)
-#endif
-
-/* composite_key */
-
-template<
-  typename Value,
-  BOOST_MULTI_INDEX_CK_ENUM(BOOST_MULTI_INDEX_CK_TEMPLATE_PARM,KeyFromValue)
->
-struct composite_key:
-  private tuple<BOOST_MULTI_INDEX_CK_ENUM_PARAMS(KeyFromValue)>
-{
-private:
-  typedef tuple<BOOST_MULTI_INDEX_CK_ENUM_PARAMS(KeyFromValue)> super;
-
-public:
-  typedef super                               key_extractor_tuple;
-  typedef Value                               value_type;
-  typedef composite_key_result<composite_key> result_type;
-
-  composite_key(
-    BOOST_MULTI_INDEX_CK_ENUM(BOOST_MULTI_INDEX_CK_CTOR_ARG,KeyFromValue)):
-    super(BOOST_MULTI_INDEX_CK_ENUM_PARAMS(k))
-  {}
-
-  composite_key(const key_extractor_tuple& x):super(x){}
-
-  const key_extractor_tuple& key_extractors()const{return *this;}
-  key_extractor_tuple&       key_extractors(){return *this;}
-
-  template<typename ChainedPtr>
-
-#if !defined(BOOST_NO_SFINAE)
-  typename disable_if<
-    is_convertible<const ChainedPtr&,const value_type&>,result_type>::type
-#else
-  result_type
-#endif
-
-  operator()(const ChainedPtr& x)const
-  {
-    return operator()(*x);
-  }
-
-  result_type operator()(const value_type& x)const
-  {
-    return result_type(*this,x);
-  }
-
-  result_type operator()(const reference_wrapper<const value_type>& x)const
-  {
-    return result_type(*this,x.get());
-  }
-
-  result_type operator()(const reference_wrapper<value_type>& x)const
-  {
-    return result_type(*this,x.get());
-  }
-};
-
-/* comparison operators */
-
-/* == */
-
-template<typename CompositeKey1,typename CompositeKey2>
-inline bool operator==(
-  const composite_key_result<CompositeKey1>& x,
-  const composite_key_result<CompositeKey2>& y)
-{
-  typedef typename CompositeKey1::key_extractor_tuple key_extractor_tuple1;
-  typedef typename CompositeKey1::value_type          value_type1;
-  typedef typename CompositeKey2::key_extractor_tuple key_extractor_tuple2;
-  typedef typename CompositeKey2::value_type          value_type2;
-
-  BOOST_STATIC_ASSERT(
-    tuples::length<key_extractor_tuple1>::value==
-    tuples::length<key_extractor_tuple2>::value);
-
-  return detail::equal_ckey_ckey<
-    key_extractor_tuple1,value_type1,
-    key_extractor_tuple2,value_type2,
-    detail::generic_operator_equal_tuple
-  >::compare(
-    x.composite_key.key_extractors(),x.value,
-    y.composite_key.key_extractors(),y.value,
-    detail::generic_operator_equal_tuple());
-}
-
-template<
-  typename CompositeKey,
-  BOOST_MULTI_INDEX_CK_ENUM_PARAMS(typename Value)
->
-inline bool operator==(
-  const composite_key_result<CompositeKey>& x,
-  const tuple<BOOST_MULTI_INDEX_CK_ENUM_PARAMS(Value)>& y)
-{
-  typedef typename CompositeKey::key_extractor_tuple     key_extractor_tuple;
-  typedef typename CompositeKey::value_type              value_type;
-  typedef tuple<BOOST_MULTI_INDEX_CK_ENUM_PARAMS(Value)> key_tuple;
-  
-  BOOST_STATIC_ASSERT(
-    tuples::length<key_extractor_tuple>::value==
-    tuples::length<key_tuple>::value);
-
-  return detail::equal_ckey_cval<
-    key_extractor_tuple,value_type,
-    key_tuple,detail::generic_operator_equal_tuple
-  >::compare(
-    x.composite_key.key_extractors(),x.value,
-    y,detail::generic_operator_equal_tuple());
-}
-
-template
-<
-  BOOST_MULTI_INDEX_CK_ENUM_PARAMS(typename Value),
-  typename CompositeKey
->
-inline bool operator==(
-  const tuple<BOOST_MULTI_INDEX_CK_ENUM_PARAMS(Value)>& x,
-  const composite_key_result<CompositeKey>& y)
-{
-  typedef typename CompositeKey::key_extractor_tuple     key_extractor_tuple;
-  typedef typename CompositeKey::value_type              value_type;
-  typedef tuple<BOOST_MULTI_INDEX_CK_ENUM_PARAMS(Value)> key_tuple;
-  
-  BOOST_STATIC_ASSERT(
-    tuples::length<key_extractor_tuple>::value==
-    tuples::length<key_tuple>::value);
-
-  return detail::equal_ckey_cval<
-    key_extractor_tuple,value_type,
-    key_tuple,detail::generic_operator_equal_tuple
-  >::compare(
-    x,y.composite_key.key_extractors(),
-    y.value,detail::generic_operator_equal_tuple());
-}
-
-#if !defined(BOOST_NO_CXX11_HDR_TUPLE)&&\
-    !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-template<typename CompositeKey,typename... Values>
-inline bool operator==(
-  const composite_key_result<CompositeKey>& x,
-  const std::tuple<Values...>& y)
-{
-  typedef typename CompositeKey::key_extractor_tuple key_extractor_tuple;
-  typedef typename CompositeKey::value_type          value_type;
-  typedef std::tuple<Values...>                      key_tuple;
-  typedef typename detail::cons_stdtuple_ctor<
-    key_tuple>::result_type                          cons_key_tuple;
-  
-  BOOST_STATIC_ASSERT(
-    static_cast<std::size_t>(tuples::length<key_extractor_tuple>::value)==
-    std::tuple_size<key_tuple>::value);
-
-  return detail::equal_ckey_cval<
-    key_extractor_tuple,value_type,
-    cons_key_tuple,detail::generic_operator_equal_tuple
-  >::compare(
-    x.composite_key.key_extractors(),x.value,
-    detail::make_cons_stdtuple(y),detail::generic_operator_equal_tuple());
-}
-
-template<typename CompositeKey,typename... Values>
-inline bool operator==(
-  const std::tuple<Values...>& x,
-  const composite_key_result<CompositeKey>& y)
-{
-  typedef typename CompositeKey::key_extractor_tuple key_extractor_tuple;
-  typedef typename CompositeKey::value_type          value_type;
-  typedef std::tuple<Values...>                      key_tuple;
-  typedef typename detail::cons_stdtuple_ctor<
-    key_tuple>::result_type                          cons_key_tuple;
-
-  BOOST_STATIC_ASSERT(
-    static_cast<std::size_t>(tuples::length<key_extractor_tuple>::value)==
-    std::tuple_size<key_tuple>::value);
-
-  return detail::equal_ckey_cval<
-    key_extractor_tuple,value_type,
-    cons_key_tuple,detail::generic_operator_equal_tuple
-  >::compare(
-    detail::make_cons_stdtuple(x),y.composite_key.key_extractors(),
-    y.value,detail::generic_operator_equal_tuple());
-}
-#endif
-
-/* < */
-
-template<typename CompositeKey1,typename CompositeKey2>
-inline bool operator<(
-  const composite_key_result<CompositeKey1>& x,
-  const composite_key_result<CompositeKey2>& y)
-{
-  typedef typename CompositeKey1::key_extractor_tuple key_extractor_tuple1;
-  typedef typename CompositeKey1::value_type          value_type1;
-  typedef typename CompositeKey2::key_extractor_tuple key_extractor_tuple2;
-  typedef typename CompositeKey2::value_type          value_type2;
-
-  return detail::compare_ckey_ckey<
-   key_extractor_tuple1,value_type1,
-   key_extractor_tuple2,value_type2,
-   detail::generic_operator_less_tuple
-  >::compare(
-    x.composite_key.key_extractors(),x.value,
-    y.composite_key.key_extractors(),y.value,
-    detail::generic_operator_less_tuple());
-}
-
-template
-<
-  typename CompositeKey,
-  BOOST_MULTI_INDEX_CK_ENUM_PARAMS(typename Value)
->
-inline bool operator<(
-  const composite_key_result<CompositeKey>& x,
-  const tuple<BOOST_MULTI_INDEX_CK_ENUM_PARAMS(Value)>& y)
-{
-  typedef typename CompositeKey::key_extractor_tuple     key_extractor_tuple;
-  typedef typename CompositeKey::value_type              value_type;
-  typedef tuple<BOOST_MULTI_INDEX_CK_ENUM_PARAMS(Value)> key_tuple;
-  
-  return detail::compare_ckey_cval<
-    key_extractor_tuple,value_type,
-    key_tuple,detail::generic_operator_less_tuple
-  >::compare(
-    x.composite_key.key_extractors(),x.value,
-    y,detail::generic_operator_less_tuple());
-}
-
-template
-<
-  BOOST_MULTI_INDEX_CK_ENUM_PARAMS(typename Value),
-  typename CompositeKey
->
-inline bool operator<(
-  const tuple<BOOST_MULTI_INDEX_CK_ENUM_PARAMS(Value)>& x,
-  const composite_key_result<CompositeKey>& y)
-{
-  typedef typename CompositeKey::key_extractor_tuple     key_extractor_tuple;
-  typedef typename CompositeKey::value_type              value_type;
-  typedef tuple<BOOST_MULTI_INDEX_CK_ENUM_PARAMS(Value)> key_tuple;
-  
-  return detail::compare_ckey_cval<
-    key_extractor_tuple,value_type,
-    key_tuple,detail::generic_operator_less_tuple
-  >::compare(
-    x,y.composite_key.key_extractors(),
-    y.value,detail::generic_operator_less_tuple());
-}
-
-#if !defined(BOOST_NO_CXX11_HDR_TUPLE)&&\
-    !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-template<typename CompositeKey,typename... Values>
-inline bool operator<(
-  const composite_key_result<CompositeKey>& x,
-  const std::tuple<Values...>& y)
-{
-  typedef typename CompositeKey::key_extractor_tuple key_extractor_tuple;
-  typedef typename CompositeKey::value_type          value_type;
-  typedef std::tuple<Values...>                      key_tuple;
-  typedef typename detail::cons_stdtuple_ctor<
-    key_tuple>::result_type                          cons_key_tuple;
-  
-  return detail::compare_ckey_cval<
-    key_extractor_tuple,value_type,
-    cons_key_tuple,detail::generic_operator_less_tuple
-  >::compare(
-    x.composite_key.key_extractors(),x.value,
-    detail::make_cons_stdtuple(y),detail::generic_operator_less_tuple());
-}
-
-template<typename CompositeKey,typename... Values>
-inline bool operator<(
-  const std::tuple<Values...>& x,
-  const composite_key_result<CompositeKey>& y)
-{
-  typedef typename CompositeKey::key_extractor_tuple key_extractor_tuple;
-  typedef typename CompositeKey::value_type          value_type;
-  typedef std::tuple<Values...>                      key_tuple;
-  typedef typename detail::cons_stdtuple_ctor<
-    key_tuple>::result_type                          cons_key_tuple;
-  
-  return detail::compare_ckey_cval<
-    key_extractor_tuple,value_type,
-    cons_key_tuple,detail::generic_operator_less_tuple
-  >::compare(
-    detail::make_cons_stdtuple(x),y.composite_key.key_extractors(),
-    y.value,detail::generic_operator_less_tuple());
-}
-#endif
-
-/* rest of comparison operators */
-
-#define BOOST_MULTI_INDEX_CK_COMPLETE_COMP_OPS(t1,t2,a1,a2)                  \
-template<t1,t2> inline bool operator!=(const a1& x,const a2& y)              \
-{                                                                            \
-  return !(x==y);                                                            \
-}                                                                            \
-                                                                             \
-template<t1,t2> inline bool operator>(const a1& x,const a2& y)               \
-{                                                                            \
-  return y<x;                                                                \
-}                                                                            \
-                                                                             \
-template<t1,t2> inline bool operator>=(const a1& x,const a2& y)              \
-{                                                                            \
-  return !(x<y);                                                             \
-}                                                                            \
-                                                                             \
-template<t1,t2> inline bool operator<=(const a1& x,const a2& y)              \
-{                                                                            \
-  return !(y<x);                                                             \
-}
-
-BOOST_MULTI_INDEX_CK_COMPLETE_COMP_OPS(
-  typename CompositeKey1,
-  typename CompositeKey2,
-  composite_key_result<CompositeKey1>,
-  composite_key_result<CompositeKey2>
-)
-
-BOOST_MULTI_INDEX_CK_COMPLETE_COMP_OPS(
-  typename CompositeKey,
-  BOOST_MULTI_INDEX_CK_ENUM_PARAMS(typename Value),
-  composite_key_result<CompositeKey>,
-  tuple<BOOST_MULTI_INDEX_CK_ENUM_PARAMS(Value)>
-)
-
-BOOST_MULTI_INDEX_CK_COMPLETE_COMP_OPS(
-  BOOST_MULTI_INDEX_CK_ENUM_PARAMS(typename Value),
-  typename CompositeKey,
-  tuple<BOOST_MULTI_INDEX_CK_ENUM_PARAMS(Value)>,
-  composite_key_result<CompositeKey>
-)
-
-#if !defined(BOOST_NO_CXX11_HDR_TUPLE)&&\
-    !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-BOOST_MULTI_INDEX_CK_COMPLETE_COMP_OPS(
-  typename CompositeKey,
-  typename... Values,
-  composite_key_result<CompositeKey>,
-  std::tuple<Values...>
-)
-
-BOOST_MULTI_INDEX_CK_COMPLETE_COMP_OPS(
-  typename CompositeKey,
-  typename... Values,
-  std::tuple<Values...>,
-  composite_key_result<CompositeKey>
-)
-#endif
-
-/* composite_key_equal_to */
-
-template
-<
-  BOOST_MULTI_INDEX_CK_ENUM(BOOST_MULTI_INDEX_CK_TEMPLATE_PARM,Pred)
->
-struct composite_key_equal_to:
-  private tuple<BOOST_MULTI_INDEX_CK_ENUM_PARAMS(Pred)>
-{
-private:
-  typedef tuple<BOOST_MULTI_INDEX_CK_ENUM_PARAMS(Pred)> super;
-
-public:
-  typedef super key_eq_tuple;
-
-  composite_key_equal_to(
-    BOOST_MULTI_INDEX_CK_ENUM(BOOST_MULTI_INDEX_CK_CTOR_ARG,Pred)):
-    super(BOOST_MULTI_INDEX_CK_ENUM_PARAMS(k))
-  {}
-
-  composite_key_equal_to(const key_eq_tuple& x):super(x){}
-
-  const key_eq_tuple& key_eqs()const{return *this;}
-  key_eq_tuple&       key_eqs(){return *this;}
-
-  template<typename CompositeKey1,typename CompositeKey2>
-  bool operator()(
-    const composite_key_result<CompositeKey1> & x,
-    const composite_key_result<CompositeKey2> & y)const
-  {
-    typedef typename CompositeKey1::key_extractor_tuple key_extractor_tuple1;
-    typedef typename CompositeKey1::value_type          value_type1;
-    typedef typename CompositeKey2::key_extractor_tuple key_extractor_tuple2;
-    typedef typename CompositeKey2::value_type          value_type2;
-
-    BOOST_STATIC_ASSERT(
-      tuples::length<key_extractor_tuple1>::value<=
-      tuples::length<key_eq_tuple>::value&&
-      tuples::length<key_extractor_tuple1>::value==
-      tuples::length<key_extractor_tuple2>::value);
-
-    return detail::equal_ckey_ckey<
-      key_extractor_tuple1,value_type1,
-      key_extractor_tuple2,value_type2,
-      key_eq_tuple
-    >::compare(
-      x.composite_key.key_extractors(),x.value,
-      y.composite_key.key_extractors(),y.value,
-      key_eqs());
-  }
-  
-  template
-  <
-    typename CompositeKey,
-    BOOST_MULTI_INDEX_CK_ENUM_PARAMS(typename Value)
-  >
-  bool operator()(
-    const composite_key_result<CompositeKey>& x,
-    const tuple<BOOST_MULTI_INDEX_CK_ENUM_PARAMS(Value)>& y)const
-  {
-    typedef typename CompositeKey::key_extractor_tuple     key_extractor_tuple;
-    typedef typename CompositeKey::value_type              value_type;
-    typedef tuple<BOOST_MULTI_INDEX_CK_ENUM_PARAMS(Value)> key_tuple;
-
-    BOOST_STATIC_ASSERT(
-      tuples::length<key_extractor_tuple>::value<=
-      tuples::length<key_eq_tuple>::value&&
-      tuples::length<key_extractor_tuple>::value==
-      tuples::length<key_tuple>::value);
-
-    return detail::equal_ckey_cval<
-      key_extractor_tuple,value_type,
-      key_tuple,key_eq_tuple
-    >::compare(x.composite_key.key_extractors(),x.value,y,key_eqs());
-  }
-
-  template
-  <
-    BOOST_MULTI_INDEX_CK_ENUM_PARAMS(typename Value),
-    typename CompositeKey
-  >
-  bool operator()(
-    const tuple<BOOST_MULTI_INDEX_CK_ENUM_PARAMS(Value)>& x,
-    const composite_key_result<CompositeKey>& y)const
-  {
-    typedef typename CompositeKey::key_extractor_tuple     key_extractor_tuple;
-    typedef typename CompositeKey::value_type              value_type;
-    typedef tuple<BOOST_MULTI_INDEX_CK_ENUM_PARAMS(Value)> key_tuple;
-
-    BOOST_STATIC_ASSERT(
-      tuples::length<key_tuple>::value<=
-      tuples::length<key_eq_tuple>::value&&
-      tuples::length<key_tuple>::value==
-      tuples::length<key_extractor_tuple>::value);
-
-    return detail::equal_ckey_cval<
-      key_extractor_tuple,value_type,
-      key_tuple,key_eq_tuple
-    >::compare(x,y.composite_key.key_extractors(),y.value,key_eqs());
-  }
-
-#if !defined(BOOST_NO_CXX11_HDR_TUPLE)&&\
-    !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-  template<typename CompositeKey,typename... Values>
-  bool operator()(
-    const composite_key_result<CompositeKey>& x,
-    const std::tuple<Values...>& y)const
-  {
-    typedef typename CompositeKey::key_extractor_tuple key_extractor_tuple;
-    typedef typename CompositeKey::value_type          value_type;
-    typedef std::tuple<Values...>                      key_tuple;
-    typedef typename detail::cons_stdtuple_ctor<
-      key_tuple>::result_type                          cons_key_tuple;
-
-    BOOST_STATIC_ASSERT(
-      tuples::length<key_extractor_tuple>::value<=
-      tuples::length<key_eq_tuple>::value&&
-      static_cast<std::size_t>(tuples::length<key_extractor_tuple>::value)==
-      std::tuple_size<key_tuple>::value);
-
-    return detail::equal_ckey_cval<
-      key_extractor_tuple,value_type,
-      cons_key_tuple,key_eq_tuple
-    >::compare(
-      x.composite_key.key_extractors(),x.value,
-      detail::make_cons_stdtuple(y),key_eqs());
-  }
-
-  template<typename CompositeKey,typename... Values>
-  bool operator()(
-    const std::tuple<Values...>& x,
-    const composite_key_result<CompositeKey>& y)const
-  {
-    typedef typename CompositeKey::key_extractor_tuple key_extractor_tuple;
-    typedef typename CompositeKey::value_type          value_type;
-    typedef std::tuple<Values...>                      key_tuple;
-    typedef typename detail::cons_stdtuple_ctor<
-      key_tuple>::result_type                          cons_key_tuple;
-
-    BOOST_STATIC_ASSERT(
-      std::tuple_size<key_tuple>::value<=
-      static_cast<std::size_t>(tuples::length<key_eq_tuple>::value)&&
-      std::tuple_size<key_tuple>::value==
-      static_cast<std::size_t>(tuples::length<key_extractor_tuple>::value));
-
-    return detail::equal_ckey_cval<
-      key_extractor_tuple,value_type,
-      cons_key_tuple,key_eq_tuple
-    >::compare(
-      detail::make_cons_stdtuple(x),y.composite_key.key_extractors(),
-      y.value,key_eqs());
-  }
-#endif
-};
-
-/* composite_key_compare */
-
-template
-<
-  BOOST_MULTI_INDEX_CK_ENUM(BOOST_MULTI_INDEX_CK_TEMPLATE_PARM,Compare)
->
-struct composite_key_compare:
-  private tuple<BOOST_MULTI_INDEX_CK_ENUM_PARAMS(Compare)>
-{
-private:
-  typedef tuple<BOOST_MULTI_INDEX_CK_ENUM_PARAMS(Compare)> super;
-
-public:
-  typedef super key_comp_tuple;
-
-  composite_key_compare(
-    BOOST_MULTI_INDEX_CK_ENUM(BOOST_MULTI_INDEX_CK_CTOR_ARG,Compare)):
-    super(BOOST_MULTI_INDEX_CK_ENUM_PARAMS(k))
-  {}
-
-  composite_key_compare(const key_comp_tuple& x):super(x){}
-
-  const key_comp_tuple& key_comps()const{return *this;}
-  key_comp_tuple&       key_comps(){return *this;}
-
-  template<typename CompositeKey1,typename CompositeKey2>
-  bool operator()(
-    const composite_key_result<CompositeKey1> & x,
-    const composite_key_result<CompositeKey2> & y)const
-  {
-    typedef typename CompositeKey1::key_extractor_tuple key_extractor_tuple1;
-    typedef typename CompositeKey1::value_type          value_type1;
-    typedef typename CompositeKey2::key_extractor_tuple key_extractor_tuple2;
-    typedef typename CompositeKey2::value_type          value_type2;
-
-    BOOST_STATIC_ASSERT(
-      tuples::length<key_extractor_tuple1>::value<=
-      tuples::length<key_comp_tuple>::value||
-      tuples::length<key_extractor_tuple2>::value<=
-      tuples::length<key_comp_tuple>::value);
-
-    return detail::compare_ckey_ckey<
-      key_extractor_tuple1,value_type1,
-      key_extractor_tuple2,value_type2,
-      key_comp_tuple
-    >::compare(
-      x.composite_key.key_extractors(),x.value,
-      y.composite_key.key_extractors(),y.value,
-      key_comps());
-  }
-  
-#if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
-  template<typename CompositeKey,typename Value>
-  bool operator()(
-    const composite_key_result<CompositeKey>& x,
-    const Value& y)const
-  {
-    return operator()(x,boost::make_tuple(boost::cref(y)));
-  }
-#endif
-
-  template
-  <
-    typename CompositeKey,
-    BOOST_MULTI_INDEX_CK_ENUM_PARAMS(typename Value)
-  >
-  bool operator()(
-    const composite_key_result<CompositeKey>& x,
-    const tuple<BOOST_MULTI_INDEX_CK_ENUM_PARAMS(Value)>& y)const
-  {
-    typedef typename CompositeKey::key_extractor_tuple     key_extractor_tuple;
-    typedef typename CompositeKey::value_type              value_type;
-    typedef tuple<BOOST_MULTI_INDEX_CK_ENUM_PARAMS(Value)> key_tuple;
-
-    BOOST_STATIC_ASSERT(
-      tuples::length<key_extractor_tuple>::value<=
-      tuples::length<key_comp_tuple>::value||
-      tuples::length<key_tuple>::value<=
-      tuples::length<key_comp_tuple>::value);
-
-    return detail::compare_ckey_cval<
-      key_extractor_tuple,value_type,
-      key_tuple,key_comp_tuple
-    >::compare(x.composite_key.key_extractors(),x.value,y,key_comps());
-  }
-
-#if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
-  template<typename Value,typename CompositeKey>
-  bool operator()(
-    const Value& x,
-    const composite_key_result<CompositeKey>& y)const
-  {
-    return operator()(boost::make_tuple(boost::cref(x)),y);
-  }
-#endif
-
-  template
-  <
-    BOOST_MULTI_INDEX_CK_ENUM_PARAMS(typename Value),
-    typename CompositeKey
-  >
-  bool operator()(
-    const tuple<BOOST_MULTI_INDEX_CK_ENUM_PARAMS(Value)>& x,
-    const composite_key_result<CompositeKey>& y)const
-  {
-    typedef typename CompositeKey::key_extractor_tuple     key_extractor_tuple;
-    typedef typename CompositeKey::value_type              value_type;
-    typedef tuple<BOOST_MULTI_INDEX_CK_ENUM_PARAMS(Value)> key_tuple;
-
-    BOOST_STATIC_ASSERT(
-      tuples::length<key_tuple>::value<=
-      tuples::length<key_comp_tuple>::value||
-      tuples::length<key_extractor_tuple>::value<=
-      tuples::length<key_comp_tuple>::value);
-
-    return detail::compare_ckey_cval<
-      key_extractor_tuple,value_type,
-      key_tuple,key_comp_tuple
-    >::compare(x,y.composite_key.key_extractors(),y.value,key_comps());
-  }
-
-#if !defined(BOOST_NO_CXX11_HDR_TUPLE)&&\
-    !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-  template<typename CompositeKey,typename... Values>
-  bool operator()(
-    const composite_key_result<CompositeKey>& x,
-    const std::tuple<Values...>& y)const
-  {
-    typedef typename CompositeKey::key_extractor_tuple key_extractor_tuple;
-    typedef typename CompositeKey::value_type          value_type;
-    typedef std::tuple<Values...>                      key_tuple;
-    typedef typename detail::cons_stdtuple_ctor<
-      key_tuple>::result_type                          cons_key_tuple;
-
-    BOOST_STATIC_ASSERT(
-      tuples::length<key_extractor_tuple>::value<=
-      tuples::length<key_comp_tuple>::value||
-      std::tuple_size<key_tuple>::value<=
-      static_cast<std::size_t>(tuples::length<key_comp_tuple>::value));
-
-    return detail::compare_ckey_cval<
-      key_extractor_tuple,value_type,
-      cons_key_tuple,key_comp_tuple
-    >::compare(
-      x.composite_key.key_extractors(),x.value,
-      detail::make_cons_stdtuple(y),key_comps());
-  }
-
-  template<typename CompositeKey,typename... Values>
-  bool operator()(
-    const std::tuple<Values...>& x,
-    const composite_key_result<CompositeKey>& y)const
-  {
-    typedef typename CompositeKey::key_extractor_tuple key_extractor_tuple;
-    typedef typename CompositeKey::value_type          value_type;
-    typedef std::tuple<Values...>                      key_tuple;
-    typedef typename detail::cons_stdtuple_ctor<
-      key_tuple>::result_type                          cons_key_tuple;
-
-    BOOST_STATIC_ASSERT(
-      std::tuple_size<key_tuple>::value<=
-      static_cast<std::size_t>(tuples::length<key_comp_tuple>::value)||
-      tuples::length<key_extractor_tuple>::value<=
-      tuples::length<key_comp_tuple>::value);
-
-    return detail::compare_ckey_cval<
-      key_extractor_tuple,value_type,
-      cons_key_tuple,key_comp_tuple
-    >::compare(
-      detail::make_cons_stdtuple(x),y.composite_key.key_extractors(),
-      y.value,key_comps());
-  }
-#endif
-};
-
-/* composite_key_hash */
-
-template
-<
-  BOOST_MULTI_INDEX_CK_ENUM(BOOST_MULTI_INDEX_CK_TEMPLATE_PARM,Hash)
->
-struct composite_key_hash:
-  private tuple<BOOST_MULTI_INDEX_CK_ENUM_PARAMS(Hash)>
-{
-private:
-  typedef tuple<BOOST_MULTI_INDEX_CK_ENUM_PARAMS(Hash)> super;
-
-public:
-  typedef super key_hasher_tuple;
-
-  composite_key_hash(
-    BOOST_MULTI_INDEX_CK_ENUM(BOOST_MULTI_INDEX_CK_CTOR_ARG,Hash)):
-    super(BOOST_MULTI_INDEX_CK_ENUM_PARAMS(k))
-  {}
-
-  composite_key_hash(const key_hasher_tuple& x):super(x){}
-
-  const key_hasher_tuple& key_hash_functions()const{return *this;}
-  key_hasher_tuple&       key_hash_functions(){return *this;}
-
-  template<typename CompositeKey>
-  std::size_t operator()(const composite_key_result<CompositeKey> & x)const
-  {
-    typedef typename CompositeKey::key_extractor_tuple key_extractor_tuple;
-    typedef typename CompositeKey::value_type          value_type;
-
-    BOOST_STATIC_ASSERT(
-      tuples::length<key_extractor_tuple>::value==
-      tuples::length<key_hasher_tuple>::value);
-
-    return detail::hash_ckey<
-      key_extractor_tuple,value_type,
-      key_hasher_tuple
-    >::hash(x.composite_key.key_extractors(),x.value,key_hash_functions());
-  }
-  
-  template<BOOST_MULTI_INDEX_CK_ENUM_PARAMS(typename Value)>
-  std::size_t operator()(
-    const tuple<BOOST_MULTI_INDEX_CK_ENUM_PARAMS(Value)>& x)const
-  {
-    typedef tuple<BOOST_MULTI_INDEX_CK_ENUM_PARAMS(Value)> key_tuple;
-
-    BOOST_STATIC_ASSERT(
-      tuples::length<key_tuple>::value==
-      tuples::length<key_hasher_tuple>::value);
-
-    return detail::hash_cval<
-      key_tuple,key_hasher_tuple
-    >::hash(x,key_hash_functions());
-  }
-
-#if !defined(BOOST_NO_CXX11_HDR_TUPLE)&&\
-    !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-  template<typename... Values>
-  std::size_t operator()(const std::tuple<Values...>& x)const
-  {
-    typedef std::tuple<Values...>                key_tuple;
-    typedef typename detail::cons_stdtuple_ctor<
-      key_tuple>::result_type                    cons_key_tuple;
-
-    BOOST_STATIC_ASSERT(
-      std::tuple_size<key_tuple>::value==
-      static_cast<std::size_t>(tuples::length<key_hasher_tuple>::value));
-
-    return detail::hash_cval<
-      cons_key_tuple,key_hasher_tuple
-    >::hash(detail::make_cons_stdtuple(x),key_hash_functions());
-  }
-#endif
-};
-
-/* Instantiations of the former functors with "natural" basic components:
- * composite_key_result_equal_to uses std::equal_to of the values.
- * composite_key_result_less     uses std::less.
- * composite_key_result_greater  uses std::greater.
- * composite_key_result_hash     uses boost::hash.
- */
-
-#define BOOST_MULTI_INDEX_CK_RESULT_EQUAL_TO_SUPER                           \
-composite_key_equal_to<                                                      \
-    BOOST_MULTI_INDEX_CK_ENUM(                                               \
-      BOOST_MULTI_INDEX_CK_APPLY_METAFUNCTION_N,                             \
-      /* the argument is a PP list */                                        \
-      (detail::nth_composite_key_equal_to,                                   \
-        (BOOST_DEDUCED_TYPENAME CompositeKeyResult::composite_key_type,      \
-          BOOST_PP_NIL)))                                                    \
-  >
-
-template<typename CompositeKeyResult>
-struct composite_key_result_equal_to:
-BOOST_MULTI_INDEX_PRIVATE_IF_USING_DECL_FOR_TEMPL_FUNCTIONS
-BOOST_MULTI_INDEX_CK_RESULT_EQUAL_TO_SUPER
-{
-private:
-  typedef BOOST_MULTI_INDEX_CK_RESULT_EQUAL_TO_SUPER super;
-
-public:
-  typedef CompositeKeyResult  first_argument_type;
-  typedef first_argument_type second_argument_type;
-  typedef bool                result_type;
-
-  using super::operator();
-};
-
-#define BOOST_MULTI_INDEX_CK_RESULT_LESS_SUPER                               \
-composite_key_compare<                                                       \
-    BOOST_MULTI_INDEX_CK_ENUM(                                               \
-      BOOST_MULTI_INDEX_CK_APPLY_METAFUNCTION_N,                             \
-      /* the argument is a PP list */                                        \
-      (detail::nth_composite_key_less,                                       \
-        (BOOST_DEDUCED_TYPENAME CompositeKeyResult::composite_key_type,      \
-          BOOST_PP_NIL)))                                                    \
-  >
-
-template<typename CompositeKeyResult>
-struct composite_key_result_less:
-BOOST_MULTI_INDEX_PRIVATE_IF_USING_DECL_FOR_TEMPL_FUNCTIONS
-BOOST_MULTI_INDEX_CK_RESULT_LESS_SUPER
-{
-private:
-  typedef BOOST_MULTI_INDEX_CK_RESULT_LESS_SUPER super;
-
-public:
-  typedef CompositeKeyResult  first_argument_type;
-  typedef first_argument_type second_argument_type;
-  typedef bool                result_type;
-
-  using super::operator();
-};
-
-#define BOOST_MULTI_INDEX_CK_RESULT_GREATER_SUPER                            \
-composite_key_compare<                                                       \
-    BOOST_MULTI_INDEX_CK_ENUM(                                               \
-      BOOST_MULTI_INDEX_CK_APPLY_METAFUNCTION_N,                             \
-      /* the argument is a PP list */                                        \
-      (detail::nth_composite_key_greater,                                    \
-        (BOOST_DEDUCED_TYPENAME CompositeKeyResult::composite_key_type,      \
-          BOOST_PP_NIL)))                                                    \
-  >
-
-template<typename CompositeKeyResult>
-struct composite_key_result_greater:
-BOOST_MULTI_INDEX_PRIVATE_IF_USING_DECL_FOR_TEMPL_FUNCTIONS
-BOOST_MULTI_INDEX_CK_RESULT_GREATER_SUPER
-{
-private:
-  typedef BOOST_MULTI_INDEX_CK_RESULT_GREATER_SUPER super;
-
-public:
-  typedef CompositeKeyResult  first_argument_type;
-  typedef first_argument_type second_argument_type;
-  typedef bool                result_type;
-
-  using super::operator();
-};
-
-#define BOOST_MULTI_INDEX_CK_RESULT_HASH_SUPER                               \
-composite_key_hash<                                                          \
-    BOOST_MULTI_INDEX_CK_ENUM(                                               \
-      BOOST_MULTI_INDEX_CK_APPLY_METAFUNCTION_N,                             \
-      /* the argument is a PP list */                                        \
-      (detail::nth_composite_key_hash,                                       \
-        (BOOST_DEDUCED_TYPENAME CompositeKeyResult::composite_key_type,      \
-          BOOST_PP_NIL)))                                                    \
-  >
-
-template<typename CompositeKeyResult>
-struct composite_key_result_hash:
-BOOST_MULTI_INDEX_PRIVATE_IF_USING_DECL_FOR_TEMPL_FUNCTIONS
-BOOST_MULTI_INDEX_CK_RESULT_HASH_SUPER
-{
-private:
-  typedef BOOST_MULTI_INDEX_CK_RESULT_HASH_SUPER super;
-
-public:
-  typedef CompositeKeyResult argument_type;
-  typedef std::size_t        result_type;
-
-  using super::operator();
-};
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-/* Specializations of std::equal_to, std::less, std::greater and boost::hash
- * for composite_key_results enabling interoperation with tuples of values.
- */
-
-namespace std{
-
-template<typename CompositeKey>
-struct equal_to<boost::multi_index::composite_key_result<CompositeKey> >:
-  boost::multi_index::composite_key_result_equal_to<
-    boost::multi_index::composite_key_result<CompositeKey>
-  >
-{
-};
-
-template<typename CompositeKey>
-struct less<boost::multi_index::composite_key_result<CompositeKey> >:
-  boost::multi_index::composite_key_result_less<
-    boost::multi_index::composite_key_result<CompositeKey>
-  >
-{
-};
-
-template<typename CompositeKey>
-struct greater<boost::multi_index::composite_key_result<CompositeKey> >:
-  boost::multi_index::composite_key_result_greater<
-    boost::multi_index::composite_key_result<CompositeKey>
-  >
-{
-};
-
-} /* namespace std */
-
-namespace boost{
-
-template<typename CompositeKey>
-struct hash<boost::multi_index::composite_key_result<CompositeKey> >:
-  boost::multi_index::composite_key_result_hash<
-    boost::multi_index::composite_key_result<CompositeKey>
-  >
-{
-};
-
-} /* namespace boost */
-
-#undef BOOST_MULTI_INDEX_CK_RESULT_HASH_SUPER
-#undef BOOST_MULTI_INDEX_CK_RESULT_GREATER_SUPER
-#undef BOOST_MULTI_INDEX_CK_RESULT_LESS_SUPER
-#undef BOOST_MULTI_INDEX_CK_RESULT_EQUAL_TO_SUPER
-#undef BOOST_MULTI_INDEX_CK_COMPLETE_COMP_OPS
-#undef BOOST_MULTI_INDEX_CK_IDENTITY_ENUM_MACRO
-#undef BOOST_MULTI_INDEX_CK_NTH_COMPOSITE_KEY_FUNCTOR
-#undef BOOST_MULTI_INDEX_CK_APPLY_METAFUNCTION_N
-#undef BOOST_MULTI_INDEX_CK_CTOR_ARG
-#undef BOOST_MULTI_INDEX_CK_TEMPLATE_PARM
-#undef BOOST_MULTI_INDEX_CK_ENUM_PARAMS
-#undef BOOST_MULTI_INDEX_CK_ENUM
-#undef BOOST_MULTI_INDEX_COMPOSITE_KEY_SIZE
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/access_specifier.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/access_specifier.hpp
deleted file mode 100644
index f3346e836d4..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/access_specifier.hpp
+++ /dev/null
@@ -1,54 +0,0 @@
-/* Copyright 2003-2013 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_DETAIL_ACCESS_SPECIFIER_HPP
-#define BOOST_MULTI_INDEX_DETAIL_ACCESS_SPECIFIER_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp>
-#include <boost/detail/workaround.hpp>
-
-/* In those compilers that do not accept the member template friend syntax,
- * some protected and private sections might need to be specified as
- * public.
- */
-
-#if defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
-#define BOOST_MULTI_INDEX_PROTECTED_IF_MEMBER_TEMPLATE_FRIENDS public
-#define BOOST_MULTI_INDEX_PRIVATE_IF_MEMBER_TEMPLATE_FRIENDS public
-#else
-#define BOOST_MULTI_INDEX_PROTECTED_IF_MEMBER_TEMPLATE_FRIENDS protected
-#define BOOST_MULTI_INDEX_PRIVATE_IF_MEMBER_TEMPLATE_FRIENDS private
-#endif
-
-/* GCC does not correctly support in-class using declarations for template
- * functions. See http://gcc.gnu.org/bugzilla/show_bug.cgi?id=9810
- * MSVC 7.1/8.0 seem to have a similar problem, though the conditions in
- * which the error happens are not that simple. I have yet to isolate this
- * into a snippet suitable for bug reporting.
- * Sun Studio also has this problem, which might be related, from the
- * information gathered at Sun forums, with a known issue notified at the
- * internal bug report 6421933. The bug is present up to Studio Express 2,
- * the latest preview version of the future Sun Studio 12. As of this writing
- * (October 2006) it is not known whether a fix will finally make it into the
- * official Sun Studio 12.
- */
-
-#if BOOST_WORKAROUND(__GNUC__,==3)&&(__GNUC_MINOR__<4)||\
-    BOOST_WORKAROUND(BOOST_MSVC,==1310)||\
-    BOOST_WORKAROUND(BOOST_MSVC,==1400)||\
-    BOOST_WORKAROUND(__SUNPRO_CC,BOOST_TESTED_AT(0x590))
-#define BOOST_MULTI_INDEX_PRIVATE_IF_USING_DECL_FOR_TEMPL_FUNCTIONS public
-#else
-#define BOOST_MULTI_INDEX_PRIVATE_IF_USING_DECL_FOR_TEMPL_FUNCTIONS private
-#endif
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/adl_swap.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/adl_swap.hpp
deleted file mode 100644
index 02b06442290..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/adl_swap.hpp
+++ /dev/null
@@ -1,44 +0,0 @@
-/* Copyright 2003-2013 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_DETAIL_ADL_SWAP_HPP
-#define BOOST_MULTI_INDEX_DETAIL_ADL_SWAP_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <algorithm>
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-template<typename T>
-void adl_swap(T& x,T& y)
-{
-
-#if !defined(BOOST_FUNCTION_SCOPE_USING_DECLARATION_BREAKS_ADL)
-  using std::swap;
-  swap(x,y);
-#else
-  std::swap(x,y);
-#endif
-
-}
-
-} /* namespace multi_index::detail */
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/archive_constructed.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/archive_constructed.hpp
deleted file mode 100644
index 0a7a26e0d4e..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/archive_constructed.hpp
+++ /dev/null
@@ -1,83 +0,0 @@
-/* Copyright 2003-2016 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_DETAIL_ARCHIVE_CONSTRUCTED_HPP
-#define BOOST_MULTI_INDEX_DETAIL_ARCHIVE_CONSTRUCTED_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <boost/detail/no_exceptions_support.hpp>
-#include <boost/noncopyable.hpp>
-#include <boost/serialization/serialization.hpp>
-#include <boost/type_traits/aligned_storage.hpp>
-#include <boost/type_traits/alignment_of.hpp> 
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-/* constructs a stack-based object from a serialization archive */
-
-template<typename T>
-struct archive_constructed:private noncopyable
-{
-  template<class Archive>
-  archive_constructed(Archive& ar,const unsigned int version)
-  {
-    serialization::load_construct_data_adl(ar,&get(),version);
-    BOOST_TRY{
-      ar>>get();
-    }
-    BOOST_CATCH(...){
-      (&get())->~T();
-      BOOST_RETHROW;
-    }
-    BOOST_CATCH_END
-  }
-
-  template<class Archive>
-  archive_constructed(const char* name,Archive& ar,const unsigned int version)
-  {
-    serialization::load_construct_data_adl(ar,&get(),version);
-    BOOST_TRY{
-      ar>>serialization::make_nvp(name,get());
-    }
-    BOOST_CATCH(...){
-      (&get())->~T();
-      BOOST_RETHROW;
-    }
-    BOOST_CATCH_END
-  }
-
-  ~archive_constructed()
-  {
-    (&get())->~T();
-  }
-
-#include <boost/multi_index/detail/ignore_wstrict_aliasing.hpp>
-
-  T& get(){return *reinterpret_cast<T*>(&space);}
-
-#include <boost/multi_index/detail/restore_wstrict_aliasing.hpp>
-
-private:
-  typename aligned_storage<sizeof(T),alignment_of<T>::value>::type space;
-};
-
-} /* namespace multi_index::detail */
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/auto_space.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/auto_space.hpp
deleted file mode 100644
index 9d78c3a363f..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/auto_space.hpp
+++ /dev/null
@@ -1,91 +0,0 @@
-/* Copyright 2003-2013 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_DETAIL_AUTO_SPACE_HPP
-#define BOOST_MULTI_INDEX_DETAIL_AUTO_SPACE_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <algorithm>
-#include <boost/detail/allocator_utilities.hpp>
-#include <boost/multi_index/detail/adl_swap.hpp>
-#include <boost/noncopyable.hpp>
-#include <memory>
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-/* auto_space provides uninitialized space suitably to store
- * a given number of elements of a given type.
- */
-
-/* NB: it is not clear whether using an allocator to handle
- * zero-sized arrays of elements is conformant or not. GCC 3.3.1
- * and prior fail here, other stdlibs handle the issue gracefully.
- * To be on the safe side, the case n==0 is given special treatment.
- * References:
- *   GCC Bugzilla, "standard allocator crashes when deallocating segment
- *    "of zero length", http://gcc.gnu.org/bugzilla/show_bug.cgi?id=14176
- *   C++ Standard Library Defect Report List (Revision 28), issue 199
- *     "What does allocate(0) return?",
- *     http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#199
- */
-
-template<typename T,typename Allocator=std::allocator<T> >
-struct auto_space:private noncopyable
-{
-  typedef typename boost::detail::allocator::rebind_to<
-    Allocator,T
-  >::type::pointer pointer;
-
-  explicit auto_space(const Allocator& al=Allocator(),std::size_t n=1):
-  al_(al),n_(n),data_(n_?al_.allocate(n_):pointer(0))
-  {}
-
-  ~auto_space()
-  {
-    if(n_)al_.deallocate(data_,n_);
-  }
-
-  Allocator get_allocator()const{return al_;}
-
-  pointer data()const{return data_;}
-
-  void swap(auto_space& x)
-  {
-    if(al_!=x.al_)adl_swap(al_,x.al_);
-    std::swap(n_,x.n_);
-    std::swap(data_,x.data_);
-  }
-    
-private:
-  typename boost::detail::allocator::rebind_to<
-    Allocator,T>::type                          al_;
-  std::size_t                                   n_;
-  pointer                                       data_;
-};
-
-template<typename T,typename Allocator>
-void swap(auto_space<T,Allocator>& x,auto_space<T,Allocator>& y)
-{
-  x.swap(y);
-}
-
-} /* namespace multi_index::detail */
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/base_type.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/base_type.hpp
deleted file mode 100644
index 8c9b62b716a..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/base_type.hpp
+++ /dev/null
@@ -1,74 +0,0 @@
-/* Copyright 2003-2013 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_DETAIL_BASE_TYPE_HPP
-#define BOOST_MULTI_INDEX_DETAIL_BASE_TYPE_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <boost/detail/workaround.hpp>
-#include <boost/mpl/at.hpp>
-#include <boost/mpl/apply.hpp>
-#include <boost/mpl/size.hpp>
-#include <boost/multi_index/detail/index_base.hpp>
-#include <boost/multi_index/detail/is_index_list.hpp>
-#include <boost/static_assert.hpp>
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-/* MPL machinery to construct a linear hierarchy of indices out of
- * a index list.
- */
-
-struct index_applier
-{
-  template<typename IndexSpecifierMeta,typename SuperMeta>
-  struct apply
-  {
-    typedef typename IndexSpecifierMeta::type            index_specifier;
-    typedef typename index_specifier::
-      BOOST_NESTED_TEMPLATE index_class<SuperMeta>::type type;
-  }; 
-};
-
-template<int N,typename Value,typename IndexSpecifierList,typename Allocator>
-struct nth_layer
-{
-  BOOST_STATIC_CONSTANT(int,length=mpl::size<IndexSpecifierList>::value);
-
-  typedef typename  mpl::eval_if_c<
-    N==length,
-    mpl::identity<index_base<Value,IndexSpecifierList,Allocator> >,
-    mpl::apply2<
-      index_applier,
-      mpl::at_c<IndexSpecifierList,N>,
-      nth_layer<N+1,Value,IndexSpecifierList,Allocator>
-    >
-  >::type type;
-};
-
-template<typename Value,typename IndexSpecifierList,typename Allocator>
-struct multi_index_base_type:nth_layer<0,Value,IndexSpecifierList,Allocator>
-{
-  BOOST_STATIC_ASSERT(detail::is_index_list<IndexSpecifierList>::value);
-};
-
-} /* namespace multi_index::detail */
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/bidir_node_iterator.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/bidir_node_iterator.hpp
deleted file mode 100644
index 9be5ec84b43..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/bidir_node_iterator.hpp
+++ /dev/null
@@ -1,114 +0,0 @@
-/* Copyright 2003-2014 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_DETAIL_BIDIR_NODE_ITERATOR_HPP
-#define BOOST_MULTI_INDEX_DETAIL_BIDIR_NODE_ITERATOR_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <boost/operators.hpp>
-
-#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
-#include <boost/serialization/nvp.hpp>
-#include <boost/serialization/split_member.hpp>
-#endif
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-/* Iterator class for node-based indices with bidirectional
- * iterators (ordered and sequenced indices.)
- */
-
-template<typename Node>
-class bidir_node_iterator:
-  public bidirectional_iterator_helper<
-    bidir_node_iterator<Node>,
-    typename Node::value_type,
-    std::ptrdiff_t,
-    const typename Node::value_type*,
-    const typename Node::value_type&>
-{
-public:
-  /* coverity[uninit_ctor]: suppress warning */
-  bidir_node_iterator(){}
-  explicit bidir_node_iterator(Node* node_):node(node_){}
-
-  const typename Node::value_type& operator*()const
-  {
-    return node->value();
-  }
-
-  bidir_node_iterator& operator++()
-  {
-    Node::increment(node);
-    return *this;
-  }
-
-  bidir_node_iterator& operator--()
-  {
-    Node::decrement(node);
-    return *this;
-  }
-
-#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
-  /* Serialization. As for why the following is public,
-   * see explanation in safe_mode_iterator notes in safe_mode.hpp.
-   */
-
-  BOOST_SERIALIZATION_SPLIT_MEMBER()
-
-  typedef typename Node::base_type node_base_type;
-
-  template<class Archive>
-  void save(Archive& ar,const unsigned int)const
-  {
-    node_base_type* bnode=node;
-    ar<<serialization::make_nvp("pointer",bnode);
-  }
-
-  template<class Archive>
-  void load(Archive& ar,const unsigned int)
-  {
-    node_base_type* bnode;
-    ar>>serialization::make_nvp("pointer",bnode);
-    node=static_cast<Node*>(bnode);
-  }
-#endif
-
-  /* get_node is not to be used by the user */
-
-  typedef Node node_type;
-
-  Node* get_node()const{return node;}
-
-private:
-  Node* node;
-};
-
-template<typename Node>
-bool operator==(
-  const bidir_node_iterator<Node>& x,
-  const bidir_node_iterator<Node>& y)
-{
-  return x.get_node()==y.get_node();
-}
-
-} /* namespace multi_index::detail */
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/bucket_array.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/bucket_array.hpp
deleted file mode 100644
index d9fa434d9a9..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/bucket_array.hpp
+++ /dev/null
@@ -1,243 +0,0 @@
-/* Copyright 2003-2015 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_DETAIL_BUCKET_ARRAY_HPP
-#define BOOST_MULTI_INDEX_DETAIL_BUCKET_ARRAY_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <algorithm>
-#include <boost/multi_index/detail/auto_space.hpp>
-#include <boost/multi_index/detail/hash_index_node.hpp>
-#include <boost/noncopyable.hpp>
-#include <boost/preprocessor/repetition/repeat.hpp>
-#include <boost/preprocessor/seq/elem.hpp>
-#include <boost/preprocessor/seq/enum.hpp>
-#include <boost/preprocessor/seq/size.hpp>
-#include <cstddef>
-#include <limits.h>
-
-#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
-#include <boost/archive/archive_exception.hpp>
-#include <boost/serialization/access.hpp>
-#include <boost/throw_exception.hpp> 
-#endif
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-/* bucket structure for use by hashed indices */
-
-#define BOOST_MULTI_INDEX_BA_SIZES_32BIT                                  \
-(53ul)(97ul)(193ul)(389ul)(769ul)                                         \
-(1543ul)(3079ul)(6151ul)(12289ul)(24593ul)                                \
-(49157ul)(98317ul)(196613ul)(393241ul)(786433ul)                          \
-(1572869ul)(3145739ul)(6291469ul)(12582917ul)(25165843ul)                 \
-(50331653ul)(100663319ul)(201326611ul)(402653189ul)(805306457ul)          \
-(1610612741ul)(3221225473ul)
-
-#if ((((ULONG_MAX>>16)>>16)>>16)>>15)==0 /* unsigned long less than 64 bits */
-#define BOOST_MULTI_INDEX_BA_SIZES                                         \
-BOOST_MULTI_INDEX_BA_SIZES_32BIT                                           \
-(4294967291ul)
-#else
-  /* obtained with aid from
-   *   http://javaboutique.internet.com/prime_numb/
-   *   http://www.rsok.com/~jrm/next_ten_primes.html
-   * and verified with
-   *   http://www.alpertron.com.ar/ECM.HTM
-   */
-
-#define BOOST_MULTI_INDEX_BA_SIZES                                         \
-BOOST_MULTI_INDEX_BA_SIZES_32BIT                                           \
-(6442450939ul)(12884901893ul)(25769803751ul)(51539607551ul)                \
-(103079215111ul)(206158430209ul)(412316860441ul)(824633720831ul)           \
-(1649267441651ul)(3298534883309ul)(6597069766657ul)(13194139533299ul)      \
-(26388279066623ul)(52776558133303ul)(105553116266489ul)(211106232532969ul) \
-(422212465066001ul)(844424930131963ul)(1688849860263953ul)                 \
-(3377699720527861ul)(6755399441055731ul)(13510798882111483ul)              \
-(27021597764222939ul)(54043195528445957ul)(108086391056891903ul)           \
-(216172782113783843ul)(432345564227567621ul)(864691128455135207ul)         \
-(1729382256910270481ul)(3458764513820540933ul)(6917529027641081903ul)      \
-(13835058055282163729ul)(18446744073709551557ul)
-#endif
-
-template<bool _=true> /* templatized to have in-header static var defs */
-class bucket_array_base:private noncopyable
-{
-protected:
-  static const std::size_t sizes[
-    BOOST_PP_SEQ_SIZE(BOOST_MULTI_INDEX_BA_SIZES)];
-
-  static std::size_t size_index(std::size_t n)
-  {
-    const std::size_t *bound=std::lower_bound(sizes,sizes+sizes_length,n);
-    if(bound==sizes+sizes_length)--bound;
-    return bound-sizes;
-  }
-
-#define BOOST_MULTI_INDEX_BA_POSITION_CASE(z,n,_)                    \
-  case n:return hash%BOOST_PP_SEQ_ELEM(n,BOOST_MULTI_INDEX_BA_SIZES);
-
-  static std::size_t position(std::size_t hash,std::size_t size_index_)
-  {
-    /* Accelerate hash%sizes[size_index_] by replacing with a switch on
-     * hash%Ci expressions, each Ci a compile-time constant, which the
-     * compiler can implement without using integer division.
-     */
-
-    switch(size_index_){
-      default: /* never used */
-      BOOST_PP_REPEAT(
-        BOOST_PP_SEQ_SIZE(BOOST_MULTI_INDEX_BA_SIZES),
-        BOOST_MULTI_INDEX_BA_POSITION_CASE,~)
-    }
-  }
-
-private:
-  static const std::size_t sizes_length;
-};
-
-template<bool _>
-const std::size_t bucket_array_base<_>::sizes[]={
-  BOOST_PP_SEQ_ENUM(BOOST_MULTI_INDEX_BA_SIZES)
-};
-
-template<bool _>
-const std::size_t bucket_array_base<_>::sizes_length=
-  sizeof(bucket_array_base<_>::sizes)/
-  sizeof(bucket_array_base<_>::sizes[0]);
-
-#undef BOOST_MULTI_INDEX_BA_POSITION_CASE
-#undef BOOST_MULTI_INDEX_BA_SIZES
-#undef BOOST_MULTI_INDEX_BA_SIZES_32BIT
-
-template<typename Allocator>
-class bucket_array:bucket_array_base<>
-{
-  typedef bucket_array_base<>                        super;
-  typedef hashed_index_base_node_impl<
-    typename boost::detail::allocator::rebind_to<
-      Allocator,
-      char
-    >::type
-  >                                                  base_node_impl_type;
-
-public:
-  typedef typename base_node_impl_type::base_pointer base_pointer;
-  typedef typename base_node_impl_type::pointer      pointer;
-
-  bucket_array(const Allocator& al,pointer end_,std::size_t size_):
-    size_index_(super::size_index(size_)),
-    spc(al,super::sizes[size_index_]+1)
-  {
-    clear(end_);
-  }
-
-  std::size_t size()const
-  {
-    return super::sizes[size_index_];
-  }
-
-  std::size_t position(std::size_t hash)const
-  {
-    return super::position(hash,size_index_);
-  }
-
-  base_pointer begin()const{return buckets();}
-  base_pointer end()const{return buckets()+size();}
-  base_pointer at(std::size_t n)const{return buckets()+n;}
-
-  void clear(pointer end_)
-  {
-    for(base_pointer x=begin(),y=end();x!=y;++x)x->prior()=pointer(0);
-    end()->prior()=end_->prior()=end_;
-    end_->next()=end();
- }
-
-  void swap(bucket_array& x)
-  {
-    std::swap(size_index_,x.size_index_);
-    spc.swap(x.spc);
-  }
-
-private:
-  std::size_t                               size_index_;
-  auto_space<base_node_impl_type,Allocator> spc;
-
-  base_pointer buckets()const
-  {
-    return spc.data();
-  }
-
-#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
-  friend class boost::serialization::access;
-  
-  /* bucket_arrays do not emit any kind of serialization info. They are
-   * fed to Boost.Serialization as hashed index iterators need to track
-   * them during serialization.
-   */
-
-  template<class Archive>
-  void serialize(Archive&,const unsigned int)
-  {
-  }
-#endif
-};
-
-template<typename Allocator>
-void swap(bucket_array<Allocator>& x,bucket_array<Allocator>& y)
-{
-  x.swap(y);
-}
-
-} /* namespace multi_index::detail */
-
-} /* namespace multi_index */
-
-#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
-/* bucket_arrays never get constructed directly by Boost.Serialization,
- * as archives are always fed pointers to previously existent
- * arrays. So, if this is called it means we are dealing with a
- * somehow invalid archive.
- */
-
-#if defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)
-namespace serialization{
-#else
-namespace multi_index{
-namespace detail{
-#endif
-
-template<class Archive,typename Allocator>
-inline void load_construct_data(
-  Archive&,boost::multi_index::detail::bucket_array<Allocator>*,
-  const unsigned int)
-{
-  throw_exception(
-    archive::archive_exception(archive::archive_exception::other_exception));
-}
-
-#if defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)
-} /* namespace serialization */
-#else
-} /* namespace multi_index::detail */
-} /* namespace multi_index */
-#endif
-
-#endif
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/cons_stdtuple.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/cons_stdtuple.hpp
deleted file mode 100644
index 855c5e06aa9..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/cons_stdtuple.hpp
+++ /dev/null
@@ -1,93 +0,0 @@
-/* Copyright 2003-2014 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_DETAIL_CONS_STDTUPLE_HPP
-#define BOOST_MULTI_INDEX_DETAIL_CONS_STDTUPLE_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <boost/mpl/if.hpp>
-#include <boost/tuple/tuple.hpp>
-#include <tuple>
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-/* std::tuple wrapper providing the cons-based interface of boost::tuple for
- * composite_key interoperability.
- */
-
-template<typename StdTuple,std::size_t N>
-struct cons_stdtuple;
-
-struct cons_stdtuple_ctor_terminal
-{
-  typedef boost::tuples::null_type result_type;
-
-  template<typename StdTuple>
-  static result_type create(const StdTuple&)
-  {
-    return boost::tuples::null_type();
-  }
-};
-
-template<typename StdTuple,std::size_t N>
-struct cons_stdtuple_ctor_normal
-{
-  typedef cons_stdtuple<StdTuple,N> result_type;
-
-  static result_type create(const StdTuple& t)
-  {
-    return result_type(t);
-  }
-};
-
-template<typename StdTuple,std::size_t N=0>
-struct cons_stdtuple_ctor:
-  boost::mpl::if_c<
-    N<std::tuple_size<StdTuple>::value,
-    cons_stdtuple_ctor_normal<StdTuple,N>,
-    cons_stdtuple_ctor_terminal
-  >::type
-{};
-
-template<typename StdTuple,std::size_t N>
-struct cons_stdtuple
-{
-  typedef typename std::tuple_element<N,StdTuple>::type head_type;
-  typedef cons_stdtuple_ctor<StdTuple,N+1>              tail_ctor;
-  typedef typename tail_ctor::result_type               tail_type;
-  
-  cons_stdtuple(const StdTuple& t_):t(t_){}
-
-  const head_type& get_head()const{return std::get<N>(t);}
-  tail_type get_tail()const{return tail_ctor::create(t);}
-    
-  const StdTuple& t;
-};
-
-template<typename StdTuple>
-typename cons_stdtuple_ctor<StdTuple>::result_type
-make_cons_stdtuple(const StdTuple& t)
-{
-  return cons_stdtuple_ctor<StdTuple>::create(t);
-}
-
-} /* namespace multi_index::detail */
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/converter.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/converter.hpp
deleted file mode 100644
index 3e04a3e8295..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/converter.hpp
+++ /dev/null
@@ -1,52 +0,0 @@
-/* Copyright 2003-2013 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_DETAIL_CONVERTER_HPP
-#define BOOST_MULTI_INDEX_DETAIL_CONVERTER_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-/* converter offers means to access indices of a given multi_index_container
- * and for convertibilty between index iterators, so providing a
- * localized access point for get() and project() functions.
- */
-
-template<typename MultiIndexContainer,typename Index>
-struct converter
-{
-  static const Index& index(const MultiIndexContainer& x){return x;}
-  static Index&       index(MultiIndexContainer& x){return x;}
-
-  static typename Index::const_iterator const_iterator(
-    const MultiIndexContainer& x,typename MultiIndexContainer::node_type* node)
-  {
-    return x.Index::make_iterator(node);
-  }
-
-  static typename Index::iterator iterator(
-    MultiIndexContainer& x,typename MultiIndexContainer::node_type* node)
-  {
-    return x.Index::make_iterator(node);
-  }
-};
-
-} /* namespace multi_index::detail */
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/copy_map.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/copy_map.hpp
deleted file mode 100644
index 9a34b259cf3..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/copy_map.hpp
+++ /dev/null
@@ -1,142 +0,0 @@
-/* Copyright 2003-2015 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_DETAIL_COPY_MAP_HPP
-#define BOOST_MULTI_INDEX_DETAIL_COPY_MAP_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <algorithm>
-#include <boost/detail/no_exceptions_support.hpp>
-#include <boost/multi_index/detail/auto_space.hpp>
-#include <boost/multi_index/detail/raw_ptr.hpp>
-#include <boost/noncopyable.hpp>
-#include <cstddef>
-#include <functional>
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-/* copy_map is used as an auxiliary structure during copy_() operations.
- * When a container with n nodes is replicated, node_map holds the pairings
- * between original and copied nodes, and provides a fast way to find a
- * copied node from an original one.
- * The semantics of the class are not simple, and no attempt has been made
- * to enforce it: multi_index_container handles it right. On the other hand,
- * the const interface, which is the one provided to index implementations,
- * only allows for:
- *   - Enumeration of pairs of (original,copied) nodes (excluding the headers),
- *   - fast retrieval of copied nodes (including the headers.)
- */
-
-template <typename Node>
-struct copy_map_entry
-{
-  copy_map_entry(Node* f,Node* s):first(f),second(s){}
-
-  Node* first;
-  Node* second;
-
-  bool operator<(const copy_map_entry<Node>& x)const
-  {
-    return std::less<Node*>()(first,x.first);
-  }
-};
-
-template <typename Node,typename Allocator>
-class copy_map:private noncopyable
-{
-public:
-  typedef const copy_map_entry<Node>* const_iterator;
-
-  copy_map(
-    const Allocator& al,std::size_t size,Node* header_org,Node* header_cpy):
-    al_(al),size_(size),spc(al_,size_),n(0),
-    header_org_(header_org),header_cpy_(header_cpy),released(false)
-  {}
-
-  ~copy_map()
-  {
-    if(!released){
-      for(std::size_t i=0;i<n;++i){
-        boost::detail::allocator::destroy(&(spc.data()+i)->second->value());
-        deallocate((spc.data()+i)->second);
-      }
-    }
-  }
-
-  const_iterator begin()const{return raw_ptr<const_iterator>(spc.data());}
-  const_iterator end()const{return raw_ptr<const_iterator>(spc.data()+n);}
-
-  void clone(Node* node)
-  {
-    (spc.data()+n)->first=node;
-    (spc.data()+n)->second=raw_ptr<Node*>(al_.allocate(1));
-    BOOST_TRY{
-      boost::detail::allocator::construct(
-        &(spc.data()+n)->second->value(),node->value());
-    }
-    BOOST_CATCH(...){
-      deallocate((spc.data()+n)->second);
-      BOOST_RETHROW;
-    }
-    BOOST_CATCH_END
-    ++n;
-
-    if(n==size_){
-      std::sort(
-        raw_ptr<copy_map_entry<Node>*>(spc.data()),
-        raw_ptr<copy_map_entry<Node>*>(spc.data())+size_);
-    }
-  }
-
-  Node* find(Node* node)const
-  {
-    if(node==header_org_)return header_cpy_;
-    return std::lower_bound(
-      begin(),end(),copy_map_entry<Node>(node,0))->second;
-  }
-
-  void release()
-  {
-    released=true;
-  }
-
-private:
-  typedef typename boost::detail::allocator::rebind_to<
-    Allocator,Node
-  >::type                                               allocator_type;
-  typedef typename allocator_type::pointer              allocator_pointer;
-
-  allocator_type                                        al_;
-  std::size_t                                           size_;
-  auto_space<copy_map_entry<Node>,Allocator>            spc;
-  std::size_t                                           n;
-  Node*                                                 header_org_;
-  Node*                                                 header_cpy_;
-  bool                                                  released;
-
-  void deallocate(Node* node)
-  {
-    al_.deallocate(static_cast<allocator_pointer>(node),1);
-  }
-};
-
-} /* namespace multi_index::detail */
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/do_not_copy_elements_tag.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/do_not_copy_elements_tag.hpp
deleted file mode 100644
index f0fa7304253..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/do_not_copy_elements_tag.hpp
+++ /dev/null
@@ -1,34 +0,0 @@
-/* Copyright 2003-2013 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_DETAIL_DO_NOT_COPY_ELEMENTS_TAG_HPP
-#define BOOST_MULTI_INDEX_DETAIL_DO_NOT_COPY_ELEMENTS_TAG_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-/* Used to mark a special ctor variant that copies the internal objects of
- * a container but not its elements.
- */
-
-struct do_not_copy_elements_tag{};
-
-} /* namespace multi_index::detail */
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/duplicates_iterator.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/duplicates_iterator.hpp
deleted file mode 100644
index cbebf264045..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/duplicates_iterator.hpp
+++ /dev/null
@@ -1,120 +0,0 @@
-/* Copyright 2003-2013 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_DETAIL_DUPLICATES_ITERATOR_HPP
-#define BOOST_MULTI_INDEX_DETAIL_DUPLICATES_ITERATOR_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <cstddef>
-#include <iterator>
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-/* duplicates_operator is given a range of ordered elements and
- * passes only over those which are duplicated.
- */
-
-template<typename Node,typename Predicate>
-class duplicates_iterator
-{
-public:
-  typedef typename Node::value_type        value_type;
-  typedef std::ptrdiff_t                   difference_type;
-  typedef const typename Node::value_type* pointer;
-  typedef const typename Node::value_type& reference;
-  typedef std::forward_iterator_tag        iterator_category;
-
-  duplicates_iterator(Node* node_,Node* end_,Predicate pred_):
-    node(node_),begin_chunk(0),end(end_),pred(pred_)
-  {
-    advance();
-  }
-
-  duplicates_iterator(Node* end_,Predicate pred_):
-    node(end_),begin_chunk(end_),end(end_),pred(pred_)
-  {
-  }
-
-  reference operator*()const
-  {
-    return node->value();
-  }
-
-  pointer operator->()const
-  {
-    return &node->value();
-  }
-
-  duplicates_iterator& operator++()
-  {
-    Node::increment(node);
-    sync();
-    return *this;
-  }
-
-  duplicates_iterator operator++(int)
-  {
-    duplicates_iterator tmp(*this);
-    ++(*this);
-    return tmp;
-  }
-
-  Node* get_node()const{return node;}
-
-private:
-  void sync()
-  {
-    if(node!=end&&pred(begin_chunk->value(),node->value()))advance();
-  }
-
-  void advance()
-  {
-    for(Node* node2=node;node!=end;node=node2){
-      Node::increment(node2);
-      if(node2!=end&&!pred(node->value(),node2->value()))break;
-    }
-    begin_chunk=node;
-  }
-
-  Node*     node;
-  Node*     begin_chunk;
-  Node*     end;
-  Predicate pred;
-};
-
-template<typename Node,typename Predicate>
-bool operator==(
-  const duplicates_iterator<Node,Predicate>& x,
-  const duplicates_iterator<Node,Predicate>& y)
-{
-  return x.get_node()==y.get_node();
-}
-
-template<typename Node,typename Predicate>
-bool operator!=(
-  const duplicates_iterator<Node,Predicate>& x,
-  const duplicates_iterator<Node,Predicate>& y)
-{
-  return !(x==y);
-}
-
-} /* namespace multi_index::detail */
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/has_tag.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/has_tag.hpp
deleted file mode 100644
index 217b61143af..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/has_tag.hpp
+++ /dev/null
@@ -1,42 +0,0 @@
-/* Copyright 2003-2013 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_DETAIL_HAS_TAG_HPP
-#define BOOST_MULTI_INDEX_DETAIL_HAS_TAG_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <boost/mpl/contains.hpp>
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-/* determines whether an index type has a given tag in its tag list */
-
-template<typename Tag>
-struct has_tag
-{
-  template<typename Index>
-  struct apply:mpl::contains<BOOST_DEDUCED_TYPENAME Index::tag_list,Tag>
-  {
-  }; 
-};
-
-} /* namespace multi_index::detail */
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/hash_index_args.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/hash_index_args.hpp
deleted file mode 100644
index 81902f5a4a5..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/hash_index_args.hpp
+++ /dev/null
@@ -1,105 +0,0 @@
-/* Copyright 2003-2013 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_DETAIL_HASH_INDEX_ARGS_HPP
-#define BOOST_MULTI_INDEX_DETAIL_HASH_INDEX_ARGS_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <boost/functional/hash.hpp>
-#include <boost/mpl/aux_/na.hpp>
-#include <boost/mpl/eval_if.hpp>
-#include <boost/mpl/identity.hpp>
-#include <boost/mpl/if.hpp>
-#include <boost/multi_index/tag.hpp>
-#include <boost/static_assert.hpp>
-#include <boost/type_traits/is_same.hpp>
-#include <functional>
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-/* Hashed index specifiers can be instantiated in two forms:
- *
- *   (hashed_unique|hashed_non_unique)<
- *     KeyFromValue,
- *     Hash=boost::hash<KeyFromValue::result_type>,
- *     Pred=std::equal_to<KeyFromValue::result_type> >
- *   (hashed_unique|hashed_non_unique)<
- *     TagList,
- *     KeyFromValue,
- *     Hash=boost::hash<KeyFromValue::result_type>,
- *     Pred=std::equal_to<KeyFromValue::result_type> >
- *
- * hashed_index_args implements the machinery to accept this
- * argument-dependent polymorphism.
- */
-
-template<typename KeyFromValue>
-struct index_args_default_hash
-{
-  typedef ::boost::hash<typename KeyFromValue::result_type> type;
-};
-
-template<typename KeyFromValue>
-struct index_args_default_pred
-{
-  typedef std::equal_to<typename KeyFromValue::result_type> type;
-};
-
-template<typename Arg1,typename Arg2,typename Arg3,typename Arg4>
-struct hashed_index_args
-{
-  typedef is_tag<Arg1> full_form;
-
-  typedef typename mpl::if_<
-    full_form,
-    Arg1,
-    tag< > >::type                                   tag_list_type;
-  typedef typename mpl::if_<
-    full_form,
-    Arg2,
-    Arg1>::type                                      key_from_value_type;
-  typedef typename mpl::if_<
-    full_form,
-    Arg3,
-    Arg2>::type                                      supplied_hash_type;
-  typedef typename mpl::eval_if<
-    mpl::is_na<supplied_hash_type>,
-    index_args_default_hash<key_from_value_type>,
-    mpl::identity<supplied_hash_type>
-  >::type                                            hash_type;
-  typedef typename mpl::if_<
-    full_form,
-    Arg4,
-    Arg3>::type                                      supplied_pred_type;
-  typedef typename mpl::eval_if<
-    mpl::is_na<supplied_pred_type>,
-    index_args_default_pred<key_from_value_type>,
-    mpl::identity<supplied_pred_type>
-  >::type                                            pred_type;
-
-  BOOST_STATIC_ASSERT(is_tag<tag_list_type>::value);
-  BOOST_STATIC_ASSERT(!mpl::is_na<key_from_value_type>::value);
-  BOOST_STATIC_ASSERT(!mpl::is_na<hash_type>::value);
-  BOOST_STATIC_ASSERT(!mpl::is_na<pred_type>::value);
-};
-
-} /* namespace multi_index::detail */
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/hash_index_iterator.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/hash_index_iterator.hpp
deleted file mode 100644
index 8d063002a1d..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/hash_index_iterator.hpp
+++ /dev/null
@@ -1,166 +0,0 @@
-/* Copyright 2003-2014 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_DETAIL_HASH_INDEX_ITERATOR_HPP
-#define BOOST_MULTI_INDEX_DETAIL_HASH_INDEX_ITERATOR_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <boost/operators.hpp>
-
-#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
-#include <boost/serialization/nvp.hpp>
-#include <boost/serialization/split_member.hpp>
-#include <boost/serialization/version.hpp>
-#endif
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-/* Iterator class for hashed indices.
- */
-
-struct hashed_index_global_iterator_tag{};
-struct hashed_index_local_iterator_tag{};
-
-template<typename Node,typename BucketArray,typename Category>
-class hashed_index_iterator:
-  public forward_iterator_helper<
-    hashed_index_iterator<Node,BucketArray,Category>,
-    typename Node::value_type,
-    std::ptrdiff_t,
-    const typename Node::value_type*,
-    const typename Node::value_type&>
-{
-public:
-  /* coverity[uninit_ctor]: suppress warning */
-  hashed_index_iterator(){}
-  hashed_index_iterator(Node* node_):node(node_){}
-
-  const typename Node::value_type& operator*()const
-  {
-    return node->value();
-  }
-
-  hashed_index_iterator& operator++()
-  {
-    this->increment(Category());
-    return *this;
-  }
-
-#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
-  /* Serialization. As for why the following is public,
-   * see explanation in safe_mode_iterator notes in safe_mode.hpp.
-   */
-  
-  BOOST_SERIALIZATION_SPLIT_MEMBER()
-
-  typedef typename Node::base_type node_base_type;
-
-  template<class Archive>
-  void save(Archive& ar,const unsigned int)const
-  {
-    node_base_type* bnode=node;
-    ar<<serialization::make_nvp("pointer",bnode);
-  }
-
-  template<class Archive>
-  void load(Archive& ar,const unsigned int version)
-  {
-    load(ar,version,Category());
-  }
-
-  template<class Archive>
-  void load(
-    Archive& ar,const unsigned int version,hashed_index_global_iterator_tag)
-  {
-    node_base_type* bnode;
-    ar>>serialization::make_nvp("pointer",bnode);
-    node=static_cast<Node*>(bnode);
-    if(version<1){
-      BucketArray* throw_away; /* consume unused ptr */
-      ar>>serialization::make_nvp("pointer",throw_away);
-    }
-  }
-
-  template<class Archive>
-  void load(
-    Archive& ar,const unsigned int version,hashed_index_local_iterator_tag)
-  {
-    node_base_type* bnode;
-    ar>>serialization::make_nvp("pointer",bnode);
-    node=static_cast<Node*>(bnode);
-    if(version<1){
-      BucketArray* buckets;
-      ar>>serialization::make_nvp("pointer",buckets);
-      if(buckets&&node&&node->impl()==buckets->end()->prior()){
-        /* end local_iterators used to point to end node, now they are null */
-        node=0;
-      }
-    }
-  }
-#endif
-
-  /* get_node is not to be used by the user */
-
-  typedef Node node_type;
-
-  Node* get_node()const{return node;}
-
-private:
-
-  void increment(hashed_index_global_iterator_tag)
-  {
-    Node::increment(node);
-  }
-
-  void increment(hashed_index_local_iterator_tag)
-  {
-    Node::increment_local(node);
-  }
-
-  Node* node;
-};
-
-template<typename Node,typename BucketArray,typename Category>
-bool operator==(
-  const hashed_index_iterator<Node,BucketArray,Category>& x,
-  const hashed_index_iterator<Node,BucketArray,Category>& y)
-{
-  return x.get_node()==y.get_node();
-}
-
-} /* namespace multi_index::detail */
-
-} /* namespace multi_index */
-
-#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
-/* class version = 1 : hashed_index_iterator does no longer serialize a bucket
- * array pointer.
- */
-
-namespace serialization {
-template<typename Node,typename BucketArray,typename Category>
-struct version<
-  boost::multi_index::detail::hashed_index_iterator<Node,BucketArray,Category>
->
-{
-  BOOST_STATIC_CONSTANT(int,value=1);
-};
-} /* namespace serialization */
-#endif
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/hash_index_node.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/hash_index_node.hpp
deleted file mode 100644
index 7788e810ac9..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/hash_index_node.hpp
+++ /dev/null
@@ -1,778 +0,0 @@
-/* Copyright 2003-2015 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_DETAIL_HASH_INDEX_NODE_HPP
-#define BOOST_MULTI_INDEX_DETAIL_HASH_INDEX_NODE_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <boost/detail/allocator_utilities.hpp>
-#include <boost/multi_index/detail/raw_ptr.hpp>
-#include <utility>
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-/* Certain C++ requirements on unordered associative containers (see LWG issue
- * #579) imply a data structure where nodes are linked in a single list, which
- * in its turn forces implementors to add additional overhed per node to
- * associate each with its corresponding bucket. Others resort to storing hash
- * values, we use an alternative structure providing unconditional O(1)
- * manipulation, even in situations of unfair hash distribution, plus some
- * lookup speedups. For unique indices we maintain a doubly linked list of
- * nodes except that if N is the first node of a bucket its associated
- * bucket node is embedded between N and the preceding node in the following
- * manner:
- *
- *        +---+   +---+       +---+   +---+
- *     <--+   |<--+   |    <--+   |<--+   |
- *   ...  | B0|   | B1|  ...  | B1|   | B2|  ...
- *        |   |-+ |   +-->    |   |-+ |   +-->
- *        +-+-+ | +---+       +-+-+ | +---+
- *              |   ^               |   ^
- *              |   |               |   |
- *              | +-+               | +-+
- *              | |                 | |
- *              v |                 v |  
- *       --+---+---+---+--   --+---+---+---+--
- *     ... |   | B1|   |  ...  |   | B2|   | ...
- *       --+---+---+---+--   --+---+---+---+--
- *
- *
- * The fist and last nodes of buckets can be checked with
- *
- *   first node of a bucket: Npn != N
- *   last node of a bucket:  Nnp != N
- *
- * (n and p short for ->next(), ->prior(), bucket nodes have prior pointers
- * only). Pure insert and erase (without lookup) can be unconditionally done
- * in O(1).
- * For non-unique indices we add the following additional complexity: when
- * there is a group of 3 or more equivalent elements, they are linked as
- * follows:
- *
- *         +-----------------------+
- *         |                       v
- *   +---+ | +---+       +---+   +---+
- *   |   | +-+   |       |   |<--+   |
- *   | F |   | S |  ...  | P |   | L |
- *   |   +-->|   |       |   +-+ |   |
- *   +---+   +---+       +---+ | +---+
- *     ^                       |
- *     +-----------------------+
- * 
- * F, S, P and L are the first, second, penultimate and last node in the
- * group, respectively (S and P can coincide if the group has size 3.) This
- * arrangement is used to skip equivalent elements in O(1) when doing lookup,
- * while preserving O(1) insert/erase. The following invariants identify
- * special positions (some of the operations have to be carefully implemented
- * as Xnn is not valid if Xn points to a bucket):
- *
- *   first node of a bucket: Npnp  == N
- *   last node of a bucket:  Nnpp  == N
- *   first node of a group:  Nnp != N && Nnppn == N
- *   second node of a group: Npn != N && Nppnn == N
- *   n-1 node of a group:    Nnp != N && Nnnpp == N
- *   last node of a group:   Npn != N && Npnnp == N
- * 
- * The memory overhead is one pointer per bucket plus two pointers per node,
- * probably unbeatable. The resulting structure is bidirectonally traversable,
- * though currently we are just providing forward iteration.
- */
-
-template<typename Allocator>
-struct hashed_index_node_impl;
-
-/* half-header (only prior() pointer) to use for the bucket array */
-
-template<typename Allocator>
-struct hashed_index_base_node_impl
-{
-  typedef typename
-  boost::detail::allocator::rebind_to<
-      Allocator,hashed_index_base_node_impl
-  >::type::pointer                          base_pointer;
-  typedef typename
-  boost::detail::allocator::rebind_to<
-    Allocator,hashed_index_base_node_impl
-  >::type::const_pointer                    const_base_pointer;
-  typedef typename
-  boost::detail::allocator::rebind_to<
-    Allocator,
-    hashed_index_node_impl<Allocator>
-  >::type::pointer                          pointer;
-  typedef typename
-  boost::detail::allocator::rebind_to<
-    Allocator,
-    hashed_index_node_impl<Allocator>
-  >::type::const_pointer                    const_pointer;
-
-  pointer& prior(){return prior_;}
-  pointer  prior()const{return prior_;}
-
-private:
-  pointer prior_;
-};
-
-/* full header (prior() and next()) for the nodes */
-
-template<typename Allocator>
-struct hashed_index_node_impl:hashed_index_base_node_impl<Allocator>
-{
-private:
-  typedef hashed_index_base_node_impl<Allocator> super;
-
-public:  
-  typedef typename super::base_pointer           base_pointer;
-  typedef typename super::const_base_pointer     const_base_pointer;
-  typedef typename super::pointer                pointer;
-  typedef typename super::const_pointer          const_pointer;
-
-  base_pointer& next(){return next_;}
-  base_pointer  next()const{return next_;}
-
-  static pointer pointer_from(base_pointer x)
-  {
-    return static_cast<pointer>(
-      static_cast<hashed_index_node_impl*>(
-        raw_ptr<super*>(x)));
-  }
-
-  static base_pointer base_pointer_from(pointer x)
-  {
-    return static_cast<base_pointer>(
-      raw_ptr<hashed_index_node_impl*>(x));
-  }
-
-private:
-  base_pointer next_;
-};
-
-/* Boost.MultiIndex requires machinery to reverse unlink operations. A simple
- * way to make a pointer-manipulation function undoable is to templatize
- * its internal pointer assignments with a functor that, besides doing the
- * assignment, keeps track of the original pointer values and can later undo
- * the operations in reverse order.
- */
-
-struct default_assigner
-{
-  template<typename T> void operator()(T& x,const T& val){x=val;}
-};
-
-template<typename Node>
-struct unlink_undo_assigner
-{
-  typedef typename Node::base_pointer base_pointer;
-  typedef typename Node::pointer      pointer;
-
-  unlink_undo_assigner():pointer_track_count(0),base_pointer_track_count(0){}
-
-  void operator()(pointer& x,pointer val)
-  {
-    pointer_tracks[pointer_track_count].x=&x;
-    pointer_tracks[pointer_track_count++].val=x;
-    x=val;
-  }
-
-  void operator()(base_pointer& x,base_pointer val)
-  {
-    base_pointer_tracks[base_pointer_track_count].x=&x;
-    base_pointer_tracks[base_pointer_track_count++].val=x;
-    x=val;
-  }
-
-  void operator()() /* undo op */
-  {
-    /* in the absence of aliasing, restitution order is immaterial */
-
-    while(pointer_track_count--){
-      *(pointer_tracks[pointer_track_count].x)=
-        pointer_tracks[pointer_track_count].val;
-    }
-    while(base_pointer_track_count--){
-      *(base_pointer_tracks[base_pointer_track_count].x)=
-        base_pointer_tracks[base_pointer_track_count].val;
-    }
-  }
-
-  struct pointer_track     {pointer*      x; pointer      val;};
-  struct base_pointer_track{base_pointer* x; base_pointer val;};
-
-  /* We know the maximum number of pointer and base pointer assignments that
-   * the two unlink versions do, so we can statically reserve the needed
-   * storage.
-   */
-
-  pointer_track      pointer_tracks[3];
-  int                pointer_track_count;
-  base_pointer_track base_pointer_tracks[2];
-  int                base_pointer_track_count;
-};
-
-/* algorithmic stuff for unique and non-unique variants */
-
-struct hashed_unique_tag{};
-struct hashed_non_unique_tag{};
-
-template<typename Node,typename Category>
-struct hashed_index_node_alg;
-
-template<typename Node>
-struct hashed_index_node_alg<Node,hashed_unique_tag>
-{
-  typedef typename Node::base_pointer       base_pointer;
-  typedef typename Node::const_base_pointer const_base_pointer;
-  typedef typename Node::pointer            pointer;
-  typedef typename Node::const_pointer      const_pointer;
-
-  static bool is_first_of_bucket(pointer x)
-  {
-    return x->prior()->next()!=base_pointer_from(x);
-  }
-
-  static pointer after(pointer x)
-  {
-    return is_last_of_bucket(x)?x->next()->prior():pointer_from(x->next());
-  }
-
-  static pointer after_local(pointer x)
-  {
-    return is_last_of_bucket(x)?pointer(0):pointer_from(x->next());
-  }
-
-  static pointer next_to_inspect(pointer x)
-  {
-    return is_last_of_bucket(x)?pointer(0):pointer_from(x->next());
-  }
-
-  static void link(pointer x,base_pointer buc,pointer end)
-  {
-    if(buc->prior()==pointer(0)){ /* empty bucket */
-      x->prior()=end->prior();
-      x->next()=end->prior()->next();
-      x->prior()->next()=buc;
-      buc->prior()=x;
-      end->prior()=x;
-    }
-    else{
-      x->prior()=buc->prior()->prior();
-      x->next()=base_pointer_from(buc->prior());
-      buc->prior()=x;
-      x->next()->prior()=x;
-    }
-  }
-
-  static void unlink(pointer x)
-  {
-    default_assigner assign;
-    unlink(x,assign);
-  }
-
-  typedef unlink_undo_assigner<Node> unlink_undo;
-
-  template<typename Assigner>
-  static void unlink(pointer x,Assigner& assign)
-  {
-    if(is_first_of_bucket(x)){
-      if(is_last_of_bucket(x)){
-        assign(x->prior()->next()->prior(),pointer(0));
-        assign(x->prior()->next(),x->next());
-        assign(x->next()->prior()->prior(),x->prior());
-      }
-      else{
-        assign(x->prior()->next()->prior(),pointer_from(x->next()));
-        assign(x->next()->prior(),x->prior());
-      }
-    }
-    else if(is_last_of_bucket(x)){
-      assign(x->prior()->next(),x->next());
-      assign(x->next()->prior()->prior(),x->prior());
-    }
-    else{
-      assign(x->prior()->next(),x->next());
-      assign(x->next()->prior(),x->prior());
-    }
-  }
-
-  /* used only at rehashing */
-
-  static void append(pointer x,pointer end)
-  {
-    x->prior()=end->prior();
-    x->next()=end->prior()->next();
-    x->prior()->next()=base_pointer_from(x);
-    end->prior()=x;
-  }
-
-  static bool unlink_last(pointer end)
-  {
-    /* returns true iff bucket is emptied */
-
-    pointer x=end->prior();
-    if(x->prior()->next()==base_pointer_from(x)){
-      x->prior()->next()=x->next();
-      end->prior()=x->prior();
-      return false;
-    }
-    else{
-      x->prior()->next()->prior()=pointer(0);
-      x->prior()->next()=x->next();
-      end->prior()=x->prior();
-      return true;
-    }
-  }
-
-private:
-  static pointer pointer_from(base_pointer x)
-  {
-    return Node::pointer_from(x);
-  }
-
-  static base_pointer base_pointer_from(pointer x)
-  {
-    return Node::base_pointer_from(x);
-  }
-
-  static bool is_last_of_bucket(pointer x)
-  {
-    return x->next()->prior()!=x;
-  }
-};
-
-template<typename Node>
-struct hashed_index_node_alg<Node,hashed_non_unique_tag>
-{
-  typedef typename Node::base_pointer       base_pointer;
-  typedef typename Node::const_base_pointer const_base_pointer;
-  typedef typename Node::pointer            pointer;
-  typedef typename Node::const_pointer      const_pointer;
-
-  static bool is_first_of_bucket(pointer x)
-  {
-    return x->prior()->next()->prior()==x;
-  }
-
-  static bool is_first_of_group(pointer x)
-  {
-    return
-      x->next()->prior()!=x&&
-      x->next()->prior()->prior()->next()==base_pointer_from(x);
-  }
-
-  static pointer after(pointer x)
-  {
-    if(x->next()->prior()==x)return pointer_from(x->next());
-    if(x->next()->prior()->prior()==x)return x->next()->prior();
-    if(x->next()->prior()->prior()->next()==base_pointer_from(x))
-      return pointer_from(x->next());
-    return pointer_from(x->next())->next()->prior();
-  }
-
-  static pointer after_local(pointer x)
-  {
-    if(x->next()->prior()==x)return pointer_from(x->next());
-    if(x->next()->prior()->prior()==x)return pointer(0);
-    if(x->next()->prior()->prior()->next()==base_pointer_from(x))
-      return pointer_from(x->next());
-    return pointer_from(x->next())->next()->prior();
-  }
-
-  static pointer next_to_inspect(pointer x)
-  {
-    if(x->next()->prior()==x)return pointer_from(x->next());
-    if(x->next()->prior()->prior()==x)return pointer(0);
-    if(x->next()->prior()->next()->prior()!=x->next()->prior())
-      return pointer(0);
-    return pointer_from(x->next()->prior()->next());
-  }
-
-  static void link(pointer x,base_pointer buc,pointer end)
-  {
-    if(buc->prior()==pointer(0)){ /* empty bucket */
-      x->prior()=end->prior();
-      x->next()=end->prior()->next();
-      x->prior()->next()=buc;
-      buc->prior()=x;
-      end->prior()=x;
-    }
-    else{
-      x->prior()=buc->prior()->prior();
-      x->next()=base_pointer_from(buc->prior());
-      buc->prior()=x;
-      x->next()->prior()=x;
-    }
-  };
-
-  static void link(pointer x,pointer first,pointer last)
-  {
-    x->prior()=first->prior();
-    x->next()=base_pointer_from(first);
-    if(is_first_of_bucket(first)){
-      x->prior()->next()->prior()=x;
-    }
-    else{
-      x->prior()->next()=base_pointer_from(x);
-    }
-
-    if(first==last){
-      last->prior()=x;
-    }
-    else if(first->next()==base_pointer_from(last)){
-      first->prior()=last;
-      first->next()=base_pointer_from(x);
-    }
-    else{
-      pointer second=pointer_from(first->next()),
-              lastbutone=last->prior();
-      second->prior()=first;
-      first->prior()=last;
-      lastbutone->next()=base_pointer_from(x);
-    }
-  }
-
-  static void unlink(pointer x)
-  {
-    default_assigner assign;
-    unlink(x,assign);
-  }
-
-  typedef unlink_undo_assigner<Node> unlink_undo;
-
-  template<typename Assigner>
-  static void unlink(pointer x,Assigner& assign)
-  {
-    if(x->prior()->next()==base_pointer_from(x)){
-      if(x->next()->prior()==x){
-        left_unlink(x,assign);
-        right_unlink(x,assign);
-      }
-      else if(x->next()->prior()->prior()==x){           /* last of bucket */
-        left_unlink(x,assign);
-        right_unlink_last_of_bucket(x,assign);
-      }
-      else if(x->next()->prior()->prior()->next()==
-              base_pointer_from(x)){                /* first of group size */
-        left_unlink(x,assign);
-        right_unlink_first_of_group(x,assign);
-      }
-      else{                                                /* n-1 of group */
-        unlink_last_but_one_of_group(x,assign);
-      }
-    }
-    else if(x->prior()->next()->prior()==x){            /* first of bucket */
-      if(x->next()->prior()==x){
-        left_unlink_first_of_bucket(x,assign);
-        right_unlink(x,assign);
-      }
-      else if(x->next()->prior()->prior()==x){           /* last of bucket */
-        assign(x->prior()->next()->prior(),pointer(0));
-        assign(x->prior()->next(),x->next());
-        assign(x->next()->prior()->prior(),x->prior());
-      }
-      else{                                              /* first of group */
-        left_unlink_first_of_bucket(x,assign);
-        right_unlink_first_of_group(x,assign);
-      }
-    }
-    else if(x->next()->prior()->prior()==x){   /* last of group and bucket */
-      left_unlink_last_of_group(x,assign);
-      right_unlink_last_of_bucket(x,assign);
-    }
-    else if(pointer_from(x->prior()->prior()->next())
-            ->next()==base_pointer_from(x)){            /* second of group */
-      unlink_second_of_group(x,assign);
-    }
-    else{                              /* last of group, ~(last of bucket) */
-      left_unlink_last_of_group(x,assign);
-      right_unlink(x,assign);
-    }
-  }
-
-  /* used only at rehashing */
-
-  static void link_range(
-    pointer first,pointer last,base_pointer buc,pointer cend)
-  {
-    if(buc->prior()==pointer(0)){ /* empty bucket */
-      first->prior()=cend->prior();
-      last->next()=cend->prior()->next();
-      first->prior()->next()=buc;
-      buc->prior()=first;
-      cend->prior()=last;
-    }
-    else{
-      first->prior()=buc->prior()->prior();
-      last->next()=base_pointer_from(buc->prior());
-      buc->prior()=first;
-      last->next()->prior()=last;
-    }
-  }
-
-  static void append_range(pointer first,pointer last,pointer cend)
-  {
-    first->prior()=cend->prior();
-    last->next()=cend->prior()->next();
-    first->prior()->next()=base_pointer_from(first);
-    cend->prior()=last;
-  }
-
-  static std::pair<pointer,bool> unlink_last_group(pointer end)
-  {
-    /* returns first of group true iff bucket is emptied */
-
-    pointer x=end->prior();
-    if(x->prior()->next()==base_pointer_from(x)){
-      x->prior()->next()=x->next();
-      end->prior()=x->prior();
-      return std::make_pair(x,false);
-    }
-    else if(x->prior()->next()->prior()==x){
-      x->prior()->next()->prior()=pointer(0);
-      x->prior()->next()=x->next();
-      end->prior()=x->prior();
-      return std::make_pair(x,true);
-    }
-    else{
-      pointer y=pointer_from(x->prior()->next());
-
-      if(y->prior()->next()==base_pointer_from(y)){
-        y->prior()->next()=x->next();
-        end->prior()=y->prior();
-        return std::make_pair(y,false);
-      }
-      else{
-        y->prior()->next()->prior()=pointer(0);
-        y->prior()->next()=x->next();
-        end->prior()=y->prior();
-        return std::make_pair(y,true);
-      }
-    }
-  }
-
-  static void unlink_range(pointer first,pointer last)
-  {
-    if(is_first_of_bucket(first)){
-      if(is_last_of_bucket(last)){
-        first->prior()->next()->prior()=pointer(0);
-        first->prior()->next()=last->next();
-        last->next()->prior()->prior()=first->prior();
-      }
-      else{
-        first->prior()->next()->prior()=pointer_from(last->next());
-        last->next()->prior()=first->prior();
-      }
-    }
-    else if(is_last_of_bucket(last)){
-      first->prior()->next()=last->next();
-      last->next()->prior()->prior()=first->prior();
-    }
-    else{
-      first->prior()->next()=last->next();
-      last->next()->prior()=first->prior();
-    }
-  }
-
-private:
-  static pointer pointer_from(base_pointer x)
-  {
-    return Node::pointer_from(x);
-  }
-
-  static base_pointer base_pointer_from(pointer x)
-  {
-    return Node::base_pointer_from(x);
-  }
-
-  static bool is_last_of_bucket(pointer x)
-  {
-    return x->next()->prior()->prior()==x;
-  }
-
-  template<typename Assigner>
-  static void left_unlink(pointer x,Assigner& assign)
-  {
-    assign(x->prior()->next(),x->next());
-  }
-  
-  template<typename Assigner>
-  static void right_unlink(pointer x,Assigner& assign)
-  {
-    assign(x->next()->prior(),x->prior());
-  }
-
-  template<typename Assigner>
-  static void left_unlink_first_of_bucket(pointer x,Assigner& assign)
-  {
-    assign(x->prior()->next()->prior(),pointer_from(x->next()));
-  }
-
-  template<typename Assigner>
-  static void right_unlink_last_of_bucket(pointer x,Assigner& assign)
-  {
-    assign(x->next()->prior()->prior(),x->prior());
-  }
-
-  template<typename Assigner>
-  static void right_unlink_first_of_group(pointer x,Assigner& assign)
-  {
-    pointer second=pointer_from(x->next()),
-            last=second->prior(),
-            lastbutone=last->prior();
-    if(second==lastbutone){
-      assign(second->next(),base_pointer_from(last));
-      assign(second->prior(),x->prior());
-    }
-    else{
-      assign(lastbutone->next(),base_pointer_from(second));
-      assign(second->next()->prior(),last);
-      assign(second->prior(),x->prior());
-    }
-  }
-
-  template<typename Assigner>
-  static void left_unlink_last_of_group(pointer x,Assigner& assign)
-  {
-    pointer lastbutone=x->prior(),
-            first=pointer_from(lastbutone->next()),
-            second=pointer_from(first->next());
-    if(lastbutone==second){
-      assign(lastbutone->prior(),first);
-      assign(lastbutone->next(),x->next());
-    }
-    else{
-      assign(second->prior(),lastbutone);
-      assign(lastbutone->prior()->next(),base_pointer_from(first));
-      assign(lastbutone->next(),x->next());
-    }
-  }
-
-  template<typename Assigner>
-  static void unlink_last_but_one_of_group(pointer x,Assigner& assign)
-  {
-    pointer first=pointer_from(x->next()),
-            second=pointer_from(first->next()),
-            last=second->prior();
-    if(second==x){
-      assign(last->prior(),first);
-      assign(first->next(),base_pointer_from(last));
-    }
-    else{
-      assign(last->prior(),x->prior());
-      assign(x->prior()->next(),base_pointer_from(first));
-    }
-  }
-
-  template<typename Assigner>
-  static void unlink_second_of_group(pointer x,Assigner& assign)
-  {
-    pointer last=x->prior(),
-            lastbutone=last->prior(),
-            first=pointer_from(lastbutone->next());
-    if(lastbutone==x){
-      assign(first->next(),base_pointer_from(last));
-      assign(last->prior(),first);
-    }
-    else{
-      assign(first->next(),x->next());
-      assign(x->next()->prior(),last);
-    }
-  }
-};
-
-template<typename Super>
-struct hashed_index_node_trampoline:
-  hashed_index_node_impl<
-    typename boost::detail::allocator::rebind_to<
-      typename Super::allocator_type,
-      char
-    >::type
-  >
-{
-  typedef typename boost::detail::allocator::rebind_to<
-    typename Super::allocator_type,
-    char
-  >::type                                               impl_allocator_type;
-  typedef hashed_index_node_impl<impl_allocator_type>   impl_type;
-};
-
-template<typename Super,typename Category>
-struct hashed_index_node:
-  Super,hashed_index_node_trampoline<Super>
-{
-private:
-  typedef hashed_index_node_trampoline<Super> trampoline;
-
-public:
-  typedef typename trampoline::impl_type          impl_type;
-  typedef hashed_index_node_alg<
-    impl_type,Category>                           node_alg;
-  typedef typename trampoline::base_pointer       impl_base_pointer;
-  typedef typename trampoline::const_base_pointer const_impl_base_pointer;
-  typedef typename trampoline::pointer            impl_pointer;
-  typedef typename trampoline::const_pointer      const_impl_pointer;
-
-  impl_pointer&      prior(){return trampoline::prior();}
-  impl_pointer       prior()const{return trampoline::prior();}
-  impl_base_pointer& next(){return trampoline::next();}
-  impl_base_pointer  next()const{return trampoline::next();}
-
-  impl_pointer impl()
-  {
-    return static_cast<impl_pointer>(
-      static_cast<impl_type*>(static_cast<trampoline*>(this)));
-  }
-
-  const_impl_pointer impl()const
-  {
-    return static_cast<const_impl_pointer>(
-      static_cast<const impl_type*>(static_cast<const trampoline*>(this)));
-  }
-
-  static hashed_index_node* from_impl(impl_pointer x)
-  {
-    return
-      static_cast<hashed_index_node*>(
-        static_cast<trampoline*>(
-          raw_ptr<impl_type*>(x)));
-  }
-
-  static const hashed_index_node* from_impl(const_impl_pointer x)
-  {
-    return 
-      static_cast<const hashed_index_node*>(
-        static_cast<const trampoline*>(
-          raw_ptr<const impl_type*>(x)));
-  }
-
-  /* interoperability with hashed_index_iterator */
-
-  static void increment(hashed_index_node*& x)
-  {
-    x=from_impl(node_alg::after(x->impl()));
-  }
-
-  static void increment_local(hashed_index_node*& x)
-  {
-    x=from_impl(node_alg::after_local(x->impl()));
-  }
-};
-
-} /* namespace multi_index::detail */
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/header_holder.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/header_holder.hpp
deleted file mode 100644
index ca8a9b2edb1..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/header_holder.hpp
+++ /dev/null
@@ -1,50 +0,0 @@
-/* Copyright 2003-2008 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_DETAIL_HEADER_HOLDER_HPP
-#define BOOST_MULTI_INDEX_DETAIL_HEADER_HOLDER_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/noncopyable.hpp>
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-/* A utility class used to hold a pointer to the header node.
- * The base from member idiom is used because index classes, which are
- * superclasses of multi_index_container, need this header in construction
- * time. The allocation is made by the allocator of the multi_index_container
- * class --hence, this allocator needs also be stored resorting
- * to the base from member trick.
- */
-
-template<typename NodeTypePtr,typename Final>
-struct header_holder:private noncopyable
-{
-  header_holder():member(final().allocate_node()){}
-  ~header_holder(){final().deallocate_node(&*member);}
-
-  NodeTypePtr member;
-
-private:
-  Final& final(){return *static_cast<Final*>(this);}
-};
-
-} /* namespace multi_index::detail */
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/ignore_wstrict_aliasing.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/ignore_wstrict_aliasing.hpp
deleted file mode 100644
index ae398456d1f..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/ignore_wstrict_aliasing.hpp
+++ /dev/null
@@ -1,18 +0,0 @@
-/* Copyright 2003-2016 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#include <boost/config.hpp>
-
-#if defined(BOOST_GCC)&&(BOOST_GCC>=4*10000+6*100)
-#if !defined(BOOST_MULTI_INDEX_DETAIL_RESTORE_WSTRICT_ALIASING)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wstrict-aliasing"
-#else
-#pragma GCC diagnostic pop
-#endif
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/index_base.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/index_base.hpp
deleted file mode 100644
index 99000ed4813..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/index_base.hpp
+++ /dev/null
@@ -1,293 +0,0 @@
-/* Copyright 2003-2014 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_DETAIL_INDEX_BASE_HPP
-#define BOOST_MULTI_INDEX_DETAIL_INDEX_BASE_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <boost/detail/allocator_utilities.hpp>
-#include <boost/detail/no_exceptions_support.hpp>
-#include <boost/detail/workaround.hpp>
-#include <boost/move/core.hpp>
-#include <boost/move/utility.hpp>
-#include <boost/mpl/vector.hpp>
-#include <boost/multi_index/detail/copy_map.hpp>
-#include <boost/multi_index/detail/do_not_copy_elements_tag.hpp>
-#include <boost/multi_index/detail/node_type.hpp>
-#include <boost/multi_index/detail/vartempl_support.hpp>
-#include <boost/multi_index_container_fwd.hpp>
-#include <boost/tuple/tuple.hpp>
-#include <utility>
-
-#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
-#include <boost/multi_index/detail/index_loader.hpp>
-#include <boost/multi_index/detail/index_saver.hpp>
-#endif
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-/* The role of this class is threefold:
- *   - tops the linear hierarchy of indices.
- *   - terminates some cascading backbone function calls (insert_, etc.),
- *   - grants access to the backbone functions of the final
- *     multi_index_container class (for access restriction reasons, these
- *     cannot be called directly from the index classes.)
- */
-
-struct lvalue_tag{};
-struct rvalue_tag{};
-struct emplaced_tag{};
-
-template<typename Value,typename IndexSpecifierList,typename Allocator>
-class index_base
-{
-protected:
-  typedef index_node_base<Value,Allocator>    node_type;
-  typedef typename multi_index_node_type<
-    Value,IndexSpecifierList,Allocator>::type final_node_type;
-  typedef multi_index_container<
-    Value,IndexSpecifierList,Allocator>       final_type;
-  typedef tuples::null_type                   ctor_args_list;
-  typedef typename 
-  boost::detail::allocator::rebind_to<
-    Allocator,
-    typename Allocator::value_type
-  >::type                                     final_allocator_type;
-  typedef mpl::vector0<>                      index_type_list;
-  typedef mpl::vector0<>                      iterator_type_list;
-  typedef mpl::vector0<>                      const_iterator_type_list;
-  typedef copy_map<
-    final_node_type,
-    final_allocator_type>                     copy_map_type;
-
-#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
-  typedef index_saver<
-    node_type,
-    final_allocator_type>                     index_saver_type;
-  typedef index_loader<
-    node_type,
-    final_node_type,
-    final_allocator_type>                     index_loader_type;
-#endif
-
-private:
-  typedef Value                               value_type;
-
-protected:
-  explicit index_base(const ctor_args_list&,const Allocator&){}
-
-  index_base(
-    const index_base<Value,IndexSpecifierList,Allocator>&,
-    do_not_copy_elements_tag)
-  {}
-
-  void copy_(
-    const index_base<Value,IndexSpecifierList,Allocator>&,const copy_map_type&)
-  {}
-
-  final_node_type* insert_(const value_type& v,final_node_type*& x,lvalue_tag)
-  {
-    x=final().allocate_node();
-    BOOST_TRY{
-      boost::detail::allocator::construct(&x->value(),v);
-    }
-    BOOST_CATCH(...){
-      final().deallocate_node(x);
-      BOOST_RETHROW;
-    }
-    BOOST_CATCH_END
-    return x;
-  }
-
-  final_node_type* insert_(const value_type& v,final_node_type*& x,rvalue_tag)
-  {
-    x=final().allocate_node();
-    BOOST_TRY{
-      /* This shoud have used a modified, T&&-compatible version of
-       * boost::detail::allocator::construct, but 
-       * <boost/detail/allocator_utilities.hpp> is too old and venerable to
-       * mess with; besides, it is a general internal utility and the imperfect
-       * perfect forwarding emulation of Boost.Move might break other libs.
-       */
-
-      new (&x->value()) value_type(boost::move(const_cast<value_type&>(v)));
-    }
-    BOOST_CATCH(...){
-      final().deallocate_node(x);
-      BOOST_RETHROW;
-    }
-    BOOST_CATCH_END
-    return x;
-  }
-
-  final_node_type* insert_(const value_type&,final_node_type*& x,emplaced_tag)
-  {
-    return x;
-  }
-
-  final_node_type* insert_(
-    const value_type& v,node_type*,final_node_type*& x,lvalue_tag)
-  {
-    return insert_(v,x,lvalue_tag());
-  }
-
-  final_node_type* insert_(
-    const value_type& v,node_type*,final_node_type*& x,rvalue_tag)
-  {
-    return insert_(v,x,rvalue_tag());
-  }
-
-  final_node_type* insert_(
-    const value_type&,node_type*,final_node_type*& x,emplaced_tag)
-  {
-    return x;
-  }
-
-  void erase_(node_type* x)
-  {
-    boost::detail::allocator::destroy(&x->value());
-  }
-
-  void delete_node_(node_type* x)
-  {
-    boost::detail::allocator::destroy(&x->value());
-  }
-
-  void clear_(){}
-
-  void swap_(index_base<Value,IndexSpecifierList,Allocator>&){}
-
-  void swap_elements_(index_base<Value,IndexSpecifierList,Allocator>&){}
-
-  bool replace_(const value_type& v,node_type* x,lvalue_tag)
-  {
-    x->value()=v;
-    return true;
-  }
-
-  bool replace_(const value_type& v,node_type* x,rvalue_tag)
-  {
-    x->value()=boost::move(const_cast<value_type&>(v));
-    return true;
-  }
-
-  bool modify_(node_type*){return true;}
-
-  bool modify_rollback_(node_type*){return true;}
-
-#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
-  /* serialization */
-
-  template<typename Archive>
-  void save_(Archive&,const unsigned int,const index_saver_type&)const{}
-
-  template<typename Archive>
-  void load_(Archive&,const unsigned int,const index_loader_type&){}
-#endif
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING)
-  /* invariant stuff */
-
-  bool invariant_()const{return true;}
-#endif
-
-  /* access to backbone memfuns of Final class */
-
-  final_type&       final(){return *static_cast<final_type*>(this);}
-  const final_type& final()const{return *static_cast<const final_type*>(this);}
-
-  final_node_type* final_header()const{return final().header();}
-
-  bool        final_empty_()const{return final().empty_();}
-  std::size_t final_size_()const{return final().size_();}
-  std::size_t final_max_size_()const{return final().max_size_();}
-
-  std::pair<final_node_type*,bool> final_insert_(const value_type& x)
-    {return final().insert_(x);}
-  std::pair<final_node_type*,bool> final_insert_rv_(const value_type& x)
-    {return final().insert_rv_(x);}
-  template<typename T>
-  std::pair<final_node_type*,bool> final_insert_ref_(const T& t)
-    {return final().insert_ref_(t);}
-  template<typename T>
-  std::pair<final_node_type*,bool> final_insert_ref_(T& t)
-    {return final().insert_ref_(t);}
-
-  template<BOOST_MULTI_INDEX_TEMPLATE_PARAM_PACK>
-  std::pair<final_node_type*,bool> final_emplace_(
-    BOOST_MULTI_INDEX_FUNCTION_PARAM_PACK)
-  {
-    return final().emplace_(BOOST_MULTI_INDEX_FORWARD_PARAM_PACK);
-  }
-
-  std::pair<final_node_type*,bool> final_insert_(
-    const value_type& x,final_node_type* position)
-    {return final().insert_(x,position);}
-  std::pair<final_node_type*,bool> final_insert_rv_(
-    const value_type& x,final_node_type* position)
-    {return final().insert_rv_(x,position);}
-  template<typename T>
-  std::pair<final_node_type*,bool> final_insert_ref_(
-    const T& t,final_node_type* position)
-    {return final().insert_ref_(t,position);}
-  template<typename T>
-  std::pair<final_node_type*,bool> final_insert_ref_(
-    T& t,final_node_type* position)
-    {return final().insert_ref_(t,position);}
-
-  template<BOOST_MULTI_INDEX_TEMPLATE_PARAM_PACK>
-  std::pair<final_node_type*,bool> final_emplace_hint_(
-    final_node_type* position,BOOST_MULTI_INDEX_FUNCTION_PARAM_PACK)
-  {
-    return final().emplace_hint_(
-      position,BOOST_MULTI_INDEX_FORWARD_PARAM_PACK);
-  }
-
-  void final_erase_(final_node_type* x){final().erase_(x);}
-
-  void final_delete_node_(final_node_type* x){final().delete_node_(x);}
-  void final_delete_all_nodes_(){final().delete_all_nodes_();}
-  void final_clear_(){final().clear_();}
-
-  void final_swap_(final_type& x){final().swap_(x);}
-
-  bool final_replace_(
-    const value_type& k,final_node_type* x)
-    {return final().replace_(k,x);}
-  bool final_replace_rv_(
-    const value_type& k,final_node_type* x)
-    {return final().replace_rv_(k,x);}
-
-  template<typename Modifier>
-  bool final_modify_(Modifier& mod,final_node_type* x)
-    {return final().modify_(mod,x);}
-
-  template<typename Modifier,typename Rollback>
-  bool final_modify_(Modifier& mod,Rollback& back,final_node_type* x)
-    {return final().modify_(mod,back,x);}
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING)
-  void final_check_invariant_()const{final().check_invariant_();}
-#endif
-};
-
-} /* namespace multi_index::detail */
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/index_loader.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/index_loader.hpp
deleted file mode 100644
index 71418a10e19..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/index_loader.hpp
+++ /dev/null
@@ -1,139 +0,0 @@
-/* Copyright 2003-2015 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_DETAIL_INDEX_LOADER_HPP
-#define BOOST_MULTI_INDEX_DETAIL_INDEX_LOADER_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <algorithm>
-#include <boost/archive/archive_exception.hpp>
-#include <boost/noncopyable.hpp>
-#include <boost/multi_index/detail/auto_space.hpp>
-#include <boost/multi_index/detail/raw_ptr.hpp>
-#include <boost/serialization/nvp.hpp>
-#include <boost/throw_exception.hpp> 
-#include <cstddef>
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-/* Counterpart of index_saver (check index_saver.hpp for serialization
- * details.)* multi_index_container is in charge of supplying the info about
- * the base sequence, and each index can subsequently load itself using the
- * const interface of index_loader.
- */
-
-template<typename Node,typename FinalNode,typename Allocator>
-class index_loader:private noncopyable
-{
-public:
-  index_loader(const Allocator& al,std::size_t size):
-    spc(al,size),size_(size),n(0),sorted(false)
-  {
-  }
-
-  template<class Archive>
-  void add(Node* node,Archive& ar,const unsigned int)
-  {
-    ar>>serialization::make_nvp("position",*node);
-    entries()[n++]=node;
-  }
-
-  template<class Archive>
-  void add_track(Node* node,Archive& ar,const unsigned int)
-  {
-    ar>>serialization::make_nvp("position",*node);
-  }
-
-  /* A rearranger is passed two nodes, and is expected to
-   * reposition the second after the first.
-   * If the first node is 0, then the second should be moved
-   * to the beginning of the sequence.
-   */
-
-  template<typename Rearranger,class Archive>
-  void load(Rearranger r,Archive& ar,const unsigned int)const
-  {
-    FinalNode* prev=unchecked_load_node(ar);
-    if(!prev)return;
-
-    if(!sorted){
-      std::sort(entries(),entries()+size_);
-      sorted=true;
-    }
-
-    check_node(prev);
-
-    for(;;){
-      for(;;){
-        FinalNode* node=load_node(ar);
-        if(!node)break;
-
-        if(node==prev)prev=0;
-        r(prev,node);
-
-        prev=node;
-      }
-      prev=load_node(ar);
-      if(!prev)break;
-    }
-  }
-
-private:
-  Node** entries()const{return raw_ptr<Node**>(spc.data());}
-
-  /* We try to delay sorting as much as possible just in case it
-   * is not necessary, hence this version of load_node.
-   */
-
-  template<class Archive>
-  FinalNode* unchecked_load_node(Archive& ar)const
-  {
-    Node* node=0;
-    ar>>serialization::make_nvp("pointer",node);
-    return static_cast<FinalNode*>(node);
-  }
-
-  template<class Archive>
-  FinalNode* load_node(Archive& ar)const
-  {
-    Node* node=0;
-    ar>>serialization::make_nvp("pointer",node);
-    check_node(node);
-    return static_cast<FinalNode*>(node);
-  }
-
-  void check_node(Node* node)const
-  {
-    if(node!=0&&!std::binary_search(entries(),entries()+size_,node)){
-      throw_exception(
-        archive::archive_exception(
-          archive::archive_exception::other_exception));
-    }
-  }
-
-  auto_space<Node*,Allocator> spc;
-  std::size_t                 size_;
-  std::size_t                 n;
-  mutable bool                sorted;
-};
-
-} /* namespace multi_index::detail */
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/index_matcher.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/index_matcher.hpp
deleted file mode 100644
index 34d1f9d5a8d..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/index_matcher.hpp
+++ /dev/null
@@ -1,249 +0,0 @@
-/* Copyright 2003-2015 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_DETAIL_INDEX_MATCHER_HPP
-#define BOOST_MULTI_INDEX_DETAIL_INDEX_MATCHER_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <algorithm>
-#include <boost/noncopyable.hpp>
-#include <boost/multi_index/detail/auto_space.hpp>
-#include <boost/multi_index/detail/raw_ptr.hpp>
-#include <cstddef>
-#include <functional>
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-/* index_matcher compares a sequence of elements against a
- * base sequence, identifying those elements that belong to the
- * longest subsequence which is ordered with respect to the base.
- * For instance, if the base sequence is:
- *
- *   0 1 2 3 4 5 6 7 8 9
- *
- * and the compared sequence (not necesarilly the same length):
- *
- *   1 4 2 3 0 7 8 9
- *
- * the elements of the longest ordered subsequence are:
- *
- *   1 2 3 7 8 9
- * 
- * The algorithm for obtaining such a subsequence is called
- * Patience Sorting, described in ch. 1 of:
- *   Aldous, D., Diaconis, P.: "Longest increasing subsequences: from
- *   patience sorting to the Baik-Deift-Johansson Theorem", Bulletin
- *   of the American Mathematical Society, vol. 36, no 4, pp. 413-432,
- *   July 1999.
- *   http://www.ams.org/bull/1999-36-04/S0273-0979-99-00796-X/
- *   S0273-0979-99-00796-X.pdf
- *
- * This implementation is not fully generic since it assumes that
- * the sequences given are pointed to by index iterators (having a
- * get_node() memfun.)
- */
-
-namespace index_matcher{
-
-/* The algorithm stores the nodes of the base sequence and a number
- * of "piles" that are dynamically updated during the calculation
- * stage. From a logical point of view, nodes form an independent
- * sequence from piles. They are stored together so as to minimize
- * allocated memory.
- */
-
-struct entry
-{
-  entry(void* node_,std::size_t pos_=0):node(node_),pos(pos_){}
-
-  /* node stuff */
-
-  void*       node;
-  std::size_t pos;
-  entry*      previous;
-  bool        ordered;
-
-  struct less_by_node
-  {
-    bool operator()(
-      const entry& x,const entry& y)const
-    {
-      return std::less<void*>()(x.node,y.node);
-    }
-  };
-
-  /* pile stuff */
-
-  std::size_t pile_top;
-  entry*      pile_top_entry;
-
-  struct less_by_pile_top
-  {
-    bool operator()(
-      const entry& x,const entry& y)const
-    {
-      return x.pile_top<y.pile_top;
-    }
-  };
-};
-
-/* common code operating on void *'s */
-
-template<typename Allocator>
-class algorithm_base:private noncopyable
-{
-protected:
-  algorithm_base(const Allocator& al,std::size_t size):
-    spc(al,size),size_(size),n_(0),sorted(false)
-  {
-  }
-
-  void add(void* node)
-  {
-    entries()[n_]=entry(node,n_);
-    ++n_;
-  }
-
-  void begin_algorithm()const
-  {
-    if(!sorted){
-      std::sort(entries(),entries()+size_,entry::less_by_node());
-      sorted=true;
-    }
-    num_piles=0;
-  }
-
-  void add_node_to_algorithm(void* node)const
-  {
-    entry* ent=
-      std::lower_bound(
-        entries(),entries()+size_,
-        entry(node),entry::less_by_node()); /* localize entry */
-    ent->ordered=false;
-    std::size_t n=ent->pos;                 /* get its position */
-
-    entry dummy(0);
-    dummy.pile_top=n;
-
-    entry* pile_ent=                        /* find the first available pile */
-      std::lower_bound(                     /* to stack the entry            */
-        entries(),entries()+num_piles,
-        dummy,entry::less_by_pile_top());
-
-    pile_ent->pile_top=n;                   /* stack the entry */
-    pile_ent->pile_top_entry=ent;        
-
-    /* if not the first pile, link entry to top of the preceding pile */
-    if(pile_ent>&entries()[0]){ 
-      ent->previous=(pile_ent-1)->pile_top_entry;
-    }
-
-    if(pile_ent==&entries()[num_piles]){    /* new pile? */
-      ++num_piles;
-    }
-  }
-
-  void finish_algorithm()const
-  {
-    if(num_piles>0){
-      /* Mark those elements which are in their correct position, i.e. those
-       * belonging to the longest increasing subsequence. These are those
-       * elements linked from the top of the last pile.
-       */
-
-      entry* ent=entries()[num_piles-1].pile_top_entry;
-      for(std::size_t n=num_piles;n--;){
-        ent->ordered=true;
-        ent=ent->previous;
-      }
-    }
-  }
-
-  bool is_ordered(void * node)const
-  {
-    return std::lower_bound(
-      entries(),entries()+size_,
-      entry(node),entry::less_by_node())->ordered;
-  }
-
-private:
-  entry* entries()const{return raw_ptr<entry*>(spc.data());}
-
-  auto_space<entry,Allocator> spc;
-  std::size_t                 size_;
-  std::size_t                 n_;
-  mutable bool                sorted;
-  mutable std::size_t         num_piles;
-};
-
-/* The algorithm has three phases:
- *   - Initialization, during which the nodes of the base sequence are added.
- *   - Execution.
- *   - Results querying, through the is_ordered memfun.
- */
-
-template<typename Node,typename Allocator>
-class algorithm:private algorithm_base<Allocator>
-{
-  typedef algorithm_base<Allocator> super;
-
-public:
-  algorithm(const Allocator& al,std::size_t size):super(al,size){}
-
-  void add(Node* node)
-  {
-    super::add(node);
-  }
-
-  template<typename IndexIterator>
-  void execute(IndexIterator first,IndexIterator last)const
-  {
-    super::begin_algorithm();
-
-    for(IndexIterator it=first;it!=last;++it){
-      add_node_to_algorithm(get_node(it));
-    }
-
-    super::finish_algorithm();
-  }
-
-  bool is_ordered(Node* node)const
-  {
-    return super::is_ordered(node);
-  }
-
-private:
-  void add_node_to_algorithm(Node* node)const
-  {
-    super::add_node_to_algorithm(node);
-  }
-
-  template<typename IndexIterator>
-  static Node* get_node(IndexIterator it)
-  {
-    return static_cast<Node*>(it.get_node());
-  }
-};
-
-} /* namespace multi_index::detail::index_matcher */
-
-} /* namespace multi_index::detail */
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/index_node_base.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/index_node_base.hpp
deleted file mode 100644
index 1a1f0cae4be..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/index_node_base.hpp
+++ /dev/null
@@ -1,135 +0,0 @@
-/* Copyright 2003-2016 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_DETAIL_INDEX_NODE_BASE_HPP
-#define BOOST_MULTI_INDEX_DETAIL_INDEX_NODE_BASE_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <boost/type_traits/aligned_storage.hpp>
-#include <boost/type_traits/alignment_of.hpp> 
-
-#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
-#include <boost/archive/archive_exception.hpp>
-#include <boost/serialization/access.hpp>
-#include <boost/throw_exception.hpp> 
-#endif
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-/* index_node_base tops the node hierarchy of multi_index_container. It holds
- * the value of the element contained.
- */
-
-template<typename Value>
-struct pod_value_holder
-{
-  typename aligned_storage<
-    sizeof(Value),
-    alignment_of<Value>::value
-  >::type                      space;
-};
-
-template<typename Value,typename Allocator>
-struct index_node_base:private pod_value_holder<Value>
-{
-  typedef index_node_base base_type; /* used for serialization purposes */
-  typedef Value           value_type;
-  typedef Allocator       allocator_type;
-
-#include <boost/multi_index/detail/ignore_wstrict_aliasing.hpp>
-
-  value_type& value()
-  {
-    return *reinterpret_cast<value_type*>(&this->space);
-  }
-
-  const value_type& value()const
-  {
-    return *reinterpret_cast<const value_type*>(&this->space);
-  }
-
-#include <boost/multi_index/detail/restore_wstrict_aliasing.hpp>
-
-  static index_node_base* from_value(const value_type* p)
-  {
-    return static_cast<index_node_base *>(
-      reinterpret_cast<pod_value_holder<Value>*>( /* std 9.2.17 */
-        const_cast<value_type*>(p))); 
-  }
-
-private:
-#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
-  friend class boost::serialization::access;
-  
-  /* nodes do not emit any kind of serialization info. They are
-   * fed to Boost.Serialization so that pointers to nodes are
-   * tracked correctly.
-   */
-
-  template<class Archive>
-  void serialize(Archive&,const unsigned int)
-  {
-  }
-#endif
-};
-
-template<typename Node,typename Value>
-Node* node_from_value(const Value* p)
-{
-  typedef typename Node::allocator_type allocator_type;
-  return static_cast<Node*>(
-    index_node_base<Value,allocator_type>::from_value(p));
-}
-
-} /* namespace multi_index::detail */
-
-} /* namespace multi_index */
-
-#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
-/* Index nodes never get constructed directly by Boost.Serialization,
- * as archives are always fed pointers to previously existent
- * nodes. So, if this is called it means we are dealing with a
- * somehow invalid archive.
- */
-
-#if defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)
-namespace serialization{
-#else
-namespace multi_index{
-namespace detail{
-#endif
-
-template<class Archive,typename Value,typename Allocator>
-inline void load_construct_data(
-  Archive&,boost::multi_index::detail::index_node_base<Value,Allocator>*,
-  const unsigned int)
-{
-  throw_exception(
-    archive::archive_exception(archive::archive_exception::other_exception));
-}
-
-#if defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)
-} /* namespace serialization */
-#else
-} /* namespace multi_index::detail */
-} /* namespace multi_index */
-#endif
-
-#endif
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/index_saver.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/index_saver.hpp
deleted file mode 100644
index ae09d4eba4f..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/index_saver.hpp
+++ /dev/null
@@ -1,135 +0,0 @@
-/* Copyright 2003-2013 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_DETAIL_INDEX_SAVER_HPP
-#define BOOST_MULTI_INDEX_DETAIL_INDEX_SAVER_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <boost/multi_index/detail/index_matcher.hpp>
-#include <boost/noncopyable.hpp>
-#include <boost/serialization/nvp.hpp>
-#include <cstddef>
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-/* index_saver accepts a base sequence of previously saved elements
- * and saves a possibly reordered subsequence in an efficient manner,
- * serializing only the information needed to rearrange the subsequence
- * based on the original order of the base.
- * multi_index_container is in charge of supplying the info about the
- * base sequence, and each index can subsequently save itself using the
- * const interface of index_saver.
- */
-
-template<typename Node,typename Allocator>
-class index_saver:private noncopyable
-{
-public:
-  index_saver(const Allocator& al,std::size_t size):alg(al,size){}
-
-  template<class Archive>
-  void add(Node* node,Archive& ar,const unsigned int)
-  {
-    ar<<serialization::make_nvp("position",*node);
-    alg.add(node);
-  }
-
-  template<class Archive>
-  void add_track(Node* node,Archive& ar,const unsigned int)
-  {
-    ar<<serialization::make_nvp("position",*node);
-  }
-
-  template<typename IndexIterator,class Archive>
-  void save(
-    IndexIterator first,IndexIterator last,Archive& ar,
-    const unsigned int)const
-  {
-    /* calculate ordered positions */
-
-    alg.execute(first,last);
-
-    /* Given a consecutive subsequence of displaced elements
-     * x1,...,xn, the following information is serialized:
-     *
-     *   p0,p1,...,pn,0
-     *
-     * where pi is a pointer to xi and p0 is a pointer to the element
-     * preceding x1. Crealy, from this information is possible to
-     * restore the original order on loading time. If x1 is the first
-     * element in the sequence, the following is serialized instead:
-     *
-     *   p1,p1,...,pn,0
-     *
-     * For each subsequence of n elements, n+2 pointers are serialized.
-     * An optimization policy is applied: consider for instance the
-     * sequence
-     *
-     *   a,B,c,D
-     * 
-     * where B and D are displaced, but c is in its correct position.
-     * Applying the schema described above we would serialize 6 pointers:
-     *
-     *  p(a),p(B),0
-     *  p(c),p(D),0
-     * 
-     * but this can be reduced to 5 pointers by treating c as a displaced
-     * element:
-     *
-     *  p(a),p(B),p(c),p(D),0
-     */
-
-    std::size_t last_saved=3; /* distance to last pointer saved */
-    for(IndexIterator it=first,prev=first;it!=last;prev=it++,++last_saved){
-      if(!alg.is_ordered(get_node(it))){
-        if(last_saved>1)save_node(get_node(prev),ar);
-        save_node(get_node(it),ar);
-        last_saved=0;
-      }
-      else if(last_saved==2)save_node(null_node(),ar);
-    }
-    if(last_saved<=2)save_node(null_node(),ar);
-
-    /* marks the end of the serialization info for [first,last) */
-
-    save_node(null_node(),ar);
-  }
-
-private:
-  template<typename IndexIterator>
-  static Node* get_node(IndexIterator it)
-  {
-    return it.get_node();
-  }
-
-  static Node* null_node(){return 0;}
-
-  template<typename Archive>
-  static void save_node(Node* node,Archive& ar)
-  {
-    ar<<serialization::make_nvp("pointer",node);
-  }
-
-  index_matcher::algorithm<Node,Allocator> alg;
-};
-
-} /* namespace multi_index::detail */
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/invariant_assert.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/invariant_assert.hpp
deleted file mode 100644
index c6c547c7c33..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/invariant_assert.hpp
+++ /dev/null
@@ -1,21 +0,0 @@
-/* Copyright 2003-2013 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_DETAIL_INVARIANT_ASSERT_HPP
-#define BOOST_MULTI_INDEX_DETAIL_INVARIANT_ASSERT_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#if !defined(BOOST_MULTI_INDEX_INVARIANT_ASSERT)
-#include <boost/assert.hpp>
-#define BOOST_MULTI_INDEX_INVARIANT_ASSERT BOOST_ASSERT
-#endif
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/is_index_list.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/is_index_list.hpp
deleted file mode 100644
index f6a24218b81..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/is_index_list.hpp
+++ /dev/null
@@ -1,40 +0,0 @@
-/* Copyright 2003-2013 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_DETAIL_IS_INDEX_LIST_HPP
-#define BOOST_MULTI_INDEX_DETAIL_IS_INDEX_LIST_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <boost/mpl/empty.hpp>
-#include <boost/mpl/is_sequence.hpp>
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-template<typename T>
-struct is_index_list
-{
-  BOOST_STATIC_CONSTANT(bool,mpl_sequence=mpl::is_sequence<T>::value);
-  BOOST_STATIC_CONSTANT(bool,non_empty=!mpl::empty<T>::value);
-  BOOST_STATIC_CONSTANT(bool,value=mpl_sequence&&non_empty);
-};
-
-} /* namespace multi_index::detail */
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/is_transparent.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/is_transparent.hpp
deleted file mode 100644
index 72036d257e2..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/is_transparent.hpp
+++ /dev/null
@@ -1,135 +0,0 @@
-/* Copyright 2003-2014 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_DETAIL_IS_TRANSPARENT_HPP
-#define BOOST_MULTI_INDEX_DETAIL_IS_TRANSPARENT_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <boost/mpl/bool.hpp>
-#include <boost/type_traits/intrinsics.hpp>
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-/* Metafunction that checks if f(arg,arg2) executes without argument type
- * conversion. By default (i.e. when it cannot be determined) it evaluates to
- * true.
- */
-
-template<typename F,typename Arg1,typename Arg2,typename=void>
-struct is_transparent:mpl::true_{};
-
-} /* namespace multi_index::detail */
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#if !defined(BOOST_NO_SFINAE)&&!defined(BOOST_NO_SFINAE_EXPR)&& \
-    !defined(BOOST_NO_CXX11_DECLTYPE)&& \
-    (defined(BOOST_NO_CXX11_FINAL)||defined(BOOST_IS_FINAL))
-
-#include <boost/mpl/and.hpp>
-#include <boost/mpl/not.hpp>
-#include <boost/mpl/or.hpp>
-#include <boost/type_traits/function_traits.hpp>
-#include <boost/type_traits/is_class.hpp>
-#include <boost/type_traits/is_final.hpp>
-#include <boost/type_traits/is_function.hpp>
-#include <boost/type_traits/is_same.hpp>
-#include <boost/type_traits/remove_pointer.hpp>
-#include <boost/utility/declval.hpp>
-#include <boost/utility/enable_if.hpp>
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-struct not_is_transparent_result_type{};
-
-template<typename F,typename Arg1,typename Arg2>
-struct is_transparent_class_helper:F
-{
-  using F::operator();
-  template<typename T,typename Q>
-  not_is_transparent_result_type operator()(const T&,const Q&)const;
-};
-
-template<typename F,typename Arg1,typename Arg2,typename=void>
-struct is_transparent_class:mpl::true_{};
-
-template<typename F,typename Arg1,typename Arg2>
-struct is_transparent_class<
-  F,Arg1,Arg2,
-  typename enable_if<
-    is_same<
-      decltype(
-        declval<const is_transparent_class_helper<F,Arg1,Arg2> >()(
-          declval<const Arg1&>(),declval<const Arg2&>())
-      ),
-      not_is_transparent_result_type
-    >
-  >::type
->:mpl::false_{};
-
-template<typename F,typename Arg1,typename Arg2>
-struct is_transparent<
-  F,Arg1,Arg2,
-  typename enable_if<
-    mpl::and_<
-      is_class<F>,
-      mpl::not_<is_final<F> > /* is_transparent_class_helper derives from F */
-    >
-  >::type
->:is_transparent_class<F,Arg1,Arg2>{};
-
-template<typename F,typename Arg1,typename Arg2,typename=void>
-struct is_transparent_function:mpl::true_{};
-
-template<typename F,typename Arg1,typename Arg2>
-struct is_transparent_function<
-  F,Arg1,Arg2,
-  typename enable_if<
-    mpl::or_<
-      mpl::not_<mpl::or_<
-        is_same<typename function_traits<F>::arg1_type,const Arg1&>,
-        is_same<typename function_traits<F>::arg1_type,Arg1>
-      > >,
-      mpl::not_<mpl::or_<
-        is_same<typename function_traits<F>::arg2_type,const Arg2&>,
-        is_same<typename function_traits<F>::arg2_type,Arg2>
-      > >
-    >
-  >::type
->:mpl::false_{};
-
-template<typename F,typename Arg1,typename Arg2>
-struct is_transparent<
-  F,Arg1,Arg2,
-  typename enable_if<
-    is_function<typename remove_pointer<F>::type>
-  >::type
->:is_transparent_function<typename remove_pointer<F>::type,Arg1,Arg2>{};
-
-} /* namespace multi_index::detail */
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/iter_adaptor.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/iter_adaptor.hpp
deleted file mode 100644
index 7a032350b36..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/iter_adaptor.hpp
+++ /dev/null
@@ -1,321 +0,0 @@
-/* Copyright 2003-2013 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_DETAIL_ITER_ADAPTOR_HPP
-#define BOOST_MULTI_INDEX_DETAIL_ITER_ADAPTOR_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <boost/mpl/apply.hpp>
-#include <boost/operators.hpp>
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-/* Poor man's version of boost::iterator_adaptor. Used instead of the
- * original as compile times for the latter are significantly higher.
- * The interface is not replicated exactly, only to the extent necessary
- * for internal consumption.
- */
-
-/* NB. The purpose of the (non-inclass) global operators ==, < and - defined
- * above is to partially alleviate a problem of MSVC++ 6.0 by * which
- * friend-injected operators on T are not visible if T is instantiated only
- * in template code where T is a dependent type.
- */
-
-class iter_adaptor_access
-{
-public:
-  template<class Class>
-    static typename Class::reference dereference(const Class& x)
-  {
-    return x.dereference();
-  }
-
-  template<class Class>
-  static bool equal(const Class& x,const Class& y)
-  {
-    return x.equal(y);
-  }
-
-  template<class Class>
-  static void increment(Class& x)
-  {
-    x.increment();
-  }
-
-  template<class Class>
-  static void decrement(Class& x)
-  {
-    x.decrement();
-  }
-
-  template<class Class>
-  static void advance(Class& x,typename Class::difference_type n)
-  {
-    x.advance(n);
-  }
-
-  template<class Class>
-  static typename Class::difference_type distance_to(
-    const Class& x,const Class& y)
-  {
-    return x.distance_to(y);
-  }
-};
-
-template<typename Category>
-struct iter_adaptor_selector;
-
-template<class Derived,class Base>
-class forward_iter_adaptor_base:
-  public forward_iterator_helper<
-    Derived,
-    typename Base::value_type,
-    typename Base::difference_type,
-    typename Base::pointer,
-    typename Base::reference>
-{
-public:
-  typedef typename Base::reference reference;
-
-  reference operator*()const
-  {
-    return iter_adaptor_access::dereference(final());
-  }
-
-  friend bool operator==(const Derived& x,const Derived& y)
-  {
-    return iter_adaptor_access::equal(x,y);
-  }
-
-  Derived& operator++()
-  {
-    iter_adaptor_access::increment(final());
-    return final();
-  }
-
-private:
-  Derived& final(){return *static_cast<Derived*>(this);}
-  const Derived& final()const{return *static_cast<const Derived*>(this);}
-};
-
-template<class Derived,class Base>
-bool operator==(
-  const forward_iter_adaptor_base<Derived,Base>& x,
-  const forward_iter_adaptor_base<Derived,Base>& y)
-{
-  return iter_adaptor_access::equal(
-    static_cast<const Derived&>(x),static_cast<const Derived&>(y));
-}
-
-template<>
-struct iter_adaptor_selector<std::forward_iterator_tag>
-{
-  template<class Derived,class Base>
-  struct apply
-  {
-    typedef forward_iter_adaptor_base<Derived,Base> type;
-  };
-};
-
-template<class Derived,class Base>
-class bidirectional_iter_adaptor_base:
-  public bidirectional_iterator_helper<
-    Derived,
-    typename Base::value_type,
-    typename Base::difference_type,
-    typename Base::pointer,
-    typename Base::reference>
-{
-public:
-  typedef typename Base::reference reference;
-
-  reference operator*()const
-  {
-    return iter_adaptor_access::dereference(final());
-  }
-
-  friend bool operator==(const Derived& x,const Derived& y)
-  {
-    return iter_adaptor_access::equal(x,y);
-  }
-
-  Derived& operator++()
-  {
-    iter_adaptor_access::increment(final());
-    return final();
-  }
-
-  Derived& operator--()
-  {
-    iter_adaptor_access::decrement(final());
-    return final();
-  }
-
-private:
-  Derived& final(){return *static_cast<Derived*>(this);}
-  const Derived& final()const{return *static_cast<const Derived*>(this);}
-};
-
-template<class Derived,class Base>
-bool operator==(
-  const bidirectional_iter_adaptor_base<Derived,Base>& x,
-  const bidirectional_iter_adaptor_base<Derived,Base>& y)
-{
-  return iter_adaptor_access::equal(
-    static_cast<const Derived&>(x),static_cast<const Derived&>(y));
-}
-
-template<>
-struct iter_adaptor_selector<std::bidirectional_iterator_tag>
-{
-  template<class Derived,class Base>
-  struct apply
-  {
-    typedef bidirectional_iter_adaptor_base<Derived,Base> type;
-  };
-};
-
-template<class Derived,class Base>
-class random_access_iter_adaptor_base:
-  public random_access_iterator_helper<
-    Derived,
-    typename Base::value_type,
-    typename Base::difference_type,
-    typename Base::pointer,
-    typename Base::reference>
-{
-public:
-  typedef typename Base::reference       reference;
-  typedef typename Base::difference_type difference_type;
-
-  reference operator*()const
-  {
-    return iter_adaptor_access::dereference(final());
-  }
-
-  friend bool operator==(const Derived& x,const Derived& y)
-  {
-    return iter_adaptor_access::equal(x,y);
-  }
-
-  friend bool operator<(const Derived& x,const Derived& y)
-  {
-    return iter_adaptor_access::distance_to(x,y)>0;
-  }
-
-  Derived& operator++()
-  {
-    iter_adaptor_access::increment(final());
-    return final();
-  }
-
-  Derived& operator--()
-  {
-    iter_adaptor_access::decrement(final());
-    return final();
-  }
-
-  Derived& operator+=(difference_type n)
-  {
-    iter_adaptor_access::advance(final(),n);
-    return final();
-  }
-
-  Derived& operator-=(difference_type n)
-  {
-    iter_adaptor_access::advance(final(),-n);
-    return final();
-  }
-
-  friend difference_type operator-(const Derived& x,const Derived& y)
-  {
-    return iter_adaptor_access::distance_to(y,x);
-  }
-
-private:
-  Derived& final(){return *static_cast<Derived*>(this);}
-  const Derived& final()const{return *static_cast<const Derived*>(this);}
-};
-
-template<class Derived,class Base>
-bool operator==(
-  const random_access_iter_adaptor_base<Derived,Base>& x,
-  const random_access_iter_adaptor_base<Derived,Base>& y)
-{
-  return iter_adaptor_access::equal(
-    static_cast<const Derived&>(x),static_cast<const Derived&>(y));
-}
-
-template<class Derived,class Base>
-bool operator<(
-  const random_access_iter_adaptor_base<Derived,Base>& x,
-  const random_access_iter_adaptor_base<Derived,Base>& y)
-{
-  return iter_adaptor_access::distance_to(
-    static_cast<const Derived&>(x),static_cast<const Derived&>(y))>0;
-}
-
-template<class Derived,class Base>
-typename random_access_iter_adaptor_base<Derived,Base>::difference_type
-operator-(
-  const random_access_iter_adaptor_base<Derived,Base>& x,
-  const random_access_iter_adaptor_base<Derived,Base>& y)
-{
-  return iter_adaptor_access::distance_to(
-    static_cast<const Derived&>(y),static_cast<const Derived&>(x));
-}
-
-template<>
-struct iter_adaptor_selector<std::random_access_iterator_tag>
-{
-  template<class Derived,class Base>
-  struct apply
-  {
-    typedef random_access_iter_adaptor_base<Derived,Base> type;
-  };
-};
-
-template<class Derived,class Base>
-struct iter_adaptor_base
-{
-  typedef iter_adaptor_selector<
-    typename Base::iterator_category> selector;
-  typedef typename mpl::apply2<
-    selector,Derived,Base>::type      type;
-};
-
-template<class Derived,class Base>
-class iter_adaptor:public iter_adaptor_base<Derived,Base>::type
-{
-protected:
-  iter_adaptor(){}
-  explicit iter_adaptor(const Base& b_):b(b_){}
-
-  const Base& base_reference()const{return b;}
-  Base&       base_reference(){return b;}
-
-private:
-  Base b;
-};
-
-} /* namespace multi_index::detail */
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/modify_key_adaptor.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/modify_key_adaptor.hpp
deleted file mode 100644
index 6df89b18386..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/modify_key_adaptor.hpp
+++ /dev/null
@@ -1,49 +0,0 @@
-/* Copyright 2003-2013 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_DETAIL_MODIFY_KEY_ADAPTOR_HPP
-#define BOOST_MULTI_INDEX_DETAIL_MODIFY_KEY_ADAPTOR_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-/* Functional adaptor to resolve modify_key as a call to modify.
- * Preferred over compose_f_gx and stuff cause it eliminates problems
- * with references to references, dealing with function pointers, etc.
- */
-
-template<typename Fun,typename Value,typename KeyFromValue>
-struct modify_key_adaptor
-{
-
-  modify_key_adaptor(Fun f_,KeyFromValue kfv_):f(f_),kfv(kfv_){}
-
-  void operator()(Value& x)
-  {
-    f(kfv(x));
-  }
-
-private:
-  Fun          f;
-  KeyFromValue kfv;
-};
-
-} /* namespace multi_index::detail */
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/no_duplicate_tags.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/no_duplicate_tags.hpp
deleted file mode 100644
index ba216ed82cf..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/no_duplicate_tags.hpp
+++ /dev/null
@@ -1,97 +0,0 @@
-/* Copyright 2003-2013 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_DETAIL_NO_DUPLICATE_TAGS_HPP
-#define BOOST_MULTI_INDEX_DETAIL_NO_DUPLICATE_TAGS_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <boost/mpl/fold.hpp>
-#include <boost/mpl/set/set0.hpp>
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-/* no_duplicate_tags check at compile-time that a tag list
- * has no duplicate tags.
- * The algorithm deserves some explanation: tags
- * are sequentially inserted into a mpl::set if they were
- * not already present. Due to the magic of mpl::set
- * (mpl::has_key is contant time), this operation takes linear
- * time, and even MSVC++ 6.5 handles it gracefully (other obvious
- * solutions are quadratic.)
- */
-
-struct duplicate_tag_mark{};
-
-struct duplicate_tag_marker
-{
-  template <typename MplSet,typename Tag>
-  struct apply
-  {
-    typedef mpl::s_item<
-      typename mpl::if_<mpl::has_key<MplSet,Tag>,duplicate_tag_mark,Tag>::type,
-      MplSet
-    > type;
-  };
-};
-
-template<typename TagList>
-struct no_duplicate_tags
-{
-  typedef typename mpl::fold<
-    TagList,
-    mpl::set0<>,
-    duplicate_tag_marker
-  >::type aux;
- 
-  BOOST_STATIC_CONSTANT(
-    bool,value=!(mpl::has_key<aux,duplicate_tag_mark>::value));
-};
-
-/* Variant for an index list: duplication is checked
- * across all the indices.
- */
-
-struct duplicate_tag_list_marker
-{
-  template <typename MplSet,typename Index>
-  struct apply:mpl::fold<
-    BOOST_DEDUCED_TYPENAME Index::tag_list,
-    MplSet,
-    duplicate_tag_marker>
-  {
-  };
-};
-
-template<typename IndexList>
-struct no_duplicate_tags_in_index_list
-{
-  typedef typename mpl::fold<
-    IndexList,
-    mpl::set0<>,
-    duplicate_tag_list_marker
-  >::type aux;
- 
-  BOOST_STATIC_CONSTANT(
-    bool,value=!(mpl::has_key<aux,duplicate_tag_mark>::value));
-};
-
-} /* namespace multi_index::detail */
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/node_type.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/node_type.hpp
deleted file mode 100644
index 7fe85cf968b..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/node_type.hpp
+++ /dev/null
@@ -1,66 +0,0 @@
-/* Copyright 2003-2013 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_DETAIL_NODE_TYPE_HPP
-#define BOOST_MULTI_INDEX_DETAIL_NODE_TYPE_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <boost/detail/workaround.hpp>
-#include <boost/mpl/bind.hpp>
-#include <boost/mpl/reverse_iter_fold.hpp>
-#include <boost/mpl/deref.hpp>
-#include <boost/multi_index_container_fwd.hpp>
-#include <boost/multi_index/detail/header_holder.hpp>
-#include <boost/multi_index/detail/index_node_base.hpp>
-#include <boost/multi_index/detail/is_index_list.hpp>
-#include <boost/static_assert.hpp>
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-/* MPL machinery to construct the internal node type associated to an
- * index list.
- */
-
-struct index_node_applier
-{
-  template<typename IndexSpecifierIterator,typename Super>
-  struct apply
-  {
-    typedef typename mpl::deref<IndexSpecifierIterator>::type index_specifier;
-    typedef typename index_specifier::
-      BOOST_NESTED_TEMPLATE node_class<Super>::type type;
-  }; 
-};
-
-template<typename Value,typename IndexSpecifierList,typename Allocator>
-struct multi_index_node_type
-{
-  BOOST_STATIC_ASSERT(detail::is_index_list<IndexSpecifierList>::value);
-
-  typedef typename mpl::reverse_iter_fold<
-    IndexSpecifierList,
-    index_node_base<Value,Allocator>,
-    mpl::bind2<index_node_applier,mpl::_2,mpl::_1>
-  >::type type;
-};
-
-} /* namespace multi_index::detail */
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/ord_index_args.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/ord_index_args.hpp
deleted file mode 100644
index 3e2641f2f4d..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/ord_index_args.hpp
+++ /dev/null
@@ -1,83 +0,0 @@
-/* Copyright 2003-2013 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_DETAIL_ORD_INDEX_ARGS_HPP
-#define BOOST_MULTI_INDEX_DETAIL_ORD_INDEX_ARGS_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <boost/mpl/aux_/na.hpp>
-#include <boost/mpl/eval_if.hpp>
-#include <boost/mpl/identity.hpp>
-#include <boost/mpl/if.hpp>
-#include <boost/multi_index/tag.hpp>
-#include <boost/static_assert.hpp>
-#include <boost/type_traits/is_same.hpp>
-#include <functional>
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-/* Oredered index specifiers can be instantiated in two forms:
- *
- *   (ordered_unique|ordered_non_unique)<
- *     KeyFromValue,Compare=std::less<KeyFromValue::result_type> >
- *   (ordered_unique|ordered_non_unique)<
- *     TagList,KeyFromValue,Compare=std::less<KeyFromValue::result_type> >
- *
- * index_args implements the machinery to accept this argument-dependent
- * polymorphism.
- */
-
-template<typename KeyFromValue>
-struct index_args_default_compare
-{
-  typedef std::less<typename KeyFromValue::result_type> type;
-};
-
-template<typename Arg1,typename Arg2,typename Arg3>
-struct ordered_index_args
-{
-  typedef is_tag<Arg1> full_form;
-
-  typedef typename mpl::if_<
-    full_form,
-    Arg1,
-    tag< > >::type                                   tag_list_type;
-  typedef typename mpl::if_<
-    full_form,
-    Arg2,
-    Arg1>::type                                      key_from_value_type;
-  typedef typename mpl::if_<
-    full_form,
-    Arg3,
-    Arg2>::type                                      supplied_compare_type;
-  typedef typename mpl::eval_if<
-    mpl::is_na<supplied_compare_type>,
-    index_args_default_compare<key_from_value_type>,
-    mpl::identity<supplied_compare_type>
-  >::type                                            compare_type;
-
-  BOOST_STATIC_ASSERT(is_tag<tag_list_type>::value);
-  BOOST_STATIC_ASSERT(!mpl::is_na<key_from_value_type>::value);
-  BOOST_STATIC_ASSERT(!mpl::is_na<compare_type>::value);
-};
-
-} /* namespace multi_index::detail */
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/ord_index_impl.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/ord_index_impl.hpp
deleted file mode 100644
index 040cb989630..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/ord_index_impl.hpp
+++ /dev/null
@@ -1,1567 +0,0 @@
-/* Copyright 2003-2015 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- *
- * The internal implementation of red-black trees is based on that of SGI STL
- * stl_tree.h file: 
- *
- * Copyright (c) 1996,1997
- * Silicon Graphics Computer Systems, Inc.
- *
- * Permission to use, copy, modify, distribute and sell this software
- * and its documentation for any purpose is hereby granted without fee,
- * provided that the above copyright notice appear in all copies and
- * that both that copyright notice and this permission notice appear
- * in supporting documentation.  Silicon Graphics makes no
- * representations about the suitability of this software for any
- * purpose.  It is provided "as is" without express or implied warranty.
- *
- *
- * Copyright (c) 1994
- * Hewlett-Packard Company
- *
- * Permission to use, copy, modify, distribute and sell this software
- * and its documentation for any purpose is hereby granted without fee,
- * provided that the above copyright notice appear in all copies and
- * that both that copyright notice and this permission notice appear
- * in supporting documentation.  Hewlett-Packard Company makes no
- * representations about the suitability of this software for any
- * purpose.  It is provided "as is" without express or implied warranty.
- *
- */
-
-#ifndef BOOST_MULTI_INDEX_DETAIL_ORD_INDEX_IMPL_HPP
-#define BOOST_MULTI_INDEX_DETAIL_ORD_INDEX_IMPL_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <algorithm>
-#include <boost/call_traits.hpp>
-#include <boost/detail/no_exceptions_support.hpp>
-#include <boost/detail/workaround.hpp>
-#include <boost/foreach_fwd.hpp>
-#include <boost/iterator/reverse_iterator.hpp>
-#include <boost/move/core.hpp>
-#include <boost/mpl/bool.hpp>
-#include <boost/mpl/if.hpp>
-#include <boost/mpl/push_front.hpp>
-#include <boost/multi_index/detail/access_specifier.hpp>
-#include <boost/multi_index/detail/bidir_node_iterator.hpp>
-#include <boost/multi_index/detail/do_not_copy_elements_tag.hpp>
-#include <boost/multi_index/detail/index_node_base.hpp>
-#include <boost/multi_index/detail/modify_key_adaptor.hpp>
-#include <boost/multi_index/detail/ord_index_node.hpp>
-#include <boost/multi_index/detail/ord_index_ops.hpp>
-#include <boost/multi_index/detail/safe_mode.hpp>
-#include <boost/multi_index/detail/scope_guard.hpp>
-#include <boost/multi_index/detail/unbounded.hpp>
-#include <boost/multi_index/detail/value_compare.hpp>
-#include <boost/multi_index/detail/vartempl_support.hpp>
-#include <boost/multi_index/detail/ord_index_impl_fwd.hpp>
-#include <boost/ref.hpp>
-#include <boost/tuple/tuple.hpp>
-#include <boost/type_traits/is_same.hpp>
-#include <utility>
-
-#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
-#include <initializer_list>
-#endif
-
-#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
-#include <boost/archive/archive_exception.hpp>
-#include <boost/bind.hpp>
-#include <boost/multi_index/detail/duplicates_iterator.hpp>
-#include <boost/throw_exception.hpp> 
-#endif
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING)
-#define BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT_OF(x)                    \
-  detail::scope_guard BOOST_JOIN(check_invariant_,__LINE__)=                 \
-    detail::make_obj_guard(x,&ordered_index_impl::check_invariant_);         \
-  BOOST_JOIN(check_invariant_,__LINE__).touch();
-#define BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT                          \
-  BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT_OF(*this)
-#else
-#define BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT_OF(x)
-#define BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT
-#endif
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-/* ordered_index adds a layer of ordered indexing to a given Super and accepts
- * an augmenting policy for optional addition of order statistics.
- */
-
-/* Most of the implementation of unique and non-unique indices is
- * shared. We tell from one another on instantiation time by using
- * these tags.
- */
-
-struct ordered_unique_tag{};
-struct ordered_non_unique_tag{};
-
-template<
-  typename KeyFromValue,typename Compare,
-  typename SuperMeta,typename TagList,typename Category,typename AugmentPolicy
->
-class ordered_index;
-
-template<
-  typename KeyFromValue,typename Compare,
-  typename SuperMeta,typename TagList,typename Category,typename AugmentPolicy
->
-class ordered_index_impl:
-  BOOST_MULTI_INDEX_PROTECTED_IF_MEMBER_TEMPLATE_FRIENDS SuperMeta::type
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-  ,public safe_mode::safe_container<
-    ordered_index_impl<
-      KeyFromValue,Compare,SuperMeta,TagList,Category,AugmentPolicy> >
-#endif
-
-{ 
-#if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING)&&\
-    BOOST_WORKAROUND(__MWERKS__,<=0x3003)
-/* The "ISO C++ Template Parser" option in CW8.3 has a problem with the
- * lifetime of const references bound to temporaries --precisely what
- * scopeguards are.
- */
-
-#pragma parse_mfunc_templ off
-#endif
-
-  typedef typename SuperMeta::type                   super;
-
-protected:
-  typedef ordered_index_node<
-    AugmentPolicy,typename super::node_type>         node_type;
-
-protected: /* for the benefit of AugmentPolicy::augmented_interface */
-  typedef typename node_type::impl_type              node_impl_type;
-  typedef typename node_impl_type::pointer           node_impl_pointer;
-
-public:
-  /* types */
-
-  typedef typename KeyFromValue::result_type         key_type;
-  typedef typename node_type::value_type             value_type;
-  typedef KeyFromValue                               key_from_value;
-  typedef Compare                                    key_compare;
-  typedef value_comparison<
-    value_type,KeyFromValue,Compare>                 value_compare;
-  typedef tuple<key_from_value,key_compare>          ctor_args;
-  typedef typename super::final_allocator_type       allocator_type;
-  typedef typename allocator_type::reference         reference;
-  typedef typename allocator_type::const_reference   const_reference;
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-  typedef safe_mode::safe_iterator<
-    bidir_node_iterator<node_type>,
-    ordered_index_impl>                              iterator;
-#else
-  typedef bidir_node_iterator<node_type>             iterator;
-#endif
-
-  typedef iterator                                   const_iterator;
-
-  typedef std::size_t                                size_type;      
-  typedef std::ptrdiff_t                             difference_type;
-  typedef typename allocator_type::pointer           pointer;
-  typedef typename allocator_type::const_pointer     const_pointer;
-  typedef typename
-    boost::reverse_iterator<iterator>                reverse_iterator;
-  typedef typename
-    boost::reverse_iterator<const_iterator>          const_reverse_iterator;
-  typedef TagList                                    tag_list;
-
-protected:
-  typedef typename super::final_node_type            final_node_type;
-  typedef tuples::cons<
-    ctor_args, 
-    typename super::ctor_args_list>                  ctor_args_list;
-  typedef typename mpl::push_front<
-    typename super::index_type_list,
-    ordered_index<
-      KeyFromValue,Compare,
-      SuperMeta,TagList,Category,AugmentPolicy
-    > >::type                                        index_type_list;
-  typedef typename mpl::push_front<
-    typename super::iterator_type_list,
-    iterator>::type    iterator_type_list;
-  typedef typename mpl::push_front<
-    typename super::const_iterator_type_list,
-    const_iterator>::type                            const_iterator_type_list;
-  typedef typename super::copy_map_type              copy_map_type;
-
-#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
-  typedef typename super::index_saver_type           index_saver_type;
-  typedef typename super::index_loader_type          index_loader_type;
-#endif
-
-protected:
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-  typedef safe_mode::safe_container<
-    ordered_index_impl>                              safe_super;
-#endif
-
-  typedef typename call_traits<
-    value_type>::param_type                          value_param_type;
-  typedef typename call_traits<
-    key_type>::param_type                            key_param_type;
-
-  /* Needed to avoid commas in BOOST_MULTI_INDEX_OVERLOADS_TO_VARTEMPL
-   * expansion.
-   */
-
-  typedef std::pair<iterator,bool>                   emplace_return_type;
-
-public:
-
-  /* construct/copy/destroy
-   * Default and copy ctors are in the protected section as indices are
-   * not supposed to be created on their own. No range ctor either.
-   * Assignment operators defined at ordered_index rather than here.
-   */
-
-  allocator_type get_allocator()const BOOST_NOEXCEPT
-  {
-    return this->final().get_allocator();
-  }
-
-  /* iterators */
-
-  iterator
-    begin()BOOST_NOEXCEPT{return make_iterator(leftmost());}
-  const_iterator
-    begin()const BOOST_NOEXCEPT{return make_iterator(leftmost());}
-  iterator
-    end()BOOST_NOEXCEPT{return make_iterator(header());}
-  const_iterator
-    end()const BOOST_NOEXCEPT{return make_iterator(header());}
-  reverse_iterator
-    rbegin()BOOST_NOEXCEPT{return boost::make_reverse_iterator(end());}
-  const_reverse_iterator
-    rbegin()const BOOST_NOEXCEPT{return boost::make_reverse_iterator(end());}
-  reverse_iterator
-    rend()BOOST_NOEXCEPT{return boost::make_reverse_iterator(begin());}
-  const_reverse_iterator
-    rend()const BOOST_NOEXCEPT{return boost::make_reverse_iterator(begin());}
-  const_iterator
-    cbegin()const BOOST_NOEXCEPT{return begin();}
-  const_iterator
-    cend()const BOOST_NOEXCEPT{return end();}
-  const_reverse_iterator
-    crbegin()const BOOST_NOEXCEPT{return rbegin();}
-  const_reverse_iterator
-    crend()const BOOST_NOEXCEPT{return rend();}
- 
-  iterator iterator_to(const value_type& x)
-  {
-    return make_iterator(node_from_value<node_type>(&x));
-  }
-
-  const_iterator iterator_to(const value_type& x)const
-  {
-    return make_iterator(node_from_value<node_type>(&x));
-  }
-
-  /* capacity */
-
-  bool      empty()const BOOST_NOEXCEPT{return this->final_empty_();}
-  size_type size()const BOOST_NOEXCEPT{return this->final_size_();}
-  size_type max_size()const BOOST_NOEXCEPT{return this->final_max_size_();}
-
-  /* modifiers */
-
-  BOOST_MULTI_INDEX_OVERLOADS_TO_VARTEMPL(
-    emplace_return_type,emplace,emplace_impl)
-
-  BOOST_MULTI_INDEX_OVERLOADS_TO_VARTEMPL_EXTRA_ARG(
-    iterator,emplace_hint,emplace_hint_impl,iterator,position)
-
-  std::pair<iterator,bool> insert(const value_type& x)
-  {
-    BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT;
-    std::pair<final_node_type*,bool> p=this->final_insert_(x);
-    return std::pair<iterator,bool>(make_iterator(p.first),p.second);
-  }
-
-  std::pair<iterator,bool> insert(BOOST_RV_REF(value_type) x)
-  {
-    BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT;
-    std::pair<final_node_type*,bool> p=this->final_insert_rv_(x);
-    return std::pair<iterator,bool>(make_iterator(p.first),p.second);
-  }
-
-  iterator insert(iterator position,const value_type& x)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
-    BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT;
-    std::pair<final_node_type*,bool> p=this->final_insert_(
-      x,static_cast<final_node_type*>(position.get_node()));
-    return make_iterator(p.first);
-  }
-    
-  iterator insert(iterator position,BOOST_RV_REF(value_type) x)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
-    BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT;
-    std::pair<final_node_type*,bool> p=this->final_insert_rv_(
-      x,static_cast<final_node_type*>(position.get_node()));
-    return make_iterator(p.first);
-  }
-
-  template<typename InputIterator>
-  void insert(InputIterator first,InputIterator last)
-  {
-    BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT;
-    node_type* hint=header(); /* end() */
-    for(;first!=last;++first){
-      hint=this->final_insert_ref_(
-        *first,static_cast<final_node_type*>(hint)).first;
-      node_type::increment(hint);
-    }
-  }
-
-#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
-  void insert(std::initializer_list<value_type> list)
-  {
-    insert(list.begin(),list.end());
-  }
-#endif
-
-  iterator erase(iterator position)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
-    BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT;
-    this->final_erase_(static_cast<final_node_type*>(position++.get_node()));
-    return position;
-  }
-  
-  size_type erase(key_param_type x)
-  {
-    BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT;
-    std::pair<iterator,iterator> p=equal_range(x);
-    size_type s=0;
-    while(p.first!=p.second){
-      p.first=erase(p.first);
-      ++s;
-    }
-    return s;
-  }
-
-  iterator erase(iterator first,iterator last)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(first);
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(last);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(first,*this);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(last,*this);
-    BOOST_MULTI_INDEX_CHECK_VALID_RANGE(first,last);
-    BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT;
-    while(first!=last){
-      first=erase(first);
-    }
-    return first;
-  }
-
-  bool replace(iterator position,const value_type& x)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
-    BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT;
-    return this->final_replace_(
-      x,static_cast<final_node_type*>(position.get_node()));
-  }
-
-  bool replace(iterator position,BOOST_RV_REF(value_type) x)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
-    BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT;
-    return this->final_replace_rv_(
-      x,static_cast<final_node_type*>(position.get_node()));
-  }
-
-  template<typename Modifier>
-  bool modify(iterator position,Modifier mod)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
-    BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT;
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-    /* MSVC++ 6.0 optimizer on safe mode code chokes if this
-     * this is not added. Left it for all compilers as it does no
-     * harm.
-     */
-
-    position.detach();
-#endif
-
-    return this->final_modify_(
-      mod,static_cast<final_node_type*>(position.get_node()));
-  }
-
-  template<typename Modifier,typename Rollback>
-  bool modify(iterator position,Modifier mod,Rollback back_)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
-    BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT;
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-    /* MSVC++ 6.0 optimizer on safe mode code chokes if this
-     * this is not added. Left it for all compilers as it does no
-     * harm.
-     */
-
-    position.detach();
-#endif
-
-    return this->final_modify_(
-      mod,back_,static_cast<final_node_type*>(position.get_node()));
-  }
-  
-  template<typename Modifier>
-  bool modify_key(iterator position,Modifier mod)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
-    BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT;
-    return modify(
-      position,modify_key_adaptor<Modifier,value_type,KeyFromValue>(mod,key));
-  }
-
-  template<typename Modifier,typename Rollback>
-  bool modify_key(iterator position,Modifier mod,Rollback back_)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
-    BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT;
-    return modify(
-      position,
-      modify_key_adaptor<Modifier,value_type,KeyFromValue>(mod,key),
-      modify_key_adaptor<Rollback,value_type,KeyFromValue>(back_,key));
-  }
-
-  void swap(
-    ordered_index<
-      KeyFromValue,Compare,SuperMeta,TagList,Category,AugmentPolicy>& x)
-  {
-    BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT;
-    BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT_OF(x);
-    this->final_swap_(x.final());
-  }
-
-  void clear()BOOST_NOEXCEPT
-  {
-    BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT;
-    this->final_clear_();
-  }
-
-  /* observers */
-
-  key_from_value key_extractor()const{return key;}
-  key_compare    key_comp()const{return comp_;}
-  value_compare  value_comp()const{return value_compare(key,comp_);}
-
-  /* set operations */
-
-  /* Internally, these ops rely on const_iterator being the same
-   * type as iterator.
-   */
-
-  template<typename CompatibleKey>
-  iterator find(const CompatibleKey& x)const
-  {
-    return make_iterator(ordered_index_find(root(),header(),key,x,comp_));
-  }
-
-  template<typename CompatibleKey,typename CompatibleCompare>
-  iterator find(
-    const CompatibleKey& x,const CompatibleCompare& comp)const
-  {
-    return make_iterator(ordered_index_find(root(),header(),key,x,comp));
-  }
-
-  template<typename CompatibleKey>
-  size_type count(const CompatibleKey& x)const
-  {
-    return count(x,comp_);
-  }
-
-  template<typename CompatibleKey,typename CompatibleCompare>
-  size_type count(const CompatibleKey& x,const CompatibleCompare& comp)const
-  {
-    std::pair<iterator,iterator> p=equal_range(x,comp);
-    size_type n=std::distance(p.first,p.second);
-    return n;
-  }
-
-  template<typename CompatibleKey>
-  iterator lower_bound(const CompatibleKey& x)const
-  {
-    return make_iterator(
-      ordered_index_lower_bound(root(),header(),key,x,comp_));
-  }
-
-  template<typename CompatibleKey,typename CompatibleCompare>
-  iterator lower_bound(
-    const CompatibleKey& x,const CompatibleCompare& comp)const
-  {
-    return make_iterator(
-      ordered_index_lower_bound(root(),header(),key,x,comp));
-  }
-
-  template<typename CompatibleKey>
-  iterator upper_bound(const CompatibleKey& x)const
-  {
-    return make_iterator(
-      ordered_index_upper_bound(root(),header(),key,x,comp_));
-  }
-
-  template<typename CompatibleKey,typename CompatibleCompare>
-  iterator upper_bound(
-    const CompatibleKey& x,const CompatibleCompare& comp)const
-  {
-    return make_iterator(
-      ordered_index_upper_bound(root(),header(),key,x,comp));
-  }
-
-  template<typename CompatibleKey>
-  std::pair<iterator,iterator> equal_range(
-    const CompatibleKey& x)const
-  {
-    std::pair<node_type*,node_type*> p=
-      ordered_index_equal_range(root(),header(),key,x,comp_);
-    return std::pair<iterator,iterator>(
-      make_iterator(p.first),make_iterator(p.second));
-  }
-
-  template<typename CompatibleKey,typename CompatibleCompare>
-  std::pair<iterator,iterator> equal_range(
-    const CompatibleKey& x,const CompatibleCompare& comp)const
-  {
-    std::pair<node_type*,node_type*> p=
-      ordered_index_equal_range(root(),header(),key,x,comp);
-    return std::pair<iterator,iterator>(
-      make_iterator(p.first),make_iterator(p.second));
-  }
-
-  /* range */
-
-  template<typename LowerBounder,typename UpperBounder>
-  std::pair<iterator,iterator>
-  range(LowerBounder lower,UpperBounder upper)const
-  {
-    typedef typename mpl::if_<
-      is_same<LowerBounder,unbounded_type>,
-      BOOST_DEDUCED_TYPENAME mpl::if_<
-        is_same<UpperBounder,unbounded_type>,
-        both_unbounded_tag,
-        lower_unbounded_tag
-      >::type,
-      BOOST_DEDUCED_TYPENAME mpl::if_<
-        is_same<UpperBounder,unbounded_type>,
-        upper_unbounded_tag,
-        none_unbounded_tag
-      >::type
-    >::type dispatch;
-
-    return range(lower,upper,dispatch());
-  }
-
-BOOST_MULTI_INDEX_PROTECTED_IF_MEMBER_TEMPLATE_FRIENDS:
-  ordered_index_impl(const ctor_args_list& args_list,const allocator_type& al):
-    super(args_list.get_tail(),al),
-    key(tuples::get<0>(args_list.get_head())),
-    comp_(tuples::get<1>(args_list.get_head()))
-  {
-    empty_initialize();
-  }
-
-  ordered_index_impl(
-    const ordered_index_impl<
-      KeyFromValue,Compare,SuperMeta,TagList,Category,AugmentPolicy>& x):
-    super(x),
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-    safe_super(),
-#endif
-
-    key(x.key),
-    comp_(x.comp_)
-  {
-    /* Copy ctor just takes the key and compare objects from x. The rest is
-     * done in a subsequent call to copy_().
-     */
-  }
-
-  ordered_index_impl(
-     const ordered_index_impl<
-       KeyFromValue,Compare,SuperMeta,TagList,Category,AugmentPolicy>& x,
-     do_not_copy_elements_tag):
-    super(x,do_not_copy_elements_tag()),
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-    safe_super(),
-#endif
-
-    key(x.key),
-    comp_(x.comp_)
-  {
-    empty_initialize();
-  }
-
-  ~ordered_index_impl()
-  {
-    /* the container is guaranteed to be empty by now */
-  }
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-  iterator       make_iterator(node_type* node){return iterator(node,this);}
-  const_iterator make_iterator(node_type* node)const
-    {return const_iterator(node,const_cast<ordered_index_impl*>(this));}
-#else
-  iterator       make_iterator(node_type* node){return iterator(node);}
-  const_iterator make_iterator(node_type* node)const
-                   {return const_iterator(node);}
-#endif
-
-  void copy_(
-    const ordered_index_impl<
-      KeyFromValue,Compare,SuperMeta,TagList,Category,AugmentPolicy>& x,
-    const copy_map_type& map)
-  {
-    if(!x.root()){
-      empty_initialize();
-    }
-    else{
-      header()->color()=x.header()->color();
-      AugmentPolicy::copy(x.header()->impl(),header()->impl());
-
-      node_type* root_cpy=map.find(static_cast<final_node_type*>(x.root()));
-      header()->parent()=root_cpy->impl();
-
-      node_type* leftmost_cpy=map.find(
-        static_cast<final_node_type*>(x.leftmost()));
-      header()->left()=leftmost_cpy->impl();
-
-      node_type* rightmost_cpy=map.find(
-        static_cast<final_node_type*>(x.rightmost()));
-      header()->right()=rightmost_cpy->impl();
-
-      typedef typename copy_map_type::const_iterator copy_map_iterator;
-      for(copy_map_iterator it=map.begin(),it_end=map.end();it!=it_end;++it){
-        node_type* org=it->first;
-        node_type* cpy=it->second;
-
-        cpy->color()=org->color();
-        AugmentPolicy::copy(org->impl(),cpy->impl());
-
-        node_impl_pointer parent_org=org->parent();
-        if(parent_org==node_impl_pointer(0))cpy->parent()=node_impl_pointer(0);
-        else{
-          node_type* parent_cpy=map.find(
-            static_cast<final_node_type*>(node_type::from_impl(parent_org)));
-          cpy->parent()=parent_cpy->impl();
-          if(parent_org->left()==org->impl()){
-            parent_cpy->left()=cpy->impl();
-          }
-          else if(parent_org->right()==org->impl()){
-            /* header() does not satisfy this nor the previous check */
-            parent_cpy->right()=cpy->impl();
-          }
-        }
-
-        if(org->left()==node_impl_pointer(0))
-          cpy->left()=node_impl_pointer(0);
-        if(org->right()==node_impl_pointer(0))
-          cpy->right()=node_impl_pointer(0);
-      }
-    }
-    
-    super::copy_(x,map);
-  }
-
-  template<typename Variant>
-  final_node_type* insert_(
-    value_param_type v,final_node_type*& x,Variant variant)
-  {
-    link_info inf;
-    if(!link_point(key(v),inf,Category())){
-      return static_cast<final_node_type*>(node_type::from_impl(inf.pos));
-    }
-
-    final_node_type* res=super::insert_(v,x,variant);
-    if(res==x){
-      node_impl_type::link(
-        static_cast<node_type*>(x)->impl(),inf.side,inf.pos,header()->impl());
-    }
-    return res;
-  }
-
-  template<typename Variant>
-  final_node_type* insert_(
-    value_param_type v,node_type* position,final_node_type*& x,Variant variant)
-  {
-    link_info inf;
-    if(!hinted_link_point(key(v),position,inf,Category())){
-      return static_cast<final_node_type*>(node_type::from_impl(inf.pos));
-    }
-
-    final_node_type* res=super::insert_(v,position,x,variant);
-    if(res==x){
-      node_impl_type::link(
-        static_cast<node_type*>(x)->impl(),inf.side,inf.pos,header()->impl());
-    }
-    return res;
-  }
-
-  void erase_(node_type* x)
-  {
-    node_impl_type::rebalance_for_erase(
-      x->impl(),header()->parent(),header()->left(),header()->right());
-    super::erase_(x);
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-    detach_iterators(x);
-#endif
-  }
-
-  void delete_all_nodes_()
-  {
-    delete_all_nodes(root());
-  }
-
-  void clear_()
-  {
-    super::clear_();
-    empty_initialize();
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-    safe_super::detach_dereferenceable_iterators();
-#endif
-  }
-
-  void swap_(
-    ordered_index_impl<
-      KeyFromValue,Compare,SuperMeta,TagList,Category,AugmentPolicy>& x)
-  {
-    std::swap(key,x.key);
-    std::swap(comp_,x.comp_);
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-    safe_super::swap(x);
-#endif
-
-    super::swap_(x);
-  }
-
-  void swap_elements_(
-    ordered_index_impl<
-      KeyFromValue,Compare,SuperMeta,TagList,Category,AugmentPolicy>& x)
-  {
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-    safe_super::swap(x);
-#endif
-
-    super::swap_elements_(x);
-  }
-
-  template<typename Variant>
-  bool replace_(value_param_type v,node_type* x,Variant variant)
-  {
-    if(in_place(v,x,Category())){
-      return super::replace_(v,x,variant);
-    }
-
-    node_type* next=x;
-    node_type::increment(next);
-
-    node_impl_type::rebalance_for_erase(
-      x->impl(),header()->parent(),header()->left(),header()->right());
-
-    BOOST_TRY{
-      link_info inf;
-      if(link_point(key(v),inf,Category())&&super::replace_(v,x,variant)){
-        node_impl_type::link(x->impl(),inf.side,inf.pos,header()->impl());
-        return true;
-      }
-      node_impl_type::restore(x->impl(),next->impl(),header()->impl());
-      return false;
-    }
-    BOOST_CATCH(...){
-      node_impl_type::restore(x->impl(),next->impl(),header()->impl());
-      BOOST_RETHROW;
-    }
-    BOOST_CATCH_END
-  }
-
-  bool modify_(node_type* x)
-  {
-    bool b;
-    BOOST_TRY{
-      b=in_place(x->value(),x,Category());
-    }
-    BOOST_CATCH(...){
-      erase_(x);
-      BOOST_RETHROW;
-    }
-    BOOST_CATCH_END
-    if(!b){
-      node_impl_type::rebalance_for_erase(
-        x->impl(),header()->parent(),header()->left(),header()->right());
-      BOOST_TRY{
-        link_info inf;
-        if(!link_point(key(x->value()),inf,Category())){
-          super::erase_(x);
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-          detach_iterators(x);
-#endif
-          return false;
-        }
-        node_impl_type::link(x->impl(),inf.side,inf.pos,header()->impl());
-      }
-      BOOST_CATCH(...){
-        super::erase_(x);
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-        detach_iterators(x);
-#endif
-
-        BOOST_RETHROW;
-      }
-      BOOST_CATCH_END
-    }
-
-    BOOST_TRY{
-      if(!super::modify_(x)){
-        node_impl_type::rebalance_for_erase(
-          x->impl(),header()->parent(),header()->left(),header()->right());
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-        detach_iterators(x);
-#endif
-
-        return false;
-      }
-      else return true;
-    }
-    BOOST_CATCH(...){
-      node_impl_type::rebalance_for_erase(
-        x->impl(),header()->parent(),header()->left(),header()->right());
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-      detach_iterators(x);
-#endif
-
-      BOOST_RETHROW;
-    }
-    BOOST_CATCH_END
-  }
-
-  bool modify_rollback_(node_type* x)
-  {
-    if(in_place(x->value(),x,Category())){
-      return super::modify_rollback_(x);
-    }
-
-    node_type* next=x;
-    node_type::increment(next);
-
-    node_impl_type::rebalance_for_erase(
-      x->impl(),header()->parent(),header()->left(),header()->right());
-
-    BOOST_TRY{
-      link_info inf;
-      if(link_point(key(x->value()),inf,Category())&&
-         super::modify_rollback_(x)){
-        node_impl_type::link(x->impl(),inf.side,inf.pos,header()->impl());
-        return true;
-      }
-      node_impl_type::restore(x->impl(),next->impl(),header()->impl());
-      return false;
-    }
-    BOOST_CATCH(...){
-      node_impl_type::restore(x->impl(),next->impl(),header()->impl());
-      BOOST_RETHROW;
-    }
-    BOOST_CATCH_END
-  }
-
-#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
-  /* serialization */
-
-  template<typename Archive>
-  void save_(
-    Archive& ar,const unsigned int version,const index_saver_type& sm)const
-  {
-    save_(ar,version,sm,Category());
-  }
-
-  template<typename Archive>
-  void load_(Archive& ar,const unsigned int version,const index_loader_type& lm)
-  {
-    load_(ar,version,lm,Category());
-  }
-#endif
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING)
-  /* invariant stuff */
-
-  bool invariant_()const
-  {
-    if(size()==0||begin()==end()){
-      if(size()!=0||begin()!=end()||
-         header()->left()!=header()->impl()||
-         header()->right()!=header()->impl())return false;
-    }
-    else{
-      if((size_type)std::distance(begin(),end())!=size())return false;
-
-      std::size_t len=node_impl_type::black_count(
-        leftmost()->impl(),root()->impl());
-      for(const_iterator it=begin(),it_end=end();it!=it_end;++it){
-        node_type* x=it.get_node();
-        node_type* left_x=node_type::from_impl(x->left());
-        node_type* right_x=node_type::from_impl(x->right());
-
-        if(x->color()==red){
-          if((left_x&&left_x->color()==red)||
-             (right_x&&right_x->color()==red))return false;
-        }
-        if(left_x&&comp_(key(x->value()),key(left_x->value())))return false;
-        if(right_x&&comp_(key(right_x->value()),key(x->value())))return false;
-        if(!left_x&&!right_x&&
-           node_impl_type::black_count(x->impl(),root()->impl())!=len)
-          return false;
-        if(!AugmentPolicy::invariant(x->impl()))return false;
-      }
-    
-      if(leftmost()->impl()!=node_impl_type::minimum(root()->impl()))
-        return false;
-      if(rightmost()->impl()!=node_impl_type::maximum(root()->impl()))
-        return false;
-    }
-
-    return super::invariant_();
-  }
-
-  
-  /* This forwarding function eases things for the boost::mem_fn construct
-   * in BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT. Actually,
-   * final_check_invariant is already an inherited member function of
-   * ordered_index_impl.
-   */
-  void check_invariant_()const{this->final_check_invariant_();}
-#endif
-
-protected: /* for the benefit of AugmentPolicy::augmented_interface */
-  node_type* header()const{return this->final_header();}
-  node_type* root()const{return node_type::from_impl(header()->parent());}
-  node_type* leftmost()const{return node_type::from_impl(header()->left());}
-  node_type* rightmost()const{return node_type::from_impl(header()->right());}
-
-private:
-  void empty_initialize()
-  {
-    header()->color()=red;
-    /* used to distinguish header() from root, in iterator.operator++ */
-    
-    header()->parent()=node_impl_pointer(0);
-    header()->left()=header()->impl();
-    header()->right()=header()->impl();
-  }
-
-  struct link_info
-  {
-    /* coverity[uninit_ctor]: suppress warning */
-    link_info():side(to_left){}
-
-    ordered_index_side side;
-    node_impl_pointer  pos;
-  };
-
-  bool link_point(key_param_type k,link_info& inf,ordered_unique_tag)
-  {
-    node_type* y=header();
-    node_type* x=root();
-    bool c=true;
-    while(x){
-      y=x;
-      c=comp_(k,key(x->value()));
-      x=node_type::from_impl(c?x->left():x->right());
-    }
-    node_type* yy=y;
-    if(c){
-      if(yy==leftmost()){
-        inf.side=to_left;
-        inf.pos=y->impl();
-        return true;
-      }
-      else node_type::decrement(yy);
-    }
-
-    if(comp_(key(yy->value()),k)){
-      inf.side=c?to_left:to_right;
-      inf.pos=y->impl();
-      return true;
-    }
-    else{
-      inf.pos=yy->impl();
-      return false;
-    }
-  }
-
-  bool link_point(key_param_type k,link_info& inf,ordered_non_unique_tag)
-  {
-    node_type* y=header();
-    node_type* x=root();
-    bool c=true;
-    while (x){
-     y=x;
-     c=comp_(k,key(x->value()));
-     x=node_type::from_impl(c?x->left():x->right());
-    }
-    inf.side=c?to_left:to_right;
-    inf.pos=y->impl();
-    return true;
-  }
-
-  bool lower_link_point(key_param_type k,link_info& inf,ordered_non_unique_tag)
-  {
-    node_type* y=header();
-    node_type* x=root();
-    bool c=false;
-    while (x){
-     y=x;
-     c=comp_(key(x->value()),k);
-     x=node_type::from_impl(c?x->right():x->left());
-    }
-    inf.side=c?to_right:to_left;
-    inf.pos=y->impl();
-    return true;
-  }
-
-  bool hinted_link_point(
-    key_param_type k,node_type* position,link_info& inf,ordered_unique_tag)
-  {
-    if(position->impl()==header()->left()){ 
-      if(size()>0&&comp_(k,key(position->value()))){
-        inf.side=to_left;
-        inf.pos=position->impl();
-        return true;
-      }
-      else return link_point(k,inf,ordered_unique_tag());
-    } 
-    else if(position==header()){ 
-      if(comp_(key(rightmost()->value()),k)){
-        inf.side=to_right;
-        inf.pos=rightmost()->impl();
-        return true;
-      }
-      else return link_point(k,inf,ordered_unique_tag());
-    } 
-    else{
-      node_type* before=position;
-      node_type::decrement(before);
-      if(comp_(key(before->value()),k)&&comp_(k,key(position->value()))){
-        if(before->right()==node_impl_pointer(0)){
-          inf.side=to_right;
-          inf.pos=before->impl();
-          return true;
-        }
-        else{
-          inf.side=to_left;
-          inf.pos=position->impl();
-          return true;
-        }
-      } 
-      else return link_point(k,inf,ordered_unique_tag());
-    }
-  }
-
-  bool hinted_link_point(
-    key_param_type k,node_type* position,link_info& inf,ordered_non_unique_tag)
-  {
-    if(position->impl()==header()->left()){ 
-      if(size()>0&&!comp_(key(position->value()),k)){
-        inf.side=to_left;
-        inf.pos=position->impl();
-        return true;
-      }
-      else return lower_link_point(k,inf,ordered_non_unique_tag());
-    } 
-    else if(position==header()){
-      if(!comp_(k,key(rightmost()->value()))){
-        inf.side=to_right;
-        inf.pos=rightmost()->impl();
-        return true;
-      }
-      else return link_point(k,inf,ordered_non_unique_tag());
-    } 
-    else{
-      node_type* before=position;
-      node_type::decrement(before);
-      if(!comp_(k,key(before->value()))){
-        if(!comp_(key(position->value()),k)){
-          if(before->right()==node_impl_pointer(0)){
-            inf.side=to_right;
-            inf.pos=before->impl();
-            return true;
-          }
-          else{
-            inf.side=to_left;
-            inf.pos=position->impl();
-            return true;
-          }
-        }
-        else return lower_link_point(k,inf,ordered_non_unique_tag());
-      } 
-      else return link_point(k,inf,ordered_non_unique_tag());
-    }
-  }
-
-  void delete_all_nodes(node_type* x)
-  {
-    if(!x)return;
-
-    delete_all_nodes(node_type::from_impl(x->left()));
-    delete_all_nodes(node_type::from_impl(x->right()));
-    this->final_delete_node_(static_cast<final_node_type*>(x));
-  }
-
-  bool in_place(value_param_type v,node_type* x,ordered_unique_tag)
-  {
-    node_type* y;
-    if(x!=leftmost()){
-      y=x;
-      node_type::decrement(y);
-      if(!comp_(key(y->value()),key(v)))return false;
-    }
-
-    y=x;
-    node_type::increment(y);
-    return y==header()||comp_(key(v),key(y->value()));
-  }
-
-  bool in_place(value_param_type v,node_type* x,ordered_non_unique_tag)
-  {
-    node_type* y;
-    if(x!=leftmost()){
-      y=x;
-      node_type::decrement(y);
-      if(comp_(key(v),key(y->value())))return false;
-    }
-
-    y=x;
-    node_type::increment(y);
-    return y==header()||!comp_(key(y->value()),key(v));
-  }
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-  void detach_iterators(node_type* x)
-  {
-    iterator it=make_iterator(x);
-    safe_mode::detach_equivalent_iterators(it);
-  }
-#endif
-
-  template<BOOST_MULTI_INDEX_TEMPLATE_PARAM_PACK>
-  std::pair<iterator,bool> emplace_impl(BOOST_MULTI_INDEX_FUNCTION_PARAM_PACK)
-  {
-    BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT;
-    std::pair<final_node_type*,bool>p=
-      this->final_emplace_(BOOST_MULTI_INDEX_FORWARD_PARAM_PACK);
-    return std::pair<iterator,bool>(make_iterator(p.first),p.second);
-  }
-
-  template<BOOST_MULTI_INDEX_TEMPLATE_PARAM_PACK>
-  iterator emplace_hint_impl(
-    iterator position,BOOST_MULTI_INDEX_FUNCTION_PARAM_PACK)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
-    BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT;
-    std::pair<final_node_type*,bool>p=
-      this->final_emplace_hint_(
-        static_cast<final_node_type*>(position.get_node()),
-        BOOST_MULTI_INDEX_FORWARD_PARAM_PACK);
-    return make_iterator(p.first);
-  }
-
-  template<typename LowerBounder,typename UpperBounder>
-  std::pair<iterator,iterator>
-  range(LowerBounder lower,UpperBounder upper,none_unbounded_tag)const
-  {
-    node_type* y=header();
-    node_type* z=root();
-
-    while(z){
-      if(!lower(key(z->value()))){
-        z=node_type::from_impl(z->right());
-      }
-      else if(!upper(key(z->value()))){
-        y=z;
-        z=node_type::from_impl(z->left());
-      }
-      else{
-        return std::pair<iterator,iterator>(
-          make_iterator(
-            lower_range(node_type::from_impl(z->left()),z,lower)),
-          make_iterator(
-            upper_range(node_type::from_impl(z->right()),y,upper)));
-      }
-    }
-
-    return std::pair<iterator,iterator>(make_iterator(y),make_iterator(y));
-  }
-
-  template<typename LowerBounder,typename UpperBounder>
-  std::pair<iterator,iterator>
-  range(LowerBounder,UpperBounder upper,lower_unbounded_tag)const
-  {
-    return std::pair<iterator,iterator>(
-      begin(),
-      make_iterator(upper_range(root(),header(),upper)));
-  }
-
-  template<typename LowerBounder,typename UpperBounder>
-  std::pair<iterator,iterator>
-  range(LowerBounder lower,UpperBounder,upper_unbounded_tag)const
-  {
-    return std::pair<iterator,iterator>(
-      make_iterator(lower_range(root(),header(),lower)),
-      end());
-  }
-
-  template<typename LowerBounder,typename UpperBounder>
-  std::pair<iterator,iterator>
-  range(LowerBounder,UpperBounder,both_unbounded_tag)const
-  {
-    return std::pair<iterator,iterator>(begin(),end());
-  }
-
-  template<typename LowerBounder>
-  node_type * lower_range(node_type* top,node_type* y,LowerBounder lower)const
-  {
-    while(top){
-      if(lower(key(top->value()))){
-        y=top;
-        top=node_type::from_impl(top->left());
-      }
-      else top=node_type::from_impl(top->right());
-    }
-
-    return y;
-  }
-
-  template<typename UpperBounder>
-  node_type * upper_range(node_type* top,node_type* y,UpperBounder upper)const
-  {
-    while(top){
-      if(!upper(key(top->value()))){
-        y=top;
-        top=node_type::from_impl(top->left());
-      }
-      else top=node_type::from_impl(top->right());
-    }
-
-    return y;
-  }
-
-#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
-  template<typename Archive>
-  void save_(
-    Archive& ar,const unsigned int version,const index_saver_type& sm,
-    ordered_unique_tag)const
-  {
-    super::save_(ar,version,sm);
-  }
-
-  template<typename Archive>
-  void load_(
-    Archive& ar,const unsigned int version,const index_loader_type& lm,
-    ordered_unique_tag)
-  {
-    super::load_(ar,version,lm);
-  }
-
-  template<typename Archive>
-  void save_(
-    Archive& ar,const unsigned int version,const index_saver_type& sm,
-    ordered_non_unique_tag)const
-  {
-    typedef duplicates_iterator<node_type,value_compare> dup_iterator;
-
-    sm.save(
-      dup_iterator(begin().get_node(),end().get_node(),value_comp()),
-      dup_iterator(end().get_node(),value_comp()),
-      ar,version);
-    super::save_(ar,version,sm);
-  }
-
-  template<typename Archive>
-  void load_(
-    Archive& ar,const unsigned int version,const index_loader_type& lm,
-    ordered_non_unique_tag)
-  {
-    lm.load(
-      ::boost::bind(
-        &ordered_index_impl::rearranger,this,
-        ::boost::arg<1>(),::boost::arg<2>()),
-      ar,version);
-    super::load_(ar,version,lm);
-  }
-
-  void rearranger(node_type* position,node_type *x)
-  {
-    if(!position||comp_(key(position->value()),key(x->value()))){
-      position=lower_bound(key(x->value())).get_node();
-    }
-    else if(comp_(key(x->value()),key(position->value()))){
-      /* inconsistent rearrangement */
-      throw_exception(
-        archive::archive_exception(
-          archive::archive_exception::other_exception));
-    }
-    else node_type::increment(position);
-
-    if(position!=x){
-      node_impl_type::rebalance_for_erase(
-        x->impl(),header()->parent(),header()->left(),header()->right());
-      node_impl_type::restore(
-        x->impl(),position->impl(),header()->impl());
-    }
-  }
-#endif /* serialization */
-
-protected: /* for the benefit of AugmentPolicy::augmented_interface */
-  key_from_value key;
-  key_compare    comp_;
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING)&&\
-    BOOST_WORKAROUND(__MWERKS__,<=0x3003)
-#pragma parse_mfunc_templ reset
-#endif
-};
-
-template<
-  typename KeyFromValue,typename Compare,
-  typename SuperMeta,typename TagList,typename Category,typename AugmentPolicy
->
-class ordered_index:
-  public AugmentPolicy::template augmented_interface<
-    ordered_index_impl<
-      KeyFromValue,Compare,SuperMeta,TagList,Category,AugmentPolicy
-    >
-  >::type
-{
-  typedef typename AugmentPolicy::template
-    augmented_interface<
-      ordered_index_impl<
-        KeyFromValue,Compare,
-        SuperMeta,TagList,Category,AugmentPolicy
-      >
-    >::type                                       super;
-public:
-  typedef typename super::ctor_args_list          ctor_args_list;
-  typedef typename super::allocator_type          allocator_type;
-  typedef typename super::iterator                iterator;
-
-  /* construct/copy/destroy
-   * Default and copy ctors are in the protected section as indices are
-   * not supposed to be created on their own. No range ctor either.
-   */
-
-  ordered_index& operator=(const ordered_index& x)
-  {
-    this->final()=x.final();
-    return *this;
-  }
-
-#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
-  ordered_index& operator=(
-    std::initializer_list<BOOST_DEDUCED_TYPENAME super::value_type> list)
-  {
-    this->final()=list;
-    return *this;
-  }
-#endif
-
-protected:
-  ordered_index(
-    const ctor_args_list& args_list,const allocator_type& al):
-    super(args_list,al){}
-
-  ordered_index(const ordered_index& x):super(x){};
-
-  ordered_index(const ordered_index& x,do_not_copy_elements_tag):
-    super(x,do_not_copy_elements_tag()){};
-};
-
-/* comparison */
-
-template<
-  typename KeyFromValue1,typename Compare1,
-  typename SuperMeta1,typename TagList1,typename Category1,
-  typename AugmentPolicy1,
-  typename KeyFromValue2,typename Compare2,
-  typename SuperMeta2,typename TagList2,typename Category2,
-  typename AugmentPolicy2
->
-bool operator==(
-  const ordered_index<
-    KeyFromValue1,Compare1,SuperMeta1,TagList1,Category1,AugmentPolicy1>& x,
-  const ordered_index<
-    KeyFromValue2,Compare2,SuperMeta2,TagList2,Category2,AugmentPolicy2>& y)
-{
-  return x.size()==y.size()&&std::equal(x.begin(),x.end(),y.begin());
-}
-
-template<
-  typename KeyFromValue1,typename Compare1,
-  typename SuperMeta1,typename TagList1,typename Category1,
-  typename AugmentPolicy1,
-  typename KeyFromValue2,typename Compare2,
-  typename SuperMeta2,typename TagList2,typename Category2,
-  typename AugmentPolicy2
->
-bool operator<(
-  const ordered_index<
-    KeyFromValue1,Compare1,SuperMeta1,TagList1,Category1,AugmentPolicy1>& x,
-  const ordered_index<
-    KeyFromValue2,Compare2,SuperMeta2,TagList2,Category2,AugmentPolicy2>& y)
-{
-  return std::lexicographical_compare(x.begin(),x.end(),y.begin(),y.end());
-}
-
-template<
-  typename KeyFromValue1,typename Compare1,
-  typename SuperMeta1,typename TagList1,typename Category1,
-  typename AugmentPolicy1,
-  typename KeyFromValue2,typename Compare2,
-  typename SuperMeta2,typename TagList2,typename Category2,
-  typename AugmentPolicy2
->
-bool operator!=(
-  const ordered_index<
-    KeyFromValue1,Compare1,SuperMeta1,TagList1,Category1,AugmentPolicy1>& x,
-  const ordered_index<
-    KeyFromValue2,Compare2,SuperMeta2,TagList2,Category2,AugmentPolicy2>& y)
-{
-  return !(x==y);
-}
-
-template<
-  typename KeyFromValue1,typename Compare1,
-  typename SuperMeta1,typename TagList1,typename Category1,
-  typename AugmentPolicy1,
-  typename KeyFromValue2,typename Compare2,
-  typename SuperMeta2,typename TagList2,typename Category2,
-  typename AugmentPolicy2
->
-bool operator>(
-  const ordered_index<
-    KeyFromValue1,Compare1,SuperMeta1,TagList1,Category1,AugmentPolicy1>& x,
-  const ordered_index<
-    KeyFromValue2,Compare2,SuperMeta2,TagList2,Category2,AugmentPolicy2>& y)
-{
-  return y<x;
-}
-
-template<
-  typename KeyFromValue1,typename Compare1,
-  typename SuperMeta1,typename TagList1,typename Category1,
-  typename AugmentPolicy1,
-  typename KeyFromValue2,typename Compare2,
-  typename SuperMeta2,typename TagList2,typename Category2,
-  typename AugmentPolicy2
->
-bool operator>=(
-  const ordered_index<
-    KeyFromValue1,Compare1,SuperMeta1,TagList1,Category1,AugmentPolicy1>& x,
-  const ordered_index<
-    KeyFromValue2,Compare2,SuperMeta2,TagList2,Category2,AugmentPolicy2>& y)
-{
-  return !(x<y);
-}
-
-template<
-  typename KeyFromValue1,typename Compare1,
-  typename SuperMeta1,typename TagList1,typename Category1,
-  typename AugmentPolicy1,
-  typename KeyFromValue2,typename Compare2,
-  typename SuperMeta2,typename TagList2,typename Category2,
-  typename AugmentPolicy2
->
-bool operator<=(
-  const ordered_index<
-    KeyFromValue1,Compare1,SuperMeta1,TagList1,Category1,AugmentPolicy1>& x,
-  const ordered_index<
-    KeyFromValue2,Compare2,SuperMeta2,TagList2,Category2,AugmentPolicy2>& y)
-{
-  return !(x>y);
-}
-
-/*  specialized algorithms */
-
-template<
-  typename KeyFromValue,typename Compare,
-  typename SuperMeta,typename TagList,typename Category,typename AugmentPolicy
->
-void swap(
-  ordered_index<
-    KeyFromValue,Compare,SuperMeta,TagList,Category,AugmentPolicy>& x,
-  ordered_index<
-    KeyFromValue,Compare,SuperMeta,TagList,Category,AugmentPolicy>& y)
-{
-  x.swap(y);
-}
-
-} /* namespace multi_index::detail */
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-/* Boost.Foreach compatibility */
-
-template<
-  typename KeyFromValue,typename Compare,
-  typename SuperMeta,typename TagList,typename Category,typename AugmentPolicy
->
-inline boost::mpl::true_* boost_foreach_is_noncopyable(
-  boost::multi_index::detail::ordered_index<
-    KeyFromValue,Compare,SuperMeta,TagList,Category,AugmentPolicy>*&,
-  boost_foreach_argument_dependent_lookup_hack)
-{
-  return 0;
-}
-
-#undef BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT
-#undef BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT_OF
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/ord_index_impl_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/ord_index_impl_fwd.hpp
deleted file mode 100644
index 6590ef05fdd..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/ord_index_impl_fwd.hpp
+++ /dev/null
@@ -1,128 +0,0 @@
-/* Copyright 2003-2015 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_DETAIL_ORD_INDEX_IMPL_FWD_HPP
-#define BOOST_MULTI_INDEX_DETAIL_ORD_INDEX_IMPL_FWD_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-template<
-  typename KeyFromValue,typename Compare,
-  typename SuperMeta,typename TagList,typename Category,typename AugmentPolicy
->
-class ordered_index;
-
-template<
-  typename KeyFromValue1,typename Compare1,
-  typename SuperMeta1,typename TagList1,typename Category1,
-  typename AugmentPolicy1,
-  typename KeyFromValue2,typename Compare2,
-  typename SuperMeta2,typename TagList2,typename Category2,
-  typename AugmentPolicy2
->
-bool operator==(
-  const ordered_index<
-    KeyFromValue1,Compare1,SuperMeta1,TagList1,Category1,AugmentPolicy1>& x,
-  const ordered_index<
-    KeyFromValue2,Compare2,SuperMeta2,TagList2,Category2,AugmentPolicy2>& y);
-
-template<
-  typename KeyFromValue1,typename Compare1,
-  typename SuperMeta1,typename TagList1,typename Category1,
-  typename AugmentPolicy1,
-  typename KeyFromValue2,typename Compare2,
-  typename SuperMeta2,typename TagList2,typename Category2,
-  typename AugmentPolicy2
->
-bool operator<(
-  const ordered_index<
-    KeyFromValue1,Compare1,SuperMeta1,TagList1,Category1,AugmentPolicy1>& x,
-  const ordered_index<
-    KeyFromValue2,Compare2,SuperMeta2,TagList2,Category2,AugmentPolicy2>& y);
-
-template<
-  typename KeyFromValue1,typename Compare1,
-  typename SuperMeta1,typename TagList1,typename Category1,
-  typename AugmentPolicy1,
-  typename KeyFromValue2,typename Compare2,
-  typename SuperMeta2,typename TagList2,typename Category2,
-  typename AugmentPolicy2
->
-bool operator!=(
-  const ordered_index<
-    KeyFromValue1,Compare1,SuperMeta1,TagList1,Category1,AugmentPolicy1>& x,
-  const ordered_index<
-    KeyFromValue2,Compare2,SuperMeta2,TagList2,Category2,AugmentPolicy2>& y);
-
-template<
-  typename KeyFromValue1,typename Compare1,
-  typename SuperMeta1,typename TagList1,typename Category1,
-  typename AugmentPolicy1,
-  typename KeyFromValue2,typename Compare2,
-  typename SuperMeta2,typename TagList2,typename Category2,
-  typename AugmentPolicy2
->
-bool operator>(
-  const ordered_index<
-    KeyFromValue1,Compare1,SuperMeta1,TagList1,Category1,AugmentPolicy1>& x,
-  const ordered_index<
-    KeyFromValue2,Compare2,SuperMeta2,TagList2,Category2,AugmentPolicy2>& y);
-
-template<
-  typename KeyFromValue1,typename Compare1,
-  typename SuperMeta1,typename TagList1,typename Category1,
-  typename AugmentPolicy1,
-  typename KeyFromValue2,typename Compare2,
-  typename SuperMeta2,typename TagList2,typename Category2,
-  typename AugmentPolicy2
->
-bool operator>=(
-  const ordered_index<
-    KeyFromValue1,Compare1,SuperMeta1,TagList1,Category1,AugmentPolicy1>& x,
-  const ordered_index<
-    KeyFromValue2,Compare2,SuperMeta2,TagList2,Category2,AugmentPolicy2>& y);
-
-template<
-  typename KeyFromValue1,typename Compare1,
-  typename SuperMeta1,typename TagList1,typename Category1,
-  typename AugmentPolicy1,
-  typename KeyFromValue2,typename Compare2,
-  typename SuperMeta2,typename TagList2,typename Category2,
-  typename AugmentPolicy2
->
-bool operator<=(
-  const ordered_index<
-    KeyFromValue1,Compare1,SuperMeta1,TagList1,Category1,AugmentPolicy1>& x,
-  const ordered_index<
-    KeyFromValue2,Compare2,SuperMeta2,TagList2,Category2,AugmentPolicy2>& y);
-
-template<
-  typename KeyFromValue,typename Compare,
-  typename SuperMeta,typename TagList,typename Category,typename AugmentPolicy
->
-void swap(
-  ordered_index<
-    KeyFromValue,Compare,SuperMeta,TagList,Category,AugmentPolicy>& x,
-  ordered_index<
-    KeyFromValue,Compare,SuperMeta,TagList,Category,AugmentPolicy>& y);
-
-} /* namespace multi_index::detail */
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/ord_index_node.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/ord_index_node.hpp
deleted file mode 100644
index e7af0377fb9..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/ord_index_node.hpp
+++ /dev/null
@@ -1,658 +0,0 @@
-/* Copyright 2003-2015 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- *
- * The internal implementation of red-black trees is based on that of SGI STL
- * stl_tree.h file: 
- *
- * Copyright (c) 1996,1997
- * Silicon Graphics Computer Systems, Inc.
- *
- * Permission to use, copy, modify, distribute and sell this software
- * and its documentation for any purpose is hereby granted without fee,
- * provided that the above copyright notice appear in all copies and
- * that both that copyright notice and this permission notice appear
- * in supporting documentation.  Silicon Graphics makes no
- * representations about the suitability of this software for any
- * purpose.  It is provided "as is" without express or implied warranty.
- *
- *
- * Copyright (c) 1994
- * Hewlett-Packard Company
- *
- * Permission to use, copy, modify, distribute and sell this software
- * and its documentation for any purpose is hereby granted without fee,
- * provided that the above copyright notice appear in all copies and
- * that both that copyright notice and this permission notice appear
- * in supporting documentation.  Hewlett-Packard Company makes no
- * representations about the suitability of this software for any
- * purpose.  It is provided "as is" without express or implied warranty.
- *
- */
-
-#ifndef BOOST_MULTI_INDEX_DETAIL_ORD_INDEX_NODE_HPP
-#define BOOST_MULTI_INDEX_DETAIL_ORD_INDEX_NODE_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <cstddef>
-#include <boost/detail/allocator_utilities.hpp>
-#include <boost/multi_index/detail/raw_ptr.hpp>
-
-#if !defined(BOOST_MULTI_INDEX_DISABLE_COMPRESSED_ORDERED_INDEX_NODES)
-#include <boost/mpl/and.hpp>
-#include <boost/mpl/if.hpp>
-#include <boost/multi_index/detail/uintptr_type.hpp>
-#include <boost/type_traits/alignment_of.hpp>
-#include <boost/type_traits/is_same.hpp>
-#endif
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-/* definition of red-black nodes for ordered_index */
-
-enum ordered_index_color{red=false,black=true};
-enum ordered_index_side{to_left=false,to_right=true};
-
-template<typename AugmentPolicy,typename Allocator>
-struct ordered_index_node_impl; /* fwd decl. */
-
-template<typename AugmentPolicy,typename Allocator>
-struct ordered_index_node_std_base
-{
-  typedef typename
-  boost::detail::allocator::rebind_to<
-    Allocator,
-    ordered_index_node_impl<AugmentPolicy,Allocator>
-  >::type::pointer                                   pointer;
-  typedef typename
-  boost::detail::allocator::rebind_to<
-    Allocator,
-    ordered_index_node_impl<AugmentPolicy,Allocator>
-  >::type::const_pointer                             const_pointer;
-  typedef ordered_index_color&                       color_ref;
-  typedef pointer&                                   parent_ref;
-
-  ordered_index_color& color(){return color_;}
-  ordered_index_color  color()const{return color_;}
-  pointer&             parent(){return parent_;}
-  pointer              parent()const{return parent_;}
-  pointer&             left(){return left_;}
-  pointer              left()const{return left_;}
-  pointer&             right(){return right_;}
-  pointer              right()const{return right_;}
-
-private:
-  ordered_index_color color_; 
-  pointer             parent_;
-  pointer             left_;
-  pointer             right_;
-};
-
-#if !defined(BOOST_MULTI_INDEX_DISABLE_COMPRESSED_ORDERED_INDEX_NODES)
-/* If ordered_index_node_impl has even alignment, we can use the least
- * significant bit of one of the ordered_index_node_impl pointers to
- * store color information. This typically reduces the size of
- * ordered_index_node_impl by 25%.
- */
-
-#if defined(BOOST_MSVC)
-/* This code casts pointers to an integer type that has been computed
- * to be large enough to hold the pointer, however the metaprogramming
- * logic is not always spotted by the VC++ code analyser that issues a
- * long list of warnings.
- */
-
-#pragma warning(push)
-#pragma warning(disable:4312 4311)
-#endif
-
-template<typename AugmentPolicy,typename Allocator>
-struct ordered_index_node_compressed_base
-{
-  typedef ordered_index_node_impl<
-    AugmentPolicy,Allocator>*            pointer;
-  typedef const ordered_index_node_impl<
-    AugmentPolicy,Allocator>*            const_pointer;
-
-  struct color_ref
-  {
-    color_ref(uintptr_type* r_):r(r_){}
-    
-    operator ordered_index_color()const
-    {
-      return ordered_index_color(*r&uintptr_type(1));
-    }
-    
-    color_ref& operator=(ordered_index_color c)
-    {
-      *r&=~uintptr_type(1);
-      *r|=uintptr_type(c);
-      return *this;
-    }
-    
-    color_ref& operator=(const color_ref& x)
-    {
-      return operator=(x.operator ordered_index_color());
-    }
-    
-  private:
-    uintptr_type* r;
-  };
-  
-  struct parent_ref
-  {
-    parent_ref(uintptr_type* r_):r(r_){}
-    
-    operator pointer()const
-    {
-      return (pointer)(void*)(*r&~uintptr_type(1));
-    }
-    
-    parent_ref& operator=(pointer p)
-    {
-      *r=((uintptr_type)(void*)p)|(*r&uintptr_type(1));
-      return *this;
-    }
-    
-    parent_ref& operator=(const parent_ref& x)
-    {
-      return operator=(x.operator pointer());
-    }
-
-    pointer operator->()const
-    {
-      return operator pointer();
-    }
-
-  private:
-    uintptr_type* r;
-  };
-  
-  color_ref           color(){return color_ref(&parentcolor_);}
-  ordered_index_color color()const
-  {
-    return ordered_index_color(parentcolor_&uintptr_type(1));
-  }
-
-  parent_ref parent(){return parent_ref(&parentcolor_);}
-  pointer    parent()const
-  {
-    return (pointer)(void*)(parentcolor_&~uintptr_type(1));
-  }
-
-  pointer& left(){return left_;}
-  pointer  left()const{return left_;}
-  pointer& right(){return right_;}
-  pointer  right()const{return right_;}
-
-private:
-  uintptr_type parentcolor_;
-  pointer      left_;
-  pointer      right_;
-};
-#if defined(BOOST_MSVC)
-#pragma warning(pop)
-#endif
-#endif
-
-template<typename AugmentPolicy,typename Allocator>
-struct ordered_index_node_impl_base:
-
-#if !defined(BOOST_MULTI_INDEX_DISABLE_COMPRESSED_ORDERED_INDEX_NODES)
-  AugmentPolicy::template augmented_node<
-    typename mpl::if_c<
-      !(has_uintptr_type::value)||
-      (alignment_of<
-        ordered_index_node_compressed_base<AugmentPolicy,Allocator>
-       >::value%2)||
-      !(is_same<
-        typename boost::detail::allocator::rebind_to<
-          Allocator,
-          ordered_index_node_impl<AugmentPolicy,Allocator>
-        >::type::pointer,
-        ordered_index_node_impl<AugmentPolicy,Allocator>*>::value),
-      ordered_index_node_std_base<AugmentPolicy,Allocator>,
-      ordered_index_node_compressed_base<AugmentPolicy,Allocator>
-    >::type
-  >::type
-#else
-  AugmentPolicy::template augmented_node<
-    ordered_index_node_std_base<AugmentPolicy,Allocator>
-  >::type
-#endif
-
-{};
-
-template<typename AugmentPolicy,typename Allocator>
-struct ordered_index_node_impl:
-  ordered_index_node_impl_base<AugmentPolicy,Allocator>
-{
-private:
-  typedef ordered_index_node_impl_base<AugmentPolicy,Allocator> super;
-
-public:
-  typedef typename super::color_ref                             color_ref;
-  typedef typename super::parent_ref                            parent_ref;
-  typedef typename super::pointer                               pointer;
-  typedef typename super::const_pointer                         const_pointer;
-
-  /* interoperability with bidir_node_iterator */
-
-  static void increment(pointer& x)
-  {
-    if(x->right()!=pointer(0)){
-      x=x->right();
-      while(x->left()!=pointer(0))x=x->left();
-    }
-    else{
-      pointer y=x->parent();
-      while(x==y->right()){
-        x=y;
-        y=y->parent();
-      }
-      if(x->right()!=y)x=y;
-    }
-  }
-
-  static void decrement(pointer& x)
-  {
-    if(x->color()==red&&x->parent()->parent()==x){
-      x=x->right();
-    }
-    else if(x->left()!=pointer(0)){
-      pointer y=x->left();
-      while(y->right()!=pointer(0))y=y->right();
-      x=y;
-    }else{
-      pointer y=x->parent();
-      while(x==y->left()){
-        x=y;
-        y=y->parent();
-      }
-      x=y;
-    }
-  }
-
-  /* algorithmic stuff */
-
-  static void rotate_left(pointer x,parent_ref root)
-  {
-    pointer y=x->right();
-    x->right()=y->left();
-    if(y->left()!=pointer(0))y->left()->parent()=x;
-    y->parent()=x->parent();
-    
-    if(x==root)                    root=y;
-    else if(x==x->parent()->left())x->parent()->left()=y;
-    else                           x->parent()->right()=y;
-    y->left()=x;
-    x->parent()=y;
-    AugmentPolicy::rotate_left(x,y);
-  }
-
-  static pointer minimum(pointer x)
-  {
-    while(x->left()!=pointer(0))x=x->left();
-    return x;
-  }
-
-  static pointer maximum(pointer x)
-  {
-    while(x->right()!=pointer(0))x=x->right();
-    return x;
-  }
-
-  static void rotate_right(pointer x,parent_ref root)
-  {
-    pointer y=x->left();
-    x->left()=y->right();
-    if(y->right()!=pointer(0))y->right()->parent()=x;
-    y->parent()=x->parent();
-
-    if(x==root)                     root=y;
-    else if(x==x->parent()->right())x->parent()->right()=y;
-    else                            x->parent()->left()=y;
-    y->right()=x;
-    x->parent()=y;
-    AugmentPolicy::rotate_right(x,y);
-  }
-
-  static void rebalance(pointer x,parent_ref root)
-  {
-    x->color()=red;
-    while(x!=root&&x->parent()->color()==red){
-      if(x->parent()==x->parent()->parent()->left()){
-        pointer y=x->parent()->parent()->right();
-        if(y!=pointer(0)&&y->color()==red){
-          x->parent()->color()=black;
-          y->color()=black;
-          x->parent()->parent()->color()=red;
-          x=x->parent()->parent();
-        }
-        else{
-          if(x==x->parent()->right()){
-            x=x->parent();
-            rotate_left(x,root);
-          }
-          x->parent()->color()=black;
-          x->parent()->parent()->color()=red;
-          rotate_right(x->parent()->parent(),root);
-        }
-      }
-      else{
-        pointer y=x->parent()->parent()->left();
-        if(y!=pointer(0)&&y->color()==red){
-          x->parent()->color()=black;
-          y->color()=black;
-          x->parent()->parent()->color()=red;
-          x=x->parent()->parent();
-        }
-        else{
-          if(x==x->parent()->left()){
-            x=x->parent();
-            rotate_right(x,root);
-          }
-          x->parent()->color()=black;
-          x->parent()->parent()->color()=red;
-          rotate_left(x->parent()->parent(),root);
-        }
-      }
-    }
-    root->color()=black;
-  }
-
-  static void link(
-    pointer x,ordered_index_side side,pointer position,pointer header)
-  {
-    if(side==to_left){
-      position->left()=x;  /* also makes leftmost=x when parent==header */
-      if(position==header){
-        header->parent()=x;
-        header->right()=x;
-      }
-      else if(position==header->left()){
-        header->left()=x;  /* maintain leftmost pointing to min node */
-      }
-    }
-    else{
-      position->right()=x;
-      if(position==header->right()){
-        header->right()=x; /* maintain rightmost pointing to max node */
-      }
-    }
-    x->parent()=position;
-    x->left()=pointer(0);
-    x->right()=pointer(0);
-    AugmentPolicy::add(x,pointer(header->parent()));
-    ordered_index_node_impl::rebalance(x,header->parent());
-  }
-
-  static pointer rebalance_for_erase(
-    pointer z,parent_ref root,pointer& leftmost,pointer& rightmost)
-  {
-    pointer y=z;
-    pointer x=pointer(0);
-    pointer x_parent=pointer(0);
-    if(y->left()==pointer(0)){    /* z has at most one non-null child. y==z. */
-      x=y->right();               /* x might be null */
-    }
-    else{
-      if(y->right()==pointer(0)){ /* z has exactly one non-null child. y==z. */
-        x=y->left();              /* x is not null */
-      }
-      else{                       /* z has two non-null children.  Set y to */
-        y=y->right();             /* z's successor. x might be null.        */
-        while(y->left()!=pointer(0))y=y->left();
-        x=y->right();
-      }
-    }
-    AugmentPolicy::remove(y,pointer(root));
-    if(y!=z){
-      AugmentPolicy::copy(z,y);
-      z->left()->parent()=y;   /* relink y in place of z. y is z's successor */
-      y->left()=z->left();
-      if(y!=z->right()){
-        x_parent=y->parent();
-        if(x!=pointer(0))x->parent()=y->parent();
-        y->parent()->left()=x; /* y must be a child of left */
-        y->right()=z->right();
-        z->right()->parent()=y;
-      }
-      else{
-        x_parent=y;
-      }
-
-      if(root==z)                    root=y;
-      else if(z->parent()->left()==z)z->parent()->left()=y;
-      else                           z->parent()->right()=y;
-      y->parent()=z->parent();
-      ordered_index_color c=y->color();
-      y->color()=z->color();
-      z->color()=c;
-      y=z;                    /* y now points to node to be actually deleted */
-    }
-    else{                     /* y==z */
-      x_parent=y->parent();
-      if(x!=pointer(0))x->parent()=y->parent();   
-      if(root==z){
-        root=x;
-      }
-      else{
-        if(z->parent()->left()==z)z->parent()->left()=x;
-        else                      z->parent()->right()=x;
-      }
-      if(leftmost==z){
-        if(z->right()==pointer(0)){ /* z->left() must be null also */
-          leftmost=z->parent();
-        }
-        else{              
-          leftmost=minimum(x);      /* makes leftmost==header if z==root */
-        }
-      }
-      if(rightmost==z){
-        if(z->left()==pointer(0)){  /* z->right() must be null also */
-          rightmost=z->parent();
-        }
-        else{                   /* x==z->left() */
-          rightmost=maximum(x); /* makes rightmost==header if z==root */
-        }
-      }
-    }
-    if(y->color()!=red){
-      while(x!=root&&(x==pointer(0)|| x->color()==black)){
-        if(x==x_parent->left()){
-          pointer w=x_parent->right();
-          if(w->color()==red){
-            w->color()=black;
-            x_parent->color()=red;
-            rotate_left(x_parent,root);
-            w=x_parent->right();
-          }
-          if((w->left()==pointer(0)||w->left()->color()==black) &&
-             (w->right()==pointer(0)||w->right()->color()==black)){
-            w->color()=red;
-            x=x_parent;
-            x_parent=x_parent->parent();
-          } 
-          else{
-            if(w->right()==pointer(0 )
-                || w->right()->color()==black){
-              if(w->left()!=pointer(0)) w->left()->color()=black;
-              w->color()=red;
-              rotate_right(w,root);
-              w=x_parent->right();
-            }
-            w->color()=x_parent->color();
-            x_parent->color()=black;
-            if(w->right()!=pointer(0))w->right()->color()=black;
-            rotate_left(x_parent,root);
-            break;
-          }
-        } 
-        else{                   /* same as above,with right <-> left */
-          pointer w=x_parent->left();
-          if(w->color()==red){
-            w->color()=black;
-            x_parent->color()=red;
-            rotate_right(x_parent,root);
-            w=x_parent->left();
-          }
-          if((w->right()==pointer(0)||w->right()->color()==black) &&
-             (w->left()==pointer(0)||w->left()->color()==black)){
-            w->color()=red;
-            x=x_parent;
-            x_parent=x_parent->parent();
-          }
-          else{
-            if(w->left()==pointer(0)||w->left()->color()==black){
-              if(w->right()!=pointer(0))w->right()->color()=black;
-              w->color()=red;
-              rotate_left(w,root);
-              w=x_parent->left();
-            }
-            w->color()=x_parent->color();
-            x_parent->color()=black;
-            if(w->left()!=pointer(0))w->left()->color()=black;
-            rotate_right(x_parent,root);
-            break;
-          }
-        }
-      }
-      if(x!=pointer(0))x->color()=black;
-    }
-    return y;
-  }
-
-  static void restore(pointer x,pointer position,pointer header)
-  {
-    if(position->left()==pointer(0)||position->left()==header){
-      link(x,to_left,position,header);
-    }
-    else{
-      decrement(position);
-      link(x,to_right,position,header);
-    }
-  }
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING)
-  /* invariant stuff */
-
-  static std::size_t black_count(pointer node,pointer root)
-  {
-    if(node==pointer(0))return 0;
-    std::size_t sum=0;
-    for(;;){
-      if(node->color()==black)++sum;
-      if(node==root)break;
-      node=node->parent();
-    } 
-    return sum;
-  }
-#endif
-};
-
-template<typename AugmentPolicy,typename Super>
-struct ordered_index_node_trampoline:
-  ordered_index_node_impl<
-    AugmentPolicy,
-    typename boost::detail::allocator::rebind_to<
-      typename Super::allocator_type,
-      char
-    >::type
-  >
-{
-  typedef ordered_index_node_impl<
-    AugmentPolicy,
-    typename boost::detail::allocator::rebind_to<
-      typename Super::allocator_type,
-      char
-    >::type
-  > impl_type;
-};
-
-template<typename AugmentPolicy,typename Super>
-struct ordered_index_node:
-  Super,ordered_index_node_trampoline<AugmentPolicy,Super>
-{
-private:
-  typedef ordered_index_node_trampoline<AugmentPolicy,Super> trampoline;
-
-public:
-  typedef typename trampoline::impl_type     impl_type;
-  typedef typename trampoline::color_ref     impl_color_ref;
-  typedef typename trampoline::parent_ref    impl_parent_ref;
-  typedef typename trampoline::pointer       impl_pointer;
-  typedef typename trampoline::const_pointer const_impl_pointer;
-
-  impl_color_ref      color(){return trampoline::color();}
-  ordered_index_color color()const{return trampoline::color();}
-  impl_parent_ref     parent(){return trampoline::parent();}
-  impl_pointer        parent()const{return trampoline::parent();}
-  impl_pointer&       left(){return trampoline::left();}
-  impl_pointer        left()const{return trampoline::left();}
-  impl_pointer&       right(){return trampoline::right();}
-  impl_pointer        right()const{return trampoline::right();}
-
-  impl_pointer impl()
-  {
-    return static_cast<impl_pointer>(
-      static_cast<impl_type*>(static_cast<trampoline*>(this)));
-  }
-
-  const_impl_pointer impl()const
-  {
-    return static_cast<const_impl_pointer>(
-      static_cast<const impl_type*>(static_cast<const trampoline*>(this)));
-  }
-
-  static ordered_index_node* from_impl(impl_pointer x)
-  {
-    return
-      static_cast<ordered_index_node*>(
-        static_cast<trampoline*>(
-          raw_ptr<impl_type*>(x)));
-  }
-
-  static const ordered_index_node* from_impl(const_impl_pointer x)
-  {
-    return
-      static_cast<const ordered_index_node*>(
-        static_cast<const trampoline*>(
-          raw_ptr<const impl_type*>(x)));
-  }
-
-  /* interoperability with bidir_node_iterator */
-
-  static void increment(ordered_index_node*& x)
-  {
-    impl_pointer xi=x->impl();
-    trampoline::increment(xi);
-    x=from_impl(xi);
-  }
-
-  static void decrement(ordered_index_node*& x)
-  {
-    impl_pointer xi=x->impl();
-    trampoline::decrement(xi);
-    x=from_impl(xi);
-  }
-};
-
-} /* namespace multi_index::detail */
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/ord_index_ops.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/ord_index_ops.hpp
deleted file mode 100644
index 84d5cacae19..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/ord_index_ops.hpp
+++ /dev/null
@@ -1,266 +0,0 @@
-/* Copyright 2003-2014 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- *
- * The internal implementation of red-black trees is based on that of SGI STL
- * stl_tree.h file: 
- *
- * Copyright (c) 1996,1997
- * Silicon Graphics Computer Systems, Inc.
- *
- * Permission to use, copy, modify, distribute and sell this software
- * and its documentation for any purpose is hereby granted without fee,
- * provided that the above copyright notice appear in all copies and
- * that both that copyright notice and this permission notice appear
- * in supporting documentation.  Silicon Graphics makes no
- * representations about the suitability of this software for any
- * purpose.  It is provided "as is" without express or implied warranty.
- *
- *
- * Copyright (c) 1994
- * Hewlett-Packard Company
- *
- * Permission to use, copy, modify, distribute and sell this software
- * and its documentation for any purpose is hereby granted without fee,
- * provided that the above copyright notice appear in all copies and
- * that both that copyright notice and this permission notice appear
- * in supporting documentation.  Hewlett-Packard Company makes no
- * representations about the suitability of this software for any
- * purpose.  It is provided "as is" without express or implied warranty.
- *
- */
-
-#ifndef BOOST_MULTI_INDEX_DETAIL_ORD_INDEX_OPS_HPP
-#define BOOST_MULTI_INDEX_DETAIL_ORD_INDEX_OPS_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <boost/mpl/and.hpp>
-#include <boost/multi_index/detail/promotes_arg.hpp>
-#include <utility>
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-/* Common code for index memfuns having templatized and
- * non-templatized versions.
- * Implementation note: When CompatibleKey is consistently promoted to
- * KeyFromValue::result_type for comparison, the promotion is made once in
- * advance to increase efficiency.
- */
-
-template<
-  typename Node,typename KeyFromValue,
-  typename CompatibleKey,typename CompatibleCompare
->
-inline Node* ordered_index_find(
-  Node* top,Node* y,const KeyFromValue& key,const CompatibleKey& x,
-  const CompatibleCompare& comp)
-{
-  typedef typename KeyFromValue::result_type key_type;
-
-  return ordered_index_find(
-    top,y,key,x,comp,
-    mpl::and_<
-      promotes_1st_arg<CompatibleCompare,CompatibleKey,key_type>,
-      promotes_2nd_arg<CompatibleCompare,key_type,CompatibleKey> >());
-}
-
-template<
-  typename Node,typename KeyFromValue,
-  typename CompatibleCompare
->
-inline Node* ordered_index_find(
-  Node* top,Node* y,const KeyFromValue& key,
-  const BOOST_DEDUCED_TYPENAME KeyFromValue::result_type& x,
-  const CompatibleCompare& comp,mpl::true_)
-{
-  return ordered_index_find(top,y,key,x,comp,mpl::false_());
-}
-
-template<
-  typename Node,typename KeyFromValue,
-  typename CompatibleKey,typename CompatibleCompare
->
-inline Node* ordered_index_find(
-  Node* top,Node* y,const KeyFromValue& key,const CompatibleKey& x,
-  const CompatibleCompare& comp,mpl::false_)
-{
-  Node* y0=y;
-
-  while (top){
-    if(!comp(key(top->value()),x)){
-      y=top;
-      top=Node::from_impl(top->left());
-    }
-    else top=Node::from_impl(top->right());
-  }
-    
-  return (y==y0||comp(x,key(y->value())))?y0:y;
-}
-
-template<
-  typename Node,typename KeyFromValue,
-  typename CompatibleKey,typename CompatibleCompare
->
-inline Node* ordered_index_lower_bound(
-  Node* top,Node* y,const KeyFromValue& key,const CompatibleKey& x,
-  const CompatibleCompare& comp)
-{
-  typedef typename KeyFromValue::result_type key_type;
-
-  return ordered_index_lower_bound(
-    top,y,key,x,comp,
-    promotes_2nd_arg<CompatibleCompare,key_type,CompatibleKey>());
-}
-
-template<
-  typename Node,typename KeyFromValue,
-  typename CompatibleCompare
->
-inline Node* ordered_index_lower_bound(
-  Node* top,Node* y,const KeyFromValue& key,
-  const BOOST_DEDUCED_TYPENAME KeyFromValue::result_type& x,
-  const CompatibleCompare& comp,mpl::true_)
-{
-  return ordered_index_lower_bound(top,y,key,x,comp,mpl::false_());
-}
-
-template<
-  typename Node,typename KeyFromValue,
-  typename CompatibleKey,typename CompatibleCompare
->
-inline Node* ordered_index_lower_bound(
-  Node* top,Node* y,const KeyFromValue& key,const CompatibleKey& x,
-  const CompatibleCompare& comp,mpl::false_)
-{
-  while(top){
-    if(!comp(key(top->value()),x)){
-      y=top;
-      top=Node::from_impl(top->left());
-    }
-    else top=Node::from_impl(top->right());
-  }
-
-  return y;
-}
-
-template<
-  typename Node,typename KeyFromValue,
-  typename CompatibleKey,typename CompatibleCompare
->
-inline Node* ordered_index_upper_bound(
-  Node* top,Node* y,const KeyFromValue& key,const CompatibleKey& x,
-  const CompatibleCompare& comp)
-{
-  typedef typename KeyFromValue::result_type key_type;
-
-  return ordered_index_upper_bound(
-    top,y,key,x,comp,
-    promotes_1st_arg<CompatibleCompare,CompatibleKey,key_type>());
-}
-
-template<
-  typename Node,typename KeyFromValue,
-  typename CompatibleCompare
->
-inline Node* ordered_index_upper_bound(
-  Node* top,Node* y,const KeyFromValue& key,
-  const BOOST_DEDUCED_TYPENAME KeyFromValue::result_type& x,
-  const CompatibleCompare& comp,mpl::true_)
-{
-  return ordered_index_upper_bound(top,y,key,x,comp,mpl::false_());
-}
-
-template<
-  typename Node,typename KeyFromValue,
-  typename CompatibleKey,typename CompatibleCompare
->
-inline Node* ordered_index_upper_bound(
-  Node* top,Node* y,const KeyFromValue& key,const CompatibleKey& x,
-  const CompatibleCompare& comp,mpl::false_)
-{
-  while(top){
-    if(comp(x,key(top->value()))){
-      y=top;
-      top=Node::from_impl(top->left());
-    }
-    else top=Node::from_impl(top->right());
-  }
-
-  return y;
-}
-
-template<
-  typename Node,typename KeyFromValue,
-  typename CompatibleKey,typename CompatibleCompare
->
-inline std::pair<Node*,Node*> ordered_index_equal_range(
-  Node* top,Node* y,const KeyFromValue& key,const CompatibleKey& x,
-  const CompatibleCompare& comp)
-{
-  typedef typename KeyFromValue::result_type key_type;
-
-  return ordered_index_equal_range(
-    top,y,key,x,comp,
-    mpl::and_<
-      promotes_1st_arg<CompatibleCompare,CompatibleKey,key_type>,
-      promotes_2nd_arg<CompatibleCompare,key_type,CompatibleKey> >());
-}
-
-template<
-  typename Node,typename KeyFromValue,
-  typename CompatibleCompare
->
-inline std::pair<Node*,Node*> ordered_index_equal_range(
-  Node* top,Node* y,const KeyFromValue& key,
-  const BOOST_DEDUCED_TYPENAME KeyFromValue::result_type& x,
-  const CompatibleCompare& comp,mpl::true_)
-{
-  return ordered_index_equal_range(top,y,key,x,comp,mpl::false_());
-}
-
-template<
-  typename Node,typename KeyFromValue,
-  typename CompatibleKey,typename CompatibleCompare
->
-inline std::pair<Node*,Node*> ordered_index_equal_range(
-  Node* top,Node* y,const KeyFromValue& key,const CompatibleKey& x,
-  const CompatibleCompare& comp,mpl::false_)
-{
-  while(top){
-    if(comp(key(top->value()),x)){
-      top=Node::from_impl(top->right());
-    }
-    else if(comp(x,key(top->value()))){
-      y=top;
-      top=Node::from_impl(top->left());
-    }
-    else{
-      return std::pair<Node*,Node*>(
-        ordered_index_lower_bound(
-          Node::from_impl(top->left()),top,key,x,comp,mpl::false_()),
-        ordered_index_upper_bound(
-          Node::from_impl(top->right()),y,key,x,comp,mpl::false_()));
-    }
-  }
-
-  return std::pair<Node*,Node*>(y,y);
-}
-
-} /* namespace multi_index::detail */
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/promotes_arg.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/promotes_arg.hpp
deleted file mode 100644
index 7a11b6e9fbe..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/promotes_arg.hpp
+++ /dev/null
@@ -1,83 +0,0 @@
-/* Copyright 2003-2017 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_DETAIL_PROMOTES_ARG_HPP
-#define BOOST_MULTI_INDEX_DETAIL_PROMOTES_ARG_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <boost/detail/workaround.hpp>
-
-/* Metafunctions to check if f(arg1,arg2) promotes either arg1 to the type of
- * arg2 or viceversa. By default, (i.e. if it cannot be determined), no
- * promotion is assumed.
- */
-
-#if BOOST_WORKAROUND(BOOST_MSVC,<1400)
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-template<typename F,typename Arg1,typename Arg2>
-struct promotes_1st_arg:mpl::false_{};
-
-template<typename F,typename Arg1,typename Arg2>
-struct promotes_2nd_arg:mpl::false_{};
-
-} /* namespace multi_index::detail */
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#else
-
-#include <boost/mpl/and.hpp>
-#include <boost/mpl/bool.hpp>
-#include <boost/mpl/not.hpp>
-#include <boost/multi_index/detail/is_transparent.hpp>
-#include <boost/type_traits/is_convertible.hpp>
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-  
-template<typename F,typename Arg1,typename Arg2>
-struct promotes_1st_arg:
-  mpl::and_<
-    mpl::not_<is_transparent<F,Arg1,Arg2> >,
-    is_convertible<const Arg1,Arg2>,
-    is_transparent<F,Arg2,Arg2>
-  >
-{};
-
-template<typename F,typename Arg1,typename Arg2>
-struct promotes_2nd_arg:
-  mpl::and_<
-    mpl::not_<is_transparent<F,Arg1,Arg2> >,
-    is_convertible<const Arg2,Arg1>,
-    is_transparent<F,Arg1,Arg1>
-  >
-{};
-
-} /* namespace multi_index::detail */
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/raw_ptr.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/raw_ptr.hpp
deleted file mode 100644
index c32007435c0..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/raw_ptr.hpp
+++ /dev/null
@@ -1,52 +0,0 @@
-/* Copyright 2003-2015 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_DETAIL_RAW_PTR_HPP
-#define BOOST_MULTI_INDEX_DETAIL_RAW_PTR_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <boost/mpl/bool.hpp>
-#include <boost/type_traits/is_same.hpp>
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-/* gets the underlying pointer of a pointer-like value */
-
-template<typename RawPointer>
-inline RawPointer raw_ptr(RawPointer const& p,mpl::true_)
-{
-  return p;
-}
-
-template<typename RawPointer,typename Pointer>
-inline RawPointer raw_ptr(Pointer const& p,mpl::false_)
-{
-  return p==Pointer(0)?0:&*p;
-}
-
-template<typename RawPointer,typename Pointer>
-inline RawPointer raw_ptr(Pointer const& p)
-{
-  return raw_ptr<RawPointer>(p,is_same<RawPointer,Pointer>());
-}
-
-} /* namespace multi_index::detail */
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/restore_wstrict_aliasing.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/restore_wstrict_aliasing.hpp
deleted file mode 100644
index ee2c799d5a8..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/restore_wstrict_aliasing.hpp
+++ /dev/null
@@ -1,11 +0,0 @@
-/* Copyright 2003-2016 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#define BOOST_MULTI_INDEX_DETAIL_RESTORE_WSTRICT_ALIASING
-#include <boost/multi_index/detail/ignore_wstrict_aliasing.hpp>
-#undef BOOST_MULTI_INDEX_DETAIL_RESTORE_WSTRICT_ALIASING
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/rnd_index_loader.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/rnd_index_loader.hpp
deleted file mode 100644
index 4b00345a6d9..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/rnd_index_loader.hpp
+++ /dev/null
@@ -1,173 +0,0 @@
-/* Copyright 2003-2013 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_DETAIL_RND_INDEX_LOADER_HPP
-#define BOOST_MULTI_INDEX_DETAIL_RND_INDEX_LOADER_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <algorithm>
-#include <boost/detail/allocator_utilities.hpp>
-#include <boost/multi_index/detail/auto_space.hpp>
-#include <boost/multi_index/detail/rnd_index_ptr_array.hpp>
-#include <boost/noncopyable.hpp>
-#include <cstddef>
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-/* This class implements a serialization rearranger for random access
- * indices. In order to achieve O(n) performance, the following strategy
- * is followed: the nodes of the index are handled as if in a bidirectional
- * list, where the next pointers are stored in the original
- * random_access_index_ptr_array and the prev pointers are stored in
- * an auxiliary array. Rearranging of nodes in such a bidirectional list
- * is constant time. Once all the arrangements are performed (on destruction
- * time) the list is traversed in reverse order and
- * pointers are swapped and set accordingly so that they recover its
- * original semantics ( *(node->up())==node ) while retaining the
- * new order.
- */
-
-template<typename Allocator>
-class random_access_index_loader_base:private noncopyable
-{
-protected:
-  typedef random_access_index_node_impl<
-    typename boost::detail::allocator::rebind_to<
-      Allocator,
-      char
-    >::type
-  >                                                 node_impl_type;
-  typedef typename node_impl_type::pointer          node_impl_pointer;
-  typedef random_access_index_ptr_array<Allocator>  ptr_array;
-
-  random_access_index_loader_base(const Allocator& al_,ptr_array& ptrs_):
-    al(al_),
-    ptrs(ptrs_),
-    header(*ptrs.end()),
-    prev_spc(al,0),
-    preprocessed(false)
-  {}
-
-  ~random_access_index_loader_base()
-  {
-    if(preprocessed)
-    {
-      node_impl_pointer n=header;
-      next(n)=n;
-
-      for(std::size_t i=ptrs.size();i--;){
-        n=prev(n);
-        std::size_t d=position(n);
-        if(d!=i){
-          node_impl_pointer m=prev(next_at(i));
-          std::swap(m->up(),n->up());
-          next_at(d)=next_at(i);
-          std::swap(prev_at(d),prev_at(i));
-        }
-        next(n)=n;
-      }
-    }
-  }
-
-  void rearrange(node_impl_pointer position_,node_impl_pointer x)
-  {
-    preprocess(); /* only incur this penalty if rearrange() is ever called */
-    if(position_==node_impl_pointer(0))position_=header;
-    next(prev(x))=next(x);
-    prev(next(x))=prev(x);
-    prev(x)=position_;
-    next(x)=next(position_);
-    next(prev(x))=prev(next(x))=x;
-  }
-
-private:
-  void preprocess()
-  {
-    if(!preprocessed){
-      /* get space for the auxiliary prev array */
-      auto_space<node_impl_pointer,Allocator> tmp(al,ptrs.size()+1);
-      prev_spc.swap(tmp);
-
-      /* prev_spc elements point to the prev nodes */
-      std::rotate_copy(
-        &*ptrs.begin(),&*ptrs.end(),&*ptrs.end()+1,&*prev_spc.data());
-
-      /* ptrs elements point to the next nodes */
-      std::rotate(&*ptrs.begin(),&*ptrs.begin()+1,&*ptrs.end()+1);
-
-      preprocessed=true;
-    }
-  }
-
-  std::size_t position(node_impl_pointer x)const
-  {
-    return (std::size_t)(x->up()-ptrs.begin());
-  }
-
-  node_impl_pointer& next_at(std::size_t n)const
-  {
-    return *ptrs.at(n);
-  }
-
-  node_impl_pointer& prev_at(std::size_t n)const
-  {
-    return *(prev_spc.data()+n);
-  }
-
-  node_impl_pointer& next(node_impl_pointer x)const
-  {
-    return *(x->up());
-  }
-
-  node_impl_pointer& prev(node_impl_pointer x)const
-  {
-    return prev_at(position(x));
-  }
-
-  Allocator                               al;
-  ptr_array&                              ptrs;
-  node_impl_pointer                       header;
-  auto_space<node_impl_pointer,Allocator> prev_spc;
-  bool                                    preprocessed;
-};
-
-template<typename Node,typename Allocator>
-class random_access_index_loader:
-  private random_access_index_loader_base<Allocator>
-{
-  typedef random_access_index_loader_base<Allocator> super;
-  typedef typename super::node_impl_pointer          node_impl_pointer;
-  typedef typename super::ptr_array                  ptr_array;
-
-public:
-  random_access_index_loader(const Allocator& al_,ptr_array& ptrs_):
-    super(al_,ptrs_)
-  {}
-
-  void rearrange(Node* position_,Node *x)
-  {
-    super::rearrange(
-      position_?position_->impl():node_impl_pointer(0),x->impl());
-  }
-};
-
-} /* namespace multi_index::detail */
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/rnd_index_node.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/rnd_index_node.hpp
deleted file mode 100644
index ad61ea25dda..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/rnd_index_node.hpp
+++ /dev/null
@@ -1,273 +0,0 @@
-/* Copyright 2003-2015 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_DETAIL_RND_INDEX_NODE_HPP
-#define BOOST_MULTI_INDEX_DETAIL_RND_INDEX_NODE_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <algorithm>
-#include <boost/detail/allocator_utilities.hpp>
-#include <boost/integer/common_factor_rt.hpp>
-#include <boost/multi_index/detail/raw_ptr.hpp>
-#include <cstddef>
-#include <functional>
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-template<typename Allocator>
-struct random_access_index_node_impl
-{
-  typedef typename
-  boost::detail::allocator::rebind_to<
-    Allocator,random_access_index_node_impl
-  >::type::pointer                          pointer;
-  typedef typename
-  boost::detail::allocator::rebind_to<
-    Allocator,random_access_index_node_impl
-  >::type::const_pointer                    const_pointer;
-  typedef typename
-  boost::detail::allocator::rebind_to<
-    Allocator,pointer
-  >::type::pointer                          ptr_pointer;
-
-  ptr_pointer& up(){return up_;}
-  ptr_pointer  up()const{return up_;}
-
-  /* interoperability with rnd_node_iterator */
-
-  static void increment(pointer& x)
-  {
-    x=*(x->up()+1);
-  }
-
-  static void decrement(pointer& x)
-  {
-    x=*(x->up()-1);
-  }
-
-  static void advance(pointer& x,std::ptrdiff_t n)
-  {
-    x=*(x->up()+n);
-  }
-
-  static std::ptrdiff_t distance(pointer x,pointer y)
-  {
-    return y->up()-x->up();
-  }
-
-  /* algorithmic stuff */
-
-  static void relocate(ptr_pointer pos,ptr_pointer x)
-  {
-    pointer n=*x;
-    if(x<pos){
-      extract(x,pos);
-      *(pos-1)=n;
-      n->up()=pos-1;
-    }
-    else{
-      while(x!=pos){
-        *x=*(x-1);
-        (*x)->up()=x;
-        --x;
-      }
-      *pos=n;
-      n->up()=pos;
-    }
-  };
-
-  static void relocate(ptr_pointer pos,ptr_pointer first,ptr_pointer last)
-  {
-    ptr_pointer begin,middle,end;
-    if(pos<first){
-      begin=pos;
-      middle=first;
-      end=last;
-    }
-    else{
-      begin=first;
-      middle=last;
-      end=pos;
-    }
-
-    std::ptrdiff_t n=end-begin;
-    std::ptrdiff_t m=middle-begin;
-    std::ptrdiff_t n_m=n-m;
-    std::ptrdiff_t p=integer::gcd(n,m);
-
-    for(std::ptrdiff_t i=0;i<p;++i){
-      pointer tmp=begin[i];
-      for(std::ptrdiff_t j=i,k;;){
-        if(j<n_m)k=j+m;
-        else     k=j-n_m;
-        if(k==i){
-          *(begin+j)=tmp;
-          (*(begin+j))->up()=begin+j;
-          break;
-        }
-        else{
-          *(begin+j)=*(begin+k);
-          (*(begin+j))->up()=begin+j;
-        }
-
-        if(k<n_m)j=k+m;
-        else     j=k-n_m;
-        if(j==i){
-          *(begin+k)=tmp;
-          (*(begin+k))->up()=begin+k;
-          break;
-        }
-        else{
-          *(begin+k)=*(begin+j);
-          (*(begin+k))->up()=begin+k;
-        }
-      }
-    }
-  };
-
-  static void extract(ptr_pointer x,ptr_pointer pend)
-  {
-    --pend;
-    while(x!=pend){
-      *x=*(x+1);
-      (*x)->up()=x;
-      ++x;
-    }
-  }
-
-  static void transfer(
-    ptr_pointer pbegin0,ptr_pointer pend0,ptr_pointer pbegin1)
-  {
-    while(pbegin0!=pend0){
-      *pbegin1=*pbegin0++;
-      (*pbegin1)->up()=pbegin1;
-      ++pbegin1;
-    }
-  }
-
-  static void reverse(ptr_pointer pbegin,ptr_pointer pend)
-  {
-    std::ptrdiff_t d=(pend-pbegin)/2;
-    for(std::ptrdiff_t i=0;i<d;++i){
-      std::swap(*pbegin,*--pend);
-      (*pbegin)->up()=pbegin;
-      (*pend)->up()=pend;
-      ++pbegin;
-    }
-  }
-
-private:
-  ptr_pointer up_;
-};
-
-template<typename Super>
-struct random_access_index_node_trampoline:
-  random_access_index_node_impl<
-    typename boost::detail::allocator::rebind_to<
-      typename Super::allocator_type,
-      char
-    >::type
-  >
-{
-  typedef random_access_index_node_impl<
-    typename boost::detail::allocator::rebind_to<
-      typename Super::allocator_type,
-      char
-    >::type
-  > impl_type;
-};
-
-template<typename Super>
-struct random_access_index_node:
-  Super,random_access_index_node_trampoline<Super>
-{
-private:
-  typedef random_access_index_node_trampoline<Super> trampoline;
-
-public:
-  typedef typename trampoline::impl_type     impl_type;
-  typedef typename trampoline::pointer       impl_pointer;
-  typedef typename trampoline::const_pointer const_impl_pointer;
-  typedef typename trampoline::ptr_pointer   impl_ptr_pointer;
-
-  impl_ptr_pointer& up(){return trampoline::up();}
-  impl_ptr_pointer  up()const{return trampoline::up();}
-
-  impl_pointer impl()
-  {
-    return static_cast<impl_pointer>(
-      static_cast<impl_type*>(static_cast<trampoline*>(this)));
-  }
-
-  const_impl_pointer impl()const
-  {
-    return static_cast<const_impl_pointer>(
-      static_cast<const impl_type*>(static_cast<const trampoline*>(this)));
-  }
-
-  static random_access_index_node* from_impl(impl_pointer x)
-  {
-    return
-      static_cast<random_access_index_node*>(
-        static_cast<trampoline*>(
-          raw_ptr<impl_type*>(x)));
-  }
-
-  static const random_access_index_node* from_impl(const_impl_pointer x)
-  {
-    return
-      static_cast<const random_access_index_node*>(
-        static_cast<const trampoline*>(
-          raw_ptr<const impl_type*>(x)));
-  }
-
-  /* interoperability with rnd_node_iterator */
-
-  static void increment(random_access_index_node*& x)
-  {
-    impl_pointer xi=x->impl();
-    trampoline::increment(xi);
-    x=from_impl(xi);
-  }
-
-  static void decrement(random_access_index_node*& x)
-  {
-    impl_pointer xi=x->impl();
-    trampoline::decrement(xi);
-    x=from_impl(xi);
-  }
-
-  static void advance(random_access_index_node*& x,std::ptrdiff_t n)
-  {
-    impl_pointer xi=x->impl();
-    trampoline::advance(xi,n);
-    x=from_impl(xi);
-  }
-
-  static std::ptrdiff_t distance(
-    random_access_index_node* x,random_access_index_node* y)
-  {
-    return trampoline::distance(x->impl(),y->impl());
-  }
-};
-
-} /* namespace multi_index::detail */
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/rnd_index_ops.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/rnd_index_ops.hpp
deleted file mode 100644
index f5e76e4441f..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/rnd_index_ops.hpp
+++ /dev/null
@@ -1,203 +0,0 @@
-/* Copyright 2003-2015 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_DETAIL_RND_INDEX_OPS_HPP
-#define BOOST_MULTI_INDEX_DETAIL_RND_INDEX_OPS_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <algorithm>
-#include <boost/multi_index/detail/rnd_index_ptr_array.hpp>
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-/* Common code for random_access_index memfuns having templatized and
- * non-templatized versions.
- */
-
-template<typename Node,typename Allocator,typename Predicate>
-Node* random_access_index_remove(
-  random_access_index_ptr_array<Allocator>& ptrs,Predicate pred)
-{
-  typedef typename Node::value_type value_type;
-  typedef typename Node::impl_ptr_pointer impl_ptr_pointer;
-
-  impl_ptr_pointer first=ptrs.begin(),
-                   res=first,
-                   last=ptrs.end();
-  for(;first!=last;++first){
-    if(!pred(
-        const_cast<const value_type&>(Node::from_impl(*first)->value()))){
-      if(first!=res){
-        std::swap(*first,*res);
-        (*first)->up()=first;
-        (*res)->up()=res;
-      }
-      ++res;
-    }
-  }
-  return Node::from_impl(*res);
-}
-
-template<typename Node,typename Allocator,class BinaryPredicate>
-Node* random_access_index_unique(
-  random_access_index_ptr_array<Allocator>& ptrs,BinaryPredicate binary_pred)
-{
-  typedef typename Node::value_type       value_type;
-  typedef typename Node::impl_ptr_pointer impl_ptr_pointer;
-
-  impl_ptr_pointer first=ptrs.begin(),
-                   res=first,
-                   last=ptrs.end();
-  if(first!=last){
-    for(;++first!=last;){
-      if(!binary_pred(
-           const_cast<const value_type&>(Node::from_impl(*res)->value()),
-           const_cast<const value_type&>(Node::from_impl(*first)->value()))){
-        ++res;
-        if(first!=res){
-          std::swap(*first,*res);
-          (*first)->up()=first;
-          (*res)->up()=res;
-        }
-      }
-    }
-    ++res;
-  }
-  return Node::from_impl(*res);
-}
-
-template<typename Node,typename Allocator,typename Compare>
-void random_access_index_inplace_merge(
-  const Allocator& al,
-  random_access_index_ptr_array<Allocator>& ptrs,
-  BOOST_DEDUCED_TYPENAME Node::impl_ptr_pointer first1,Compare comp)
-{
-  typedef typename Node::value_type       value_type;
-  typedef typename Node::impl_pointer     impl_pointer;
-  typedef typename Node::impl_ptr_pointer impl_ptr_pointer;
-
-  auto_space<impl_pointer,Allocator> spc(al,ptrs.size());
-
-  impl_ptr_pointer first0=ptrs.begin(),
-                   last0=first1,
-                   last1=ptrs.end(),
-                   out=spc.data();
-  while(first0!=last0&&first1!=last1){
-    if(comp(
-        const_cast<const value_type&>(Node::from_impl(*first1)->value()),
-        const_cast<const value_type&>(Node::from_impl(*first0)->value()))){
-      *out++=*first1++;
-    }
-    else{
-      *out++=*first0++;
-    }
-  }
-  std::copy(&*first0,&*last0,&*out);
-  std::copy(&*first1,&*last1,&*out);
-
-  first1=ptrs.begin();
-  out=spc.data();
-  while(first1!=last1){
-    *first1=*out++;
-    (*first1)->up()=first1;
-    ++first1;
-  }
-}
-
-/* sorting */
-
-/* auxiliary stuff */
-
-template<typename Node,typename Compare>
-struct random_access_index_sort_compare
-{
-  typedef typename Node::impl_pointer first_argument_type;
-  typedef typename Node::impl_pointer second_argument_type;
-  typedef bool                        result_type;
-
-  random_access_index_sort_compare(Compare comp_=Compare()):comp(comp_){}
-
-  bool operator()(
-    typename Node::impl_pointer x,typename Node::impl_pointer y)const
-  {
-    typedef typename Node::value_type value_type;
-
-    return comp(
-      const_cast<const value_type&>(Node::from_impl(x)->value()),
-      const_cast<const value_type&>(Node::from_impl(y)->value()));
-  }
-
-private:
-  Compare comp;
-};
-
-template<typename Node,typename Allocator,class Compare>
-void random_access_index_sort(
-  const Allocator& al,
-  random_access_index_ptr_array<Allocator>& ptrs,
-  Compare comp)
-{
-  /* The implementation is extremely simple: an auxiliary
-   * array of pointers is sorted using stdlib facilities and
-   * then used to rearrange the index. This is suboptimal
-   * in space and time, but has some advantages over other
-   * possible approaches:
-   *   - Use std::stable_sort() directly on ptrs using some
-   *     special iterator in charge of maintaining pointers
-   *     and up() pointers in sync: we cannot guarantee
-   *     preservation of the container invariants in the face of
-   *     exceptions, if, for instance, std::stable_sort throws
-   *     when ptrs transitorily contains duplicate elements.
-   *   - Rewrite the internal algorithms of std::stable_sort
-   *     adapted for this case: besides being a fair amount of
-   *     work, making a stable sort compatible with Boost.MultiIndex
-   *     invariants (basically, no duplicates or missing elements
-   *     even if an exception is thrown) is complicated, error-prone
-   *     and possibly won't perform much better than the
-   *     solution adopted.
-   */
-
-  if(ptrs.size()<=1)return;
-
-  typedef typename Node::impl_pointer       impl_pointer;
-  typedef typename Node::impl_ptr_pointer   impl_ptr_pointer;
-  typedef random_access_index_sort_compare<
-    Node,Compare>                           ptr_compare;
-  
-  impl_ptr_pointer   first=ptrs.begin();
-  impl_ptr_pointer   last=ptrs.end();
-  auto_space<
-    impl_pointer,
-    Allocator>       spc(al,ptrs.size());
-  impl_ptr_pointer   buf=spc.data();
-
-  std::copy(&*first,&*last,&*buf);
-  std::stable_sort(&*buf,&*buf+ptrs.size(),ptr_compare(comp));
-
-  while(first!=last){
-    *first=*buf++;
-    (*first)->up()=first;
-    ++first;
-  }
-}
-
-} /* namespace multi_index::detail */
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/rnd_index_ptr_array.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/rnd_index_ptr_array.hpp
deleted file mode 100644
index bae1c851b8e..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/rnd_index_ptr_array.hpp
+++ /dev/null
@@ -1,144 +0,0 @@
-/* Copyright 2003-2013 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_DETAIL_RND_INDEX_PTR_ARRAY_HPP
-#define BOOST_MULTI_INDEX_DETAIL_RND_INDEX_PTR_ARRAY_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <algorithm>
-#include <boost/detail/allocator_utilities.hpp>
-#include <boost/multi_index/detail/auto_space.hpp>
-#include <boost/multi_index/detail/rnd_index_node.hpp>
-#include <boost/noncopyable.hpp>
-#include <cstddef>
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-/* pointer structure for use by random access indices */
-
-template<typename Allocator>
-class random_access_index_ptr_array:private noncopyable
-{
-  typedef random_access_index_node_impl<
-    typename boost::detail::allocator::rebind_to<
-      Allocator,
-      char
-    >::type
-  >                                                     node_impl_type;
-
-public:
-  typedef typename node_impl_type::pointer              value_type;
-  typedef typename boost::detail::allocator::rebind_to<
-    Allocator,value_type
-  >::type::pointer                                      pointer;
-
-  random_access_index_ptr_array(
-    const Allocator& al,value_type end_,std::size_t sz):
-    size_(sz),
-    capacity_(sz),
-    spc(al,capacity_+1)
-  {
-    *end()=end_;
-    end_->up()=end();
-  }
-
-  std::size_t size()const{return size_;}
-  std::size_t capacity()const{return capacity_;}
-
-  void room_for_one()
-  {
-    if(size_==capacity_){
-      reserve(capacity_<=10?15:capacity_+capacity_/2);
-    }
-  }
-
-  void reserve(std::size_t c)
-  {
-    if(c>capacity_)set_capacity(c);
-  }
-
-  void shrink_to_fit()
-  {
-    if(capacity_>size_)set_capacity(size_);
-  }
-
-  pointer begin()const{return ptrs();}
-  pointer end()const{return ptrs()+size_;}
-  pointer at(std::size_t n)const{return ptrs()+n;}
-
-  void push_back(value_type x)
-  {
-    *(end()+1)=*end();
-    (*(end()+1))->up()=end()+1;
-    *end()=x;
-    (*end())->up()=end();
-    ++size_;
-  }
-
-  void erase(value_type x)
-  {
-    node_impl_type::extract(x->up(),end()+1);
-    --size_;
-  }
-
-  void clear()
-  {
-    *begin()=*end();
-    (*begin())->up()=begin();
-    size_=0;
-  }
-
-  void swap(random_access_index_ptr_array& x)
-  {
-    std::swap(size_,x.size_);
-    std::swap(capacity_,x.capacity_);
-    spc.swap(x.spc);
-  }
-
-private:
-  std::size_t                      size_;
-  std::size_t                      capacity_;
-  auto_space<value_type,Allocator> spc;
-
-  pointer ptrs()const
-  {
-    return spc.data();
-  }
-
-  void set_capacity(std::size_t c)
-  {
-    auto_space<value_type,Allocator> spc1(spc.get_allocator(),c+1);
-    node_impl_type::transfer(begin(),end()+1,spc1.data());
-    spc.swap(spc1);
-    capacity_=c;
-  }
-};
-
-template<typename Allocator>
-void swap(
-  random_access_index_ptr_array<Allocator>& x,
-  random_access_index_ptr_array<Allocator>& y)
-{
-  x.swap(y);
-}
-
-} /* namespace multi_index::detail */
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/rnd_node_iterator.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/rnd_node_iterator.hpp
deleted file mode 100644
index 48026132fb7..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/rnd_node_iterator.hpp
+++ /dev/null
@@ -1,140 +0,0 @@
-/* Copyright 2003-2014 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_DETAIL_RND_NODE_ITERATOR_HPP
-#define BOOST_MULTI_INDEX_DETAIL_RND_NODE_ITERATOR_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <boost/operators.hpp>
-
-#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
-#include <boost/serialization/nvp.hpp>
-#include <boost/serialization/split_member.hpp>
-#endif
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-/* Iterator class for node-based indices with random access iterators. */
-
-template<typename Node>
-class rnd_node_iterator:
-  public random_access_iterator_helper<
-    rnd_node_iterator<Node>,
-    typename Node::value_type,
-    std::ptrdiff_t,
-    const typename Node::value_type*,
-    const typename Node::value_type&>
-{
-public:
-  /* coverity[uninit_ctor]: suppress warning */
-  rnd_node_iterator(){}
-  explicit rnd_node_iterator(Node* node_):node(node_){}
-
-  const typename Node::value_type& operator*()const
-  {
-    return node->value();
-  }
-
-  rnd_node_iterator& operator++()
-  {
-    Node::increment(node);
-    return *this;
-  }
-
-  rnd_node_iterator& operator--()
-  {
-    Node::decrement(node);
-    return *this;
-  }
-
-  rnd_node_iterator& operator+=(std::ptrdiff_t n)
-  {
-    Node::advance(node,n);
-    return *this;
-  }
-
-  rnd_node_iterator& operator-=(std::ptrdiff_t n)
-  {
-    Node::advance(node,-n);
-    return *this;
-  }
-
-#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
-  /* Serialization. As for why the following is public,
-   * see explanation in safe_mode_iterator notes in safe_mode.hpp.
-   */
-
-  BOOST_SERIALIZATION_SPLIT_MEMBER()
-
-  typedef typename Node::base_type node_base_type;
-
-  template<class Archive>
-  void save(Archive& ar,const unsigned int)const
-  {
-    node_base_type* bnode=node;
-    ar<<serialization::make_nvp("pointer",bnode);
-  }
-
-  template<class Archive>
-  void load(Archive& ar,const unsigned int)
-  {
-    node_base_type* bnode;
-    ar>>serialization::make_nvp("pointer",bnode);
-    node=static_cast<Node*>(bnode);
-  }
-#endif
-
-  /* get_node is not to be used by the user */
-
-  typedef Node node_type;
-
-  Node* get_node()const{return node;}
-
-private:
-  Node* node;
-};
-
-template<typename Node>
-bool operator==(
-  const rnd_node_iterator<Node>& x,
-  const rnd_node_iterator<Node>& y)
-{
-  return x.get_node()==y.get_node();
-}
-
-template<typename Node>
-bool operator<(
-  const rnd_node_iterator<Node>& x,
-  const rnd_node_iterator<Node>& y)
-{
-  return Node::distance(x.get_node(),y.get_node())>0;
-}
-
-template<typename Node>
-std::ptrdiff_t operator-(
-  const rnd_node_iterator<Node>& x,
-  const rnd_node_iterator<Node>& y)
-{
-  return Node::distance(y.get_node(),x.get_node());
-}
-
-} /* namespace multi_index::detail */
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/rnk_index_ops.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/rnk_index_ops.hpp
deleted file mode 100644
index fb233cf4973..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/rnk_index_ops.hpp
+++ /dev/null
@@ -1,300 +0,0 @@
-/* Copyright 2003-2017 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_DETAIL_RNK_INDEX_OPS_HPP
-#define BOOST_MULTI_INDEX_DETAIL_RNK_INDEX_OPS_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <boost/mpl/and.hpp>
-#include <boost/multi_index/detail/promotes_arg.hpp>
-#include <cstddef>
-#include <utility>
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-/* Common code for ranked_index memfuns having templatized and
- * non-templatized versions.
- */
-
-template<typename Pointer>
-inline std::size_t ranked_node_size(Pointer x)
-{
-  return x!=Pointer(0)?x->size:0;
-}
-
-template<typename Pointer>
-inline Pointer ranked_index_nth(std::size_t n,Pointer end_)
-{
-  Pointer top=end_->parent();
-  if(top==Pointer(0)||n>=top->size)return end_;
-
-  for(;;){
-    std::size_t s=ranked_node_size(top->left());
-    if(n==s)return top;
-    if(n<s)top=top->left();
-    else{
-      top=top->right();
-      n-=s+1;
-    }
-  }
-}
-
-template<typename Pointer>
-inline std::size_t ranked_index_rank(Pointer x,Pointer end_)
-{
-  Pointer top=end_->parent();
-  if(top==Pointer(0))return 0;
-  if(x==end_)return top->size;
-
-  std::size_t s=ranked_node_size(x->left());
-  while(x!=top){
-    Pointer z=x->parent();
-    if(x==z->right()){
-      s+=ranked_node_size(z->left())+1;
-    }
-    x=z;
-  }
-  return s;
-}
-
-template<
-  typename Node,typename KeyFromValue,
-  typename CompatibleKey,typename CompatibleCompare
->
-inline std::size_t ranked_index_find_rank(
-  Node* top,Node* y,const KeyFromValue& key,const CompatibleKey& x,
-  const CompatibleCompare& comp)
-{
-  typedef typename KeyFromValue::result_type key_type;
-
-  return ranked_index_find_rank(
-    top,y,key,x,comp,
-    mpl::and_<
-      promotes_1st_arg<CompatibleCompare,CompatibleKey,key_type>,
-      promotes_2nd_arg<CompatibleCompare,key_type,CompatibleKey> >());
-}
-
-template<
-  typename Node,typename KeyFromValue,
-  typename CompatibleCompare
->
-inline std::size_t ranked_index_find_rank(
-  Node* top,Node* y,const KeyFromValue& key,
-  const BOOST_DEDUCED_TYPENAME KeyFromValue::result_type& x,
-  const CompatibleCompare& comp,mpl::true_)
-{
-  return ranked_index_find_rank(top,y,key,x,comp,mpl::false_());
-}
-
-template<
-  typename Node,typename KeyFromValue,
-  typename CompatibleKey,typename CompatibleCompare
->
-inline std::size_t ranked_index_find_rank(
-  Node* top,Node* y,const KeyFromValue& key,const CompatibleKey& x,
-  const CompatibleCompare& comp,mpl::false_)
-{
-  if(!top)return 0;
-
-  std::size_t s=top->impl()->size,
-              s0=s;
-  Node*       y0=y;
-
-  do{
-    if(!comp(key(top->value()),x)){
-      y=top;
-      s-=ranked_node_size(y->right())+1;
-      top=Node::from_impl(top->left());
-    }
-    else top=Node::from_impl(top->right());
-  }while(top);
-    
-  return (y==y0||comp(x,key(y->value())))?s0:s;
-}
-
-template<
-  typename Node,typename KeyFromValue,
-  typename CompatibleKey,typename CompatibleCompare
->
-inline std::size_t ranked_index_lower_bound_rank(
-  Node* top,Node* y,const KeyFromValue& key,const CompatibleKey& x,
-  const CompatibleCompare& comp)
-{
-  typedef typename KeyFromValue::result_type key_type;
-
-  return ranked_index_lower_bound_rank(
-    top,y,key,x,comp,
-    promotes_2nd_arg<CompatibleCompare,key_type,CompatibleKey>());
-}
-
-template<
-  typename Node,typename KeyFromValue,
-  typename CompatibleCompare
->
-inline std::size_t ranked_index_lower_bound_rank(
-  Node* top,Node* y,const KeyFromValue& key,
-  const BOOST_DEDUCED_TYPENAME KeyFromValue::result_type& x,
-  const CompatibleCompare& comp,mpl::true_)
-{
-  return ranked_index_lower_bound_rank(top,y,key,x,comp,mpl::false_());
-}
-
-template<
-  typename Node,typename KeyFromValue,
-  typename CompatibleKey,typename CompatibleCompare
->
-inline std::size_t ranked_index_lower_bound_rank(
-  Node* top,Node* y,const KeyFromValue& key,const CompatibleKey& x,
-  const CompatibleCompare& comp,mpl::false_)
-{
-  if(!top)return 0;
-
-  std::size_t s=top->impl()->size;
-
-  do{
-    if(!comp(key(top->value()),x)){
-      y=top;
-      s-=ranked_node_size(y->right())+1;
-      top=Node::from_impl(top->left());
-    }
-    else top=Node::from_impl(top->right());
-  }while(top);
-
-  return s;
-}
-
-template<
-  typename Node,typename KeyFromValue,
-  typename CompatibleKey,typename CompatibleCompare
->
-inline std::size_t ranked_index_upper_bound_rank(
-  Node* top,Node* y,const KeyFromValue& key,const CompatibleKey& x,
-  const CompatibleCompare& comp)
-{
-  typedef typename KeyFromValue::result_type key_type;
-
-  return ranked_index_upper_bound_rank(
-    top,y,key,x,comp,
-    promotes_1st_arg<CompatibleCompare,CompatibleKey,key_type>());
-}
-
-template<
-  typename Node,typename KeyFromValue,
-  typename CompatibleCompare
->
-inline std::size_t ranked_index_upper_bound_rank(
-  Node* top,Node* y,const KeyFromValue& key,
-  const BOOST_DEDUCED_TYPENAME KeyFromValue::result_type& x,
-  const CompatibleCompare& comp,mpl::true_)
-{
-  return ranked_index_upper_bound_rank(top,y,key,x,comp,mpl::false_());
-}
-
-template<
-  typename Node,typename KeyFromValue,
-  typename CompatibleKey,typename CompatibleCompare
->
-inline std::size_t ranked_index_upper_bound_rank(
-  Node* top,Node* y,const KeyFromValue& key,const CompatibleKey& x,
-  const CompatibleCompare& comp,mpl::false_)
-{
-  if(!top)return 0;
-
-  std::size_t s=top->impl()->size;
-
-  do{
-    if(comp(x,key(top->value()))){
-      y=top;
-      s-=ranked_node_size(y->right())+1;
-      top=Node::from_impl(top->left());
-    }
-    else top=Node::from_impl(top->right());
-  }while(top);
-
-  return s;
-}
-
-template<
-  typename Node,typename KeyFromValue,
-  typename CompatibleKey,typename CompatibleCompare
->
-inline std::pair<std::size_t,std::size_t> ranked_index_equal_range_rank(
-  Node* top,Node* y,const KeyFromValue& key,const CompatibleKey& x,
-  const CompatibleCompare& comp)
-{
-  typedef typename KeyFromValue::result_type key_type;
-
-  return ranked_index_equal_range_rank(
-    top,y,key,x,comp,
-    mpl::and_<
-      promotes_1st_arg<CompatibleCompare,CompatibleKey,key_type>,
-      promotes_2nd_arg<CompatibleCompare,key_type,CompatibleKey> >());
-}
-
-template<
-  typename Node,typename KeyFromValue,
-  typename CompatibleCompare
->
-inline std::pair<std::size_t,std::size_t> ranked_index_equal_range_rank(
-  Node* top,Node* y,const KeyFromValue& key,
-  const BOOST_DEDUCED_TYPENAME KeyFromValue::result_type& x,
-  const CompatibleCompare& comp,mpl::true_)
-{
-  return ranked_index_equal_range_rank(top,y,key,x,comp,mpl::false_());
-}
-
-template<
-  typename Node,typename KeyFromValue,
-  typename CompatibleKey,typename CompatibleCompare
->
-inline std::pair<std::size_t,std::size_t> ranked_index_equal_range_rank(
-  Node* top,Node* y,const KeyFromValue& key,const CompatibleKey& x,
-  const CompatibleCompare& comp,mpl::false_)
-{
-  if(!top)return std::pair<std::size_t,std::size_t>(0,0);
-
-  std::size_t s=top->impl()->size;
-
-  do{
-    if(comp(key(top->value()),x)){
-      top=Node::from_impl(top->right());
-    }
-    else if(comp(x,key(top->value()))){
-      y=top;
-      s-=ranked_node_size(y->right())+1;
-      top=Node::from_impl(top->left());
-    }
-    else{
-      return std::pair<std::size_t,std::size_t>(
-        s-top->impl()->size+
-          ranked_index_lower_bound_rank(
-           Node::from_impl(top->left()),top,key,x,comp,mpl::false_()),
-        s-ranked_node_size(top->right())+
-          ranked_index_upper_bound_rank(
-            Node::from_impl(top->right()),y,key,x,comp,mpl::false_()));
-    }
-  }while(top);
-
-  return std::pair<std::size_t,std::size_t>(s,s);
-}
-
-} /* namespace multi_index::detail */
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/safe_mode.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/safe_mode.hpp
deleted file mode 100644
index 905270e9fb3..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/safe_mode.hpp
+++ /dev/null
@@ -1,588 +0,0 @@
-/* Copyright 2003-2013 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_DETAIL_SAFE_MODE_HPP
-#define BOOST_MULTI_INDEX_DETAIL_SAFE_MODE_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-/* Safe mode machinery, in the spirit of Cay Hortmann's "Safe STL"
- * (http://www.horstmann.com/safestl.html).
- * In this mode, containers of type Container are derived from
- * safe_container<Container>, and their corresponding iterators
- * are wrapped with safe_iterator. These classes provide
- * an internal record of which iterators are at a given moment associated
- * to a given container, and properly mark the iterators as invalid
- * when the container gets destroyed.
- * Iterators are chained in a single attached list, whose header is
- * kept by the container. More elaborate data structures would yield better
- * performance, but I decided to keep complexity to a minimum since
- * speed is not an issue here.
- * Safe mode iterators automatically check that only proper operations
- * are performed on them: for instance, an invalid iterator cannot be
- * dereferenced. Additionally, a set of utilty macros and functions are
- * provided that serve to implement preconditions and cooperate with
- * the framework within the container.
- * Iterators can also be unchecked, i.e. they do not have info about
- * which container they belong in. This situation arises when the iterator
- * is restored from a serialization archive: only information on the node
- * is available, and it is not possible to determine to which container
- * the iterator is associated to. The only sensible policy is to assume
- * unchecked iterators are valid, though this can certainly generate false
- * positive safe mode checks.
- * This is not a full-fledged safe mode framework, and is only intended
- * for use within the limits of Boost.MultiIndex.
- */
-
-/* Assertion macros. These resolve to no-ops if
- * !defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE).
- */
-
-#if !defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-#undef BOOST_MULTI_INDEX_SAFE_MODE_ASSERT
-#define BOOST_MULTI_INDEX_SAFE_MODE_ASSERT(expr,error_code) ((void)0)
-#else
-#if !defined(BOOST_MULTI_INDEX_SAFE_MODE_ASSERT)
-#include <boost/assert.hpp>
-#define BOOST_MULTI_INDEX_SAFE_MODE_ASSERT(expr,error_code) BOOST_ASSERT(expr)
-#endif
-#endif
-
-#define BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(it)                           \
-  BOOST_MULTI_INDEX_SAFE_MODE_ASSERT(                                        \
-    safe_mode::check_valid_iterator(it),                                     \
-    safe_mode::invalid_iterator);
-
-#define BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(it)                 \
-  BOOST_MULTI_INDEX_SAFE_MODE_ASSERT(                                        \
-    safe_mode::check_dereferenceable_iterator(it),                           \
-    safe_mode::not_dereferenceable_iterator);
-
-#define BOOST_MULTI_INDEX_CHECK_INCREMENTABLE_ITERATOR(it)                   \
-  BOOST_MULTI_INDEX_SAFE_MODE_ASSERT(                                        \
-    safe_mode::check_incrementable_iterator(it),                             \
-    safe_mode::not_incrementable_iterator);
-
-#define BOOST_MULTI_INDEX_CHECK_DECREMENTABLE_ITERATOR(it)                   \
-  BOOST_MULTI_INDEX_SAFE_MODE_ASSERT(                                        \
-    safe_mode::check_decrementable_iterator(it),                             \
-    safe_mode::not_decrementable_iterator);
-
-#define BOOST_MULTI_INDEX_CHECK_IS_OWNER(it,cont)                            \
-  BOOST_MULTI_INDEX_SAFE_MODE_ASSERT(                                        \
-    safe_mode::check_is_owner(it,cont),                                      \
-    safe_mode::not_owner);
-
-#define BOOST_MULTI_INDEX_CHECK_SAME_OWNER(it0,it1)                          \
-  BOOST_MULTI_INDEX_SAFE_MODE_ASSERT(                                        \
-    safe_mode::check_same_owner(it0,it1),                                    \
-    safe_mode::not_same_owner);
-
-#define BOOST_MULTI_INDEX_CHECK_VALID_RANGE(it0,it1)                         \
-  BOOST_MULTI_INDEX_SAFE_MODE_ASSERT(                                        \
-    safe_mode::check_valid_range(it0,it1),                                   \
-    safe_mode::invalid_range);
-
-#define BOOST_MULTI_INDEX_CHECK_OUTSIDE_RANGE(it,it0,it1)                    \
-  BOOST_MULTI_INDEX_SAFE_MODE_ASSERT(                                        \
-    safe_mode::check_outside_range(it,it0,it1),                              \
-    safe_mode::inside_range);
-
-#define BOOST_MULTI_INDEX_CHECK_IN_BOUNDS(it,n)                              \
-  BOOST_MULTI_INDEX_SAFE_MODE_ASSERT(                                        \
-    safe_mode::check_in_bounds(it,n),                                        \
-    safe_mode::out_of_bounds);
-
-#define BOOST_MULTI_INDEX_CHECK_DIFFERENT_CONTAINER(cont0,cont1)             \
-  BOOST_MULTI_INDEX_SAFE_MODE_ASSERT(                                        \
-    safe_mode::check_different_container(cont0,cont1),                       \
-    safe_mode::same_container);
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <algorithm>
-#include <boost/detail/iterator.hpp>
-#include <boost/multi_index/detail/access_specifier.hpp>
-#include <boost/multi_index/detail/iter_adaptor.hpp>
-#include <boost/multi_index/safe_mode_errors.hpp>
-#include <boost/noncopyable.hpp>
-
-#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
-#include <boost/serialization/split_member.hpp>
-#include <boost/serialization/version.hpp>
-#endif
-
-#if defined(BOOST_HAS_THREADS)
-#include <boost/detail/lightweight_mutex.hpp>
-#endif
-
-namespace boost{
-
-namespace multi_index{
-
-namespace safe_mode{
-
-/* Checking routines. Assume the best for unchecked iterators
- * (i.e. they pass the checking when there is not enough info
- * to know.)
- */
-
-template<typename Iterator>
-inline bool check_valid_iterator(const Iterator& it)
-{
-  return it.valid()||it.unchecked();
-}
-
-template<typename Iterator>
-inline bool check_dereferenceable_iterator(const Iterator& it)
-{
-  return (it.valid()&&it!=it.owner()->end())||it.unchecked();
-}
-
-template<typename Iterator>
-inline bool check_incrementable_iterator(const Iterator& it)
-{
-  return (it.valid()&&it!=it.owner()->end())||it.unchecked();
-}
-
-template<typename Iterator>
-inline bool check_decrementable_iterator(const Iterator& it)
-{
-  return (it.valid()&&it!=it.owner()->begin())||it.unchecked();
-}
-
-template<typename Iterator>
-inline bool check_is_owner(
-  const Iterator& it,const typename Iterator::container_type& cont)
-{
-  return (it.valid()&&it.owner()==&cont)||it.unchecked();
-}
-
-template<typename Iterator>
-inline bool check_same_owner(const Iterator& it0,const Iterator& it1)
-{
-  return (it0.valid()&&it1.valid()&&it0.owner()==it1.owner())||
-         it0.unchecked()||it1.unchecked();
-}
-
-template<typename Iterator>
-inline bool check_valid_range(const Iterator& it0,const Iterator& it1)
-{
-  if(!check_same_owner(it0,it1))return false;
-
-  if(it0.valid()){
-    Iterator last=it0.owner()->end();
-    if(it1==last)return true;
-
-    for(Iterator first=it0;first!=last;++first){
-      if(first==it1)return true;
-    }
-    return false;
-  }
-  return true;
-}
-
-template<typename Iterator>
-inline bool check_outside_range(
-  const Iterator& it,const Iterator& it0,const Iterator& it1)
-{
-  if(!check_same_owner(it0,it1))return false;
-
-  if(it0.valid()){
-    Iterator last=it0.owner()->end();
-    bool found=false;
-
-    Iterator first=it0;
-    for(;first!=last;++first){
-      if(first==it1)break;
-    
-      /* crucial that this check goes after previous break */
-    
-      if(first==it)found=true;
-    }
-    if(first!=it1)return false;
-    return !found;
-  }
-  return true;
-}
-
-template<typename Iterator,typename Difference>
-inline bool check_in_bounds(const Iterator& it,Difference n)
-{
-  if(it.unchecked())return true;
-  if(!it.valid())   return false;
-  if(n>0)           return it.owner()->end()-it>=n;
-  else              return it.owner()->begin()-it<=n;
-}
-
-template<typename Container>
-inline bool check_different_container(
-  const Container& cont0,const Container& cont1)
-{
-  return &cont0!=&cont1;
-}
-
-/* Invalidates all iterators equivalent to that given. Safe containers
- * must call this when deleting elements: the safe mode framework cannot
- * perform this operation automatically without outside help.
- */
-
-template<typename Iterator>
-inline void detach_equivalent_iterators(Iterator& it)
-{
-  if(it.valid()){
-    {
-#if defined(BOOST_HAS_THREADS)
-      boost::detail::lightweight_mutex::scoped_lock lock(it.cont->mutex);
-#endif
-
-      Iterator *prev_,*next_;
-      for(
-        prev_=static_cast<Iterator*>(&it.cont->header);
-        (next_=static_cast<Iterator*>(prev_->next))!=0;){
-        if(next_!=&it&&*next_==it){
-          prev_->next=next_->next;
-          next_->cont=0;
-        }
-        else prev_=next_;
-      }
-    }
-    it.detach();
-  }
-}
-
-template<typename Container> class safe_container; /* fwd decl. */
-
-} /* namespace multi_index::safe_mode */
-
-namespace detail{
-
-class safe_container_base;                 /* fwd decl. */
-
-class safe_iterator_base
-{
-public:
-  bool valid()const{return cont!=0;}
-  bool unchecked()const{return unchecked_;}
-
-  inline void detach();
-
-  void uncheck()
-  {
-    detach();
-    unchecked_=true;
-  }
-
-protected:
-  safe_iterator_base():cont(0),next(0),unchecked_(false){}
-
-  explicit safe_iterator_base(safe_container_base* cont_):
-    unchecked_(false)
-  {
-    attach(cont_);
-  }
-
-  safe_iterator_base(const safe_iterator_base& it):
-    unchecked_(it.unchecked_)
-  {
-    attach(it.cont);
-  }
-
-  safe_iterator_base& operator=(const safe_iterator_base& it)
-  {
-    unchecked_=it.unchecked_;
-    safe_container_base* new_cont=it.cont;
-    if(cont!=new_cont){
-      detach();
-      attach(new_cont);
-    }
-    return *this;
-  }
-
-  ~safe_iterator_base()
-  {
-    detach();
-  }
-
-  const safe_container_base* owner()const{return cont;}
-
-BOOST_MULTI_INDEX_PRIVATE_IF_MEMBER_TEMPLATE_FRIENDS:
-  friend class safe_container_base;
-
-#if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
-  template<typename>          friend class safe_mode::safe_container;
-  template<typename Iterator> friend
-    void safe_mode::detach_equivalent_iterators(Iterator&);
-#endif
-
-  inline void attach(safe_container_base* cont_);
-
-  safe_container_base* cont;
-  safe_iterator_base*  next;
-  bool                 unchecked_;
-};
-
-class safe_container_base:private noncopyable
-{
-public:
-  safe_container_base(){}
-
-BOOST_MULTI_INDEX_PROTECTED_IF_MEMBER_TEMPLATE_FRIENDS:
-  friend class safe_iterator_base;
-
-#if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
-  template<typename Iterator> friend
-    void safe_mode::detach_equivalent_iterators(Iterator&);
-#endif
-
-  ~safe_container_base()
-  {
-    /* Detaches all remaining iterators, which by now will
-     * be those pointing to the end of the container.
-     */
-
-    for(safe_iterator_base* it=header.next;it;it=it->next)it->cont=0;
-    header.next=0;
-  }
-
-  void swap(safe_container_base& x)
-  {
-    for(safe_iterator_base* it0=header.next;it0;it0=it0->next)it0->cont=&x;
-    for(safe_iterator_base* it1=x.header.next;it1;it1=it1->next)it1->cont=this;
-    std::swap(header.cont,x.header.cont);
-    std::swap(header.next,x.header.next);
-  }
-
-  safe_iterator_base header;
-
-#if defined(BOOST_HAS_THREADS)
-  boost::detail::lightweight_mutex mutex;
-#endif
-};
-
-void safe_iterator_base::attach(safe_container_base* cont_)
-{
-  cont=cont_;
-  if(cont){
-#if defined(BOOST_HAS_THREADS)
-    boost::detail::lightweight_mutex::scoped_lock lock(cont->mutex);
-#endif
-
-    next=cont->header.next;
-    cont->header.next=this;
-  }
-}
-
-void safe_iterator_base::detach()
-{
-  if(cont){
-#if defined(BOOST_HAS_THREADS)
-    boost::detail::lightweight_mutex::scoped_lock lock(cont->mutex);
-#endif
-
-    safe_iterator_base *prev_,*next_;
-    for(prev_=&cont->header;(next_=prev_->next)!=this;prev_=next_){}
-    prev_->next=next;
-    cont=0;
-  }
-}
-
-} /* namespace multi_index::detail */
-
-namespace safe_mode{
-
-/* In order to enable safe mode on a container:
- *   - The container must derive from safe_container<container_type>,
- *   - iterators must be generated via safe_iterator, which adapts a
- *     preexistent unsafe iterator class.
- */
- 
-template<typename Container>
-class safe_container;
-
-template<typename Iterator,typename Container>
-class safe_iterator:
-  public detail::iter_adaptor<safe_iterator<Iterator,Container>,Iterator>,
-  public detail::safe_iterator_base
-{
-  typedef detail::iter_adaptor<safe_iterator,Iterator> super;
-  typedef detail::safe_iterator_base                   safe_super;
-
-public:
-  typedef Container                                    container_type;
-  typedef typename Iterator::reference                 reference;
-  typedef typename Iterator::difference_type           difference_type;
-
-  safe_iterator(){}
-  explicit safe_iterator(safe_container<container_type>* cont_):
-    safe_super(cont_){}
-  template<typename T0>
-  safe_iterator(const T0& t0,safe_container<container_type>* cont_):
-    super(Iterator(t0)),safe_super(cont_){}
-  template<typename T0,typename T1>
-  safe_iterator(
-    const T0& t0,const T1& t1,safe_container<container_type>* cont_):
-    super(Iterator(t0,t1)),safe_super(cont_){}
-
-  safe_iterator& operator=(const safe_iterator& x)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(x);
-    this->base_reference()=x.base_reference();
-    safe_super::operator=(x);
-    return *this;
-  }
-
-  const container_type* owner()const
-  {
-    return
-      static_cast<const container_type*>(
-        static_cast<const safe_container<container_type>*>(
-          this->safe_super::owner()));
-  }
-
-  /* get_node is not to be used by the user */
-
-  typedef typename Iterator::node_type node_type;
-
-  node_type* get_node()const{return this->base_reference().get_node();}
-
-private:
-  friend class boost::multi_index::detail::iter_adaptor_access;
-
-  reference dereference()const
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(*this);
-    BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(*this);
-    return *(this->base_reference());
-  }
-
-  bool equal(const safe_iterator& x)const
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(*this);
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(x);
-    BOOST_MULTI_INDEX_CHECK_SAME_OWNER(*this,x);
-    return this->base_reference()==x.base_reference();
-  }
-
-  void increment()
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(*this);
-    BOOST_MULTI_INDEX_CHECK_INCREMENTABLE_ITERATOR(*this);
-    ++(this->base_reference());
-  }
-
-  void decrement()
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(*this);
-    BOOST_MULTI_INDEX_CHECK_DECREMENTABLE_ITERATOR(*this);
-    --(this->base_reference());
-  }
-
-  void advance(difference_type n)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(*this);
-    BOOST_MULTI_INDEX_CHECK_IN_BOUNDS(*this,n);
-    this->base_reference()+=n;
-  }
-
-  difference_type distance_to(const safe_iterator& x)const
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(*this);
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(x);
-    BOOST_MULTI_INDEX_CHECK_SAME_OWNER(*this,x);
-    return x.base_reference()-this->base_reference();
-  }
-
-#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
-  /* Serialization. Note that Iterator::save and Iterator:load
-   * are assumed to be defined and public: at first sight it seems
-   * like we could have resorted to the public serialization interface
-   * for doing the forwarding to the adapted iterator class:
-   *   ar<<base_reference();
-   *   ar>>base_reference();
-   * but this would cause incompatibilities if a saving
-   * program is in safe mode and the loading program is not, or
-   * viceversa --in safe mode, the archived iterator data is one layer
-   * deeper, this is especially relevant with XML archives.
-   * It'd be nice if Boost.Serialization provided some forwarding
-   * facility for use by adaptor classes.
-   */ 
-
-  friend class boost::serialization::access;
-
-  BOOST_SERIALIZATION_SPLIT_MEMBER()
-
-  template<class Archive>
-  void save(Archive& ar,const unsigned int version)const
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(*this);
-    this->base_reference().save(ar,version);
-  }
-
-  template<class Archive>
-  void load(Archive& ar,const unsigned int version)
-  {
-    this->base_reference().load(ar,version);
-    safe_super::uncheck();
-  }
-#endif
-};
-
-template<typename Container>
-class safe_container:public detail::safe_container_base
-{
-  typedef detail::safe_container_base super;
-
-public:
-  void detach_dereferenceable_iterators()
-  {
-    typedef typename Container::iterator iterator;
-
-    iterator end_=static_cast<Container*>(this)->end();
-    iterator *prev_,*next_;
-    for(
-      prev_=static_cast<iterator*>(&this->header);
-      (next_=static_cast<iterator*>(prev_->next))!=0;){
-      if(*next_!=end_){
-        prev_->next=next_->next;
-        next_->cont=0;
-      }
-      else prev_=next_;
-    }
-  }
-
-  void swap(safe_container<Container>& x)
-  {
-    super::swap(x);
-  }
-};
-
-} /* namespace multi_index::safe_mode */
-
-} /* namespace multi_index */
-
-#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
-namespace serialization{
-template<typename Iterator,typename Container>
-struct version<
-  boost::multi_index::safe_mode::safe_iterator<Iterator,Container>
->
-{
-  BOOST_STATIC_CONSTANT(
-    int,value=boost::serialization::version<Iterator>::value);
-};
-} /* namespace serialization */
-#endif
-
-} /* namespace boost */
-
-#endif /* BOOST_MULTI_INDEX_ENABLE_SAFE_MODE */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/scope_guard.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/scope_guard.hpp
deleted file mode 100644
index 116f8f50415..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/scope_guard.hpp
+++ /dev/null
@@ -1,453 +0,0 @@
-/* Copyright 2003-2013 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_DETAIL_SCOPE_GUARD_HPP
-#define BOOST_MULTI_INDEX_DETAIL_SCOPE_GUARD_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/detail/no_exceptions_support.hpp>
-#include <boost/mpl/if.hpp>
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-/* Until some official version of the ScopeGuard idiom makes it into Boost,
- * we locally define our own. This is a merely reformated version of
- * ScopeGuard.h as defined in:
- *   Alexandrescu, A., Marginean, P.:"Generic<Programming>: Change the Way You
- *     Write Exception-Safe Code - Forever", C/C++ Users Jornal, Dec 2000,
- *     http://www.drdobbs.com/184403758
- * with the following modifications:
- *   - General pretty formatting (pretty to my taste at least.)
- *   - Naming style changed to standard C++ library requirements.
- *   - Added scope_guard_impl4 and obj_scope_guard_impl3, (Boost.MultiIndex
- *     needs them). A better design would provide guards for many more
- *     arguments through the Boost Preprocessor Library.
- *   - Added scope_guard_impl_base::touch (see below.)
- *   - Removed RefHolder and ByRef, whose functionality is provided
- *     already by Boost.Ref.
- *   - Removed static make_guard's and make_obj_guard's, so that the code
- *     will work even if BOOST_NO_MEMBER_TEMPLATES is defined. This forces
- *     us to move some private ctors to public, though.
- *
- * NB: CodeWarrior Pro 8 seems to have problems looking up safe_execute
- * without an explicit qualification.
- * 
- * We also define the following variants of the idiom:
- * 
- *   - make_guard_if_c<bool>( ... )
- *   - make_guard_if<IntegralConstant>( ... )
- *   - make_obj_guard_if_c<bool>( ... )
- *   - make_obj_guard_if<IntegralConstant>( ... )
- * which may be used with a compile-time constant to yield
- * a "null_guard" if the boolean compile-time parameter is false,
- * or conversely, the guard is only constructed if the constant is true.
- * This is useful to avoid extra tagging, because the returned
- * null_guard can be optimzed comlpetely away by the compiler.
- */
-
-class scope_guard_impl_base
-{
-public:
-  scope_guard_impl_base():dismissed_(false){}
-  void dismiss()const{dismissed_=true;}
-
-  /* This helps prevent some "unused variable" warnings under, for instance,
-   * GCC 3.2.
-   */
-  void touch()const{}
-
-protected:
-  ~scope_guard_impl_base(){}
-
-  scope_guard_impl_base(const scope_guard_impl_base& other):
-    dismissed_(other.dismissed_)
-  {
-    other.dismiss();
-  }
-
-  template<typename J>
-  static void safe_execute(J& j){
-    BOOST_TRY{
-      if(!j.dismissed_)j.execute();
-    }
-    BOOST_CATCH(...){}
-    BOOST_CATCH_END
-  }
-  
-  mutable bool dismissed_;
-
-private:
-  scope_guard_impl_base& operator=(const scope_guard_impl_base&);
-};
-
-typedef const scope_guard_impl_base& scope_guard;
-
-struct null_guard : public scope_guard_impl_base
-{
-    template< class T1 >
-    null_guard( const T1& )
-    { }
-
-    template< class T1, class T2 >
-    null_guard( const T1&, const T2& )
-    { }
-
-    template< class T1, class T2, class T3 >
-    null_guard( const T1&, const T2&, const T3& )
-    { }
-
-    template< class T1, class T2, class T3, class T4 >
-    null_guard( const T1&, const T2&, const T3&, const T4& )
-    { }
-
-    template< class T1, class T2, class T3, class T4, class T5 >
-    null_guard( const T1&, const T2&, const T3&, const T4&, const T5& )
-    { }
-};
-
-template< bool cond, class T >
-struct null_guard_return
-{
-    typedef typename boost::mpl::if_c<cond,T,null_guard>::type type;
-};
-
-template<typename F>
-class scope_guard_impl0:public scope_guard_impl_base
-{
-public:
-  scope_guard_impl0(F fun):fun_(fun){}
-  ~scope_guard_impl0(){scope_guard_impl_base::safe_execute(*this);}
-  void execute(){fun_();}
-
-protected:
-
-  F fun_;
-};
-
-template<typename F> 
-inline scope_guard_impl0<F> make_guard(F fun)
-{
-  return scope_guard_impl0<F>(fun);
-}
-
-template<bool cond, typename F> 
-inline typename null_guard_return<cond,scope_guard_impl0<F> >::type  
-make_guard_if_c(F fun)
-{
-  return typename null_guard_return<cond,scope_guard_impl0<F> >::type(fun);
-}
-
-template<typename C, typename F> 
-inline typename null_guard_return<C::value,scope_guard_impl0<F> >::type  
-make_guard_if(F fun)
-{
-  return make_guard_if<C::value>(fun);
-}
-
-template<typename F,typename P1>
-class scope_guard_impl1:public scope_guard_impl_base
-{
-public:
-  scope_guard_impl1(F fun,P1 p1):fun_(fun),p1_(p1){}
-  ~scope_guard_impl1(){scope_guard_impl_base::safe_execute(*this);}
-  void execute(){fun_(p1_);}
-
-protected:
-  F        fun_;
-  const P1 p1_;
-};
-
-template<typename F,typename P1> 
-inline scope_guard_impl1<F,P1> make_guard(F fun,P1 p1)
-{
-  return scope_guard_impl1<F,P1>(fun,p1);
-}
-
-template<bool cond, typename F,typename P1> 
-inline typename null_guard_return<cond,scope_guard_impl1<F,P1> >::type 
-make_guard_if_c(F fun,P1 p1)
-{
-  return typename null_guard_return<cond,scope_guard_impl1<F,P1> >::type(fun,p1);
-}
-
-template<typename C, typename F,typename P1> 
-inline typename null_guard_return<C::value,scope_guard_impl1<F,P1> >::type 
-make_guard_if(F fun,P1 p1)
-{
-  return make_guard_if_c<C::value>(fun,p1);
-}
-
-template<typename F,typename P1,typename P2>
-class scope_guard_impl2:public scope_guard_impl_base
-{
-public:
-  scope_guard_impl2(F fun,P1 p1,P2 p2):fun_(fun),p1_(p1),p2_(p2){}
-  ~scope_guard_impl2(){scope_guard_impl_base::safe_execute(*this);}
-  void execute(){fun_(p1_,p2_);}
-
-protected:
-  F        fun_;
-  const P1 p1_;
-  const P2 p2_;
-};
-
-template<typename F,typename P1,typename P2>
-inline scope_guard_impl2<F,P1,P2> make_guard(F fun,P1 p1,P2 p2)
-{
-  return scope_guard_impl2<F,P1,P2>(fun,p1,p2);
-}
-
-template<bool cond, typename F,typename P1,typename P2>
-inline typename null_guard_return<cond,scope_guard_impl2<F,P1,P2> >::type
-make_guard_if_c(F fun,P1 p1,P2 p2)
-{
-  return typename null_guard_return<cond,scope_guard_impl2<F,P1,P2> >::type(fun,p1,p2);
-}
-
-template<typename C, typename F,typename P1,typename P2>
-inline typename null_guard_return<C::value,scope_guard_impl2<F,P1,P2> >::type
-make_guard_if(F fun,P1 p1,P2 p2)
-{
-  return make_guard_if_c<C::value>(fun,p1,p2);
-}
-
-template<typename F,typename P1,typename P2,typename P3>
-class scope_guard_impl3:public scope_guard_impl_base
-{
-public:
-  scope_guard_impl3(F fun,P1 p1,P2 p2,P3 p3):fun_(fun),p1_(p1),p2_(p2),p3_(p3){}
-  ~scope_guard_impl3(){scope_guard_impl_base::safe_execute(*this);}
-  void execute(){fun_(p1_,p2_,p3_);}
-
-protected:
-  F        fun_;
-  const P1 p1_;
-  const P2 p2_;
-  const P3 p3_;
-};
-
-template<typename F,typename P1,typename P2,typename P3>
-inline scope_guard_impl3<F,P1,P2,P3> make_guard(F fun,P1 p1,P2 p2,P3 p3)
-{
-  return scope_guard_impl3<F,P1,P2,P3>(fun,p1,p2,p3);
-}
-
-template<bool cond,typename F,typename P1,typename P2,typename P3>
-inline typename null_guard_return<cond,scope_guard_impl3<F,P1,P2,P3> >::type 
-make_guard_if_c(F fun,P1 p1,P2 p2,P3 p3)
-{
-  return typename null_guard_return<cond,scope_guard_impl3<F,P1,P2,P3> >::type(fun,p1,p2,p3);
-}
-
-template<typename C,typename F,typename P1,typename P2,typename P3>
-inline typename null_guard_return< C::value,scope_guard_impl3<F,P1,P2,P3> >::type 
-make_guard_if(F fun,P1 p1,P2 p2,P3 p3)
-{
-  return make_guard_if_c<C::value>(fun,p1,p2,p3);
-}
-
-template<typename F,typename P1,typename P2,typename P3,typename P4>
-class scope_guard_impl4:public scope_guard_impl_base
-{
-public:
-  scope_guard_impl4(F fun,P1 p1,P2 p2,P3 p3,P4 p4):
-    fun_(fun),p1_(p1),p2_(p2),p3_(p3),p4_(p4){}
-  ~scope_guard_impl4(){scope_guard_impl_base::safe_execute(*this);}
-  void execute(){fun_(p1_,p2_,p3_,p4_);}
-
-protected:
-  F        fun_;
-  const P1 p1_;
-  const P2 p2_;
-  const P3 p3_;
-  const P4 p4_;
-};
-
-template<typename F,typename P1,typename P2,typename P3,typename P4>
-inline scope_guard_impl4<F,P1,P2,P3,P4> make_guard(
-  F fun,P1 p1,P2 p2,P3 p3,P4 p4)
-{
-  return scope_guard_impl4<F,P1,P2,P3,P4>(fun,p1,p2,p3,p4);
-}
-
-template<bool cond, typename F,typename P1,typename P2,typename P3,typename P4>
-inline typename null_guard_return<cond,scope_guard_impl4<F,P1,P2,P3,P4> >::type 
-make_guard_if_c(
-  F fun,P1 p1,P2 p2,P3 p3,P4 p4)
-{
-  return typename null_guard_return<cond,scope_guard_impl4<F,P1,P2,P3,P4> >::type(fun,p1,p2,p3,p4);
-}
-
-template<typename C, typename F,typename P1,typename P2,typename P3,typename P4>
-inline typename null_guard_return<C::value,scope_guard_impl4<F,P1,P2,P3,P4> >::type 
-make_guard_if(
-  F fun,P1 p1,P2 p2,P3 p3,P4 p4)
-{
-  return make_guard_if_c<C::value>(fun,p1,p2,p3,p4);
-}
-
-template<class Obj,typename MemFun>
-class obj_scope_guard_impl0:public scope_guard_impl_base
-{
-public:
-  obj_scope_guard_impl0(Obj& obj,MemFun mem_fun):obj_(obj),mem_fun_(mem_fun){}
-  ~obj_scope_guard_impl0(){scope_guard_impl_base::safe_execute(*this);}
-  void execute(){(obj_.*mem_fun_)();}
-
-protected:
-  Obj&   obj_;
-  MemFun mem_fun_;
-};
-
-template<class Obj,typename MemFun>
-inline obj_scope_guard_impl0<Obj,MemFun> make_obj_guard(Obj& obj,MemFun mem_fun)
-{
-  return obj_scope_guard_impl0<Obj,MemFun>(obj,mem_fun);
-}
-
-template<bool cond, class Obj,typename MemFun>
-inline typename null_guard_return<cond,obj_scope_guard_impl0<Obj,MemFun> >::type 
-make_obj_guard_if_c(Obj& obj,MemFun mem_fun)
-{
-  return typename null_guard_return<cond,obj_scope_guard_impl0<Obj,MemFun> >::type(obj,mem_fun);
-}
-
-template<typename C, class Obj,typename MemFun>
-inline typename null_guard_return<C::value,obj_scope_guard_impl0<Obj,MemFun> >::type 
-make_obj_guard_if(Obj& obj,MemFun mem_fun)
-{
-  return make_obj_guard_if_c<C::value>(obj,mem_fun);
-}
-
-template<class Obj,typename MemFun,typename P1>
-class obj_scope_guard_impl1:public scope_guard_impl_base
-{
-public:
-  obj_scope_guard_impl1(Obj& obj,MemFun mem_fun,P1 p1):
-    obj_(obj),mem_fun_(mem_fun),p1_(p1){}
-  ~obj_scope_guard_impl1(){scope_guard_impl_base::safe_execute(*this);}
-  void execute(){(obj_.*mem_fun_)(p1_);}
-
-protected:
-  Obj&     obj_;
-  MemFun   mem_fun_;
-  const P1 p1_;
-};
-
-template<class Obj,typename MemFun,typename P1>
-inline obj_scope_guard_impl1<Obj,MemFun,P1> make_obj_guard(
-  Obj& obj,MemFun mem_fun,P1 p1)
-{
-  return obj_scope_guard_impl1<Obj,MemFun,P1>(obj,mem_fun,p1);
-}
-
-template<bool cond, class Obj,typename MemFun,typename P1>
-inline typename null_guard_return<cond,obj_scope_guard_impl1<Obj,MemFun,P1> >::type 
-make_obj_guard_if_c(  Obj& obj,MemFun mem_fun,P1 p1)
-{
-  return typename null_guard_return<cond,obj_scope_guard_impl1<Obj,MemFun,P1> >::type(obj,mem_fun,p1);
-}
-
-template<typename C, class Obj,typename MemFun,typename P1>
-inline typename null_guard_return<C::value,obj_scope_guard_impl1<Obj,MemFun,P1> >::type 
-make_obj_guard_if( Obj& obj,MemFun mem_fun,P1 p1)
-{
-  return make_obj_guard_if_c<C::value>(obj,mem_fun,p1);
-}
-
-template<class Obj,typename MemFun,typename P1,typename P2>
-class obj_scope_guard_impl2:public scope_guard_impl_base
-{
-public:
-  obj_scope_guard_impl2(Obj& obj,MemFun mem_fun,P1 p1,P2 p2):
-    obj_(obj),mem_fun_(mem_fun),p1_(p1),p2_(p2)
-  {}
-  ~obj_scope_guard_impl2(){scope_guard_impl_base::safe_execute(*this);}
-  void execute(){(obj_.*mem_fun_)(p1_,p2_);}
-
-protected:
-  Obj&     obj_;
-  MemFun   mem_fun_;
-  const P1 p1_;
-  const P2 p2_;
-};
-
-template<class Obj,typename MemFun,typename P1,typename P2>
-inline obj_scope_guard_impl2<Obj,MemFun,P1,P2>
-make_obj_guard(Obj& obj,MemFun mem_fun,P1 p1,P2 p2)
-{
-  return obj_scope_guard_impl2<Obj,MemFun,P1,P2>(obj,mem_fun,p1,p2);
-}
-
-template<bool cond, class Obj,typename MemFun,typename P1,typename P2>
-inline typename null_guard_return<cond,obj_scope_guard_impl2<Obj,MemFun,P1,P2> >::type
-make_obj_guard_if_c(Obj& obj,MemFun mem_fun,P1 p1,P2 p2)
-{
-  return typename null_guard_return<cond,obj_scope_guard_impl2<Obj,MemFun,P1,P2> >::type(obj,mem_fun,p1,p2);
-}
-
-template<typename C, class Obj,typename MemFun,typename P1,typename P2>
-inline typename null_guard_return<C::value,obj_scope_guard_impl2<Obj,MemFun,P1,P2> >::type
-make_obj_guard_if(Obj& obj,MemFun mem_fun,P1 p1,P2 p2)
-{
-  return make_obj_guard_if_c<C::value>(obj,mem_fun,p1,p2);
-}
-
-template<class Obj,typename MemFun,typename P1,typename P2,typename P3>
-class obj_scope_guard_impl3:public scope_guard_impl_base
-{
-public:
-  obj_scope_guard_impl3(Obj& obj,MemFun mem_fun,P1 p1,P2 p2,P3 p3):
-    obj_(obj),mem_fun_(mem_fun),p1_(p1),p2_(p2),p3_(p3)
-  {}
-  ~obj_scope_guard_impl3(){scope_guard_impl_base::safe_execute(*this);}
-  void execute(){(obj_.*mem_fun_)(p1_,p2_,p3_);}
-
-protected:
-  Obj&     obj_;
-  MemFun   mem_fun_;
-  const P1 p1_;
-  const P2 p2_;
-  const P3 p3_;
-};
-
-template<class Obj,typename MemFun,typename P1,typename P2,typename P3>
-inline obj_scope_guard_impl3<Obj,MemFun,P1,P2,P3>
-make_obj_guard(Obj& obj,MemFun mem_fun,P1 p1,P2 p2,P3 p3)
-{
-  return obj_scope_guard_impl3<Obj,MemFun,P1,P2,P3>(obj,mem_fun,p1,p2,p3);
-}
-
-template<bool cond, class Obj,typename MemFun,typename P1,typename P2,typename P3>
-inline typename null_guard_return<cond,obj_scope_guard_impl3<Obj,MemFun,P1,P2,P3> >::type
-make_obj_guard_if_c(Obj& obj,MemFun mem_fun,P1 p1,P2 p2,P3 p3)
-{
-  return typename null_guard_return<cond,obj_scope_guard_impl3<Obj,MemFun,P1,P2,P3> >::type(obj,mem_fun,p1,p2,p3);
-}
-
-template<typename C, class Obj,typename MemFun,typename P1,typename P2,typename P3>
-inline typename null_guard_return<C::value,obj_scope_guard_impl3<Obj,MemFun,P1,P2,P3> >::type
-make_obj_guard_if(Obj& obj,MemFun mem_fun,P1 p1,P2 p2,P3 p3)
-{
-  return make_obj_guard_if_c<C::value>(obj,mem_fun,p1,p2,p3);
-}
-
-} /* namespace multi_index::detail */
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/seq_index_node.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/seq_index_node.hpp
deleted file mode 100644
index 85b345af938..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/seq_index_node.hpp
+++ /dev/null
@@ -1,217 +0,0 @@
-/* Copyright 2003-2015 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_DETAIL_SEQ_INDEX_NODE_HPP
-#define BOOST_MULTI_INDEX_DETAIL_SEQ_INDEX_NODE_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <algorithm>
-#include <boost/detail/allocator_utilities.hpp>
-#include <boost/multi_index/detail/raw_ptr.hpp>
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-/* doubly-linked node for use by sequenced_index */
-
-template<typename Allocator>
-struct sequenced_index_node_impl
-{
-  typedef typename
-  boost::detail::allocator::rebind_to<
-    Allocator,sequenced_index_node_impl
-  >::type::pointer                      pointer;
-  typedef typename
-  boost::detail::allocator::rebind_to<
-    Allocator,sequenced_index_node_impl
-  >::type::const_pointer                const_pointer;
-
-  pointer& prior(){return prior_;}
-  pointer  prior()const{return prior_;}
-  pointer& next(){return next_;}
-  pointer  next()const{return next_;}
-
-  /* interoperability with bidir_node_iterator */
-
-  static void increment(pointer& x){x=x->next();}
-  static void decrement(pointer& x){x=x->prior();}
-
-  /* algorithmic stuff */
-
-  static void link(pointer x,pointer header)
-  {
-    x->prior()=header->prior();
-    x->next()=header;
-    x->prior()->next()=x->next()->prior()=x;
-  };
-
-  static void unlink(pointer x)
-  {
-    x->prior()->next()=x->next();
-    x->next()->prior()=x->prior();
-  }
-
-  static void relink(pointer position,pointer x)
-  {
-    unlink(x);
-    x->prior()=position->prior();
-    x->next()=position;
-    x->prior()->next()=x->next()->prior()=x;
-  }
-
-  static void relink(pointer position,pointer x,pointer y)
-  {
-    /* position is assumed not to be in [x,y) */
-
-    if(x!=y){
-      pointer z=y->prior();
-      x->prior()->next()=y;
-      y->prior()=x->prior();
-      x->prior()=position->prior();
-      z->next()=position;
-      x->prior()->next()=x;
-      z->next()->prior()=z;
-    }
-  }
-
-  static void reverse(pointer header)
-  {
-    pointer x=header;
-    do{
-      pointer y=x->next();
-      std::swap(x->prior(),x->next());
-      x=y;
-    }while(x!=header);
-  }
-
-  static void swap(pointer x,pointer y)
-  {
-    /* This swap function does not exchange the header nodes,
-     * but rather their pointers. This is *not* used for implementing
-     * sequenced_index::swap.
-     */
-
-    if(x->next()!=x){
-      if(y->next()!=y){
-        std::swap(x->next(),y->next());
-        std::swap(x->prior(),y->prior());
-        x->next()->prior()=x->prior()->next()=x;
-        y->next()->prior()=y->prior()->next()=y;
-      }
-      else{
-        y->next()=x->next();
-        y->prior()=x->prior();
-        x->next()=x->prior()=x;
-        y->next()->prior()=y->prior()->next()=y;
-      }
-    }
-    else if(y->next()!=y){
-      x->next()=y->next();
-      x->prior()=y->prior();
-      y->next()=y->prior()=y;
-      x->next()->prior()=x->prior()->next()=x;
-    }
-  }
-
-private:
-  pointer prior_;
-  pointer next_;
-};
-
-template<typename Super>
-struct sequenced_index_node_trampoline:
-  sequenced_index_node_impl<
-    typename boost::detail::allocator::rebind_to<
-      typename Super::allocator_type,
-      char
-    >::type
-  >
-{
-  typedef sequenced_index_node_impl<
-    typename boost::detail::allocator::rebind_to<
-      typename Super::allocator_type,
-      char
-    >::type
-  > impl_type;
-};
-
-template<typename Super>
-struct sequenced_index_node:Super,sequenced_index_node_trampoline<Super>
-{
-private:
-  typedef sequenced_index_node_trampoline<Super> trampoline;
-
-public:
-  typedef typename trampoline::impl_type         impl_type;
-  typedef typename trampoline::pointer           impl_pointer;
-  typedef typename trampoline::const_pointer     const_impl_pointer;
-
-  impl_pointer& prior(){return trampoline::prior();}
-  impl_pointer  prior()const{return trampoline::prior();}
-  impl_pointer& next(){return trampoline::next();}
-  impl_pointer  next()const{return trampoline::next();}
-
-  impl_pointer impl()
-  {
-    return static_cast<impl_pointer>(
-      static_cast<impl_type*>(static_cast<trampoline*>(this)));
-  }
-
-  const_impl_pointer impl()const
-  {
-    return static_cast<const_impl_pointer>(
-      static_cast<const impl_type*>(static_cast<const trampoline*>(this)));
-  }
-
-  static sequenced_index_node* from_impl(impl_pointer x)
-  {
-    return
-      static_cast<sequenced_index_node*>(
-        static_cast<trampoline*>(
-          raw_ptr<impl_type*>(x)));
-  }
-
-  static const sequenced_index_node* from_impl(const_impl_pointer x)
-  {
-    return
-      static_cast<const sequenced_index_node*>(
-        static_cast<const trampoline*>(
-          raw_ptr<const impl_type*>(x)));
-  }
-
-  /* interoperability with bidir_node_iterator */
-
-  static void increment(sequenced_index_node*& x)
-  {
-    impl_pointer xi=x->impl();
-    trampoline::increment(xi);
-    x=from_impl(xi);
-  }
-
-  static void decrement(sequenced_index_node*& x)
-  {
-    impl_pointer xi=x->impl();
-    trampoline::decrement(xi);
-    x=from_impl(xi);
-  }
-};
-
-} /* namespace multi_index::detail */
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/seq_index_ops.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/seq_index_ops.hpp
deleted file mode 100644
index 142bdd9dd9a..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/seq_index_ops.hpp
+++ /dev/null
@@ -1,203 +0,0 @@
-/* Copyright 2003-2016 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_DETAIL_SEQ_INDEX_OPS_HPP
-#define BOOST_MULTI_INDEX_DETAIL_SEQ_INDEX_OPS_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <boost/detail/no_exceptions_support.hpp>
-#include <boost/multi_index/detail/seq_index_node.hpp>
-#include <boost/limits.hpp>
-#include <boost/type_traits/aligned_storage.hpp>
-#include <boost/type_traits/alignment_of.hpp> 
-#include <cstddef>
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-/* Common code for sequenced_index memfuns having templatized and
- * non-templatized versions.
- */
-
-template <typename SequencedIndex,typename Predicate>
-void sequenced_index_remove(SequencedIndex& x,Predicate pred)
-{
-  typedef typename SequencedIndex::iterator iterator;
-  iterator first=x.begin(),last=x.end();
-  while(first!=last){
-    if(pred(*first))x.erase(first++);
-    else ++first;
-  }
-}
-
-template <typename SequencedIndex,class BinaryPredicate>
-void sequenced_index_unique(SequencedIndex& x,BinaryPredicate binary_pred)
-{
-  typedef typename SequencedIndex::iterator iterator;
-  iterator first=x.begin();
-  iterator last=x.end();
-  if(first!=last){
-    for(iterator middle=first;++middle!=last;middle=first){
-      if(binary_pred(*middle,*first))x.erase(middle);
-      else first=middle;
-    }
-  }
-}
-
-template <typename SequencedIndex,typename Compare>
-void sequenced_index_merge(SequencedIndex& x,SequencedIndex& y,Compare comp)
-{
-  typedef typename SequencedIndex::iterator iterator;
-  if(&x!=&y){
-    iterator first0=x.begin(),last0=x.end();
-    iterator first1=y.begin(),last1=y.end();
-    while(first0!=last0&&first1!=last1){
-      if(comp(*first1,*first0))x.splice(first0,y,first1++);
-      else ++first0;
-    }
-    x.splice(last0,y,first1,last1);
-  }
-}
-
-/* sorting  */
-
-/* auxiliary stuff */
-
-template<typename Node,typename Compare>
-void sequenced_index_collate(
-  BOOST_DEDUCED_TYPENAME Node::impl_type* x,
-  BOOST_DEDUCED_TYPENAME Node::impl_type* y,
-  Compare comp)
-{
-  typedef typename Node::impl_type    impl_type;
-  typedef typename Node::impl_pointer impl_pointer;
-
-  impl_pointer first0=x->next();
-  impl_pointer last0=x;
-  impl_pointer first1=y->next();
-  impl_pointer last1=y;
-  while(first0!=last0&&first1!=last1){
-    if(comp(
-        Node::from_impl(first1)->value(),Node::from_impl(first0)->value())){
-      impl_pointer tmp=first1->next();
-      impl_type::relink(first0,first1);
-      first1=tmp;
-    }
-    else first0=first0->next();
-  }
-  impl_type::relink(last0,first1,last1);
-}
-
-/* Some versions of CGG require a bogus typename in counter_spc
- * inside sequenced_index_sort if the following is defined
- * also inside sequenced_index_sort.
- */
-
-BOOST_STATIC_CONSTANT(
-  std::size_t,
-  sequenced_index_sort_max_fill=
-    (std::size_t)std::numeric_limits<std::size_t>::digits+1);
-
-#include <boost/multi_index/detail/ignore_wstrict_aliasing.hpp>
-
-template<typename Node,typename Compare>
-void sequenced_index_sort(Node* header,Compare comp)
-{
-  /* Musser's mergesort, see http://www.cs.rpi.edu/~musser/gp/List/lists1.html.
-   * The implementation is a little convoluted: in the original code
-   * counter elements and carry are std::lists: here we do not want
-   * to use multi_index instead, so we do things at a lower level, managing
-   * directly the internal node representation.
-   * Incidentally, the implementations I've seen of this algorithm (SGI,
-   * Dinkumware, STLPort) are not exception-safe: this is. Moreover, we do not
-   * use any dynamic storage.
-   */
-
-  if(header->next()==header->impl()||
-     header->next()->next()==header->impl())return;
-
-  typedef typename Node::impl_type      impl_type;
-  typedef typename Node::impl_pointer   impl_pointer;
-
-  typedef typename aligned_storage<
-    sizeof(impl_type),
-    alignment_of<impl_type>::value
-  >::type                               carry_spc_type;
-  carry_spc_type                        carry_spc;
-  impl_type&                            carry=
-    *reinterpret_cast<impl_type*>(&carry_spc);
-  typedef typename aligned_storage<
-    sizeof(
-      impl_type
-        [sequenced_index_sort_max_fill]),
-    alignment_of<
-      impl_type
-        [sequenced_index_sort_max_fill]
-    >::value
-  >::type                               counter_spc_type;
-  counter_spc_type                      counter_spc;
-  impl_type*                            counter=
-    reinterpret_cast<impl_type*>(&counter_spc);
-  std::size_t                           fill=0;
-
-  carry.prior()=carry.next()=static_cast<impl_pointer>(&carry);
-  counter[0].prior()=counter[0].next()=static_cast<impl_pointer>(&counter[0]);
-
-  BOOST_TRY{
-    while(header->next()!=header->impl()){
-      impl_type::relink(carry.next(),header->next());
-      std::size_t i=0;
-      while(i<fill&&counter[i].next()!=static_cast<impl_pointer>(&counter[i])){
-        sequenced_index_collate<Node>(&carry,&counter[i++],comp);
-      }
-      impl_type::swap(
-        static_cast<impl_pointer>(&carry),
-        static_cast<impl_pointer>(&counter[i]));
-      if(i==fill){
-        ++fill;
-        counter[fill].prior()=counter[fill].next()=
-          static_cast<impl_pointer>(&counter[fill]);
-      }
-    }
-
-    for(std::size_t i=1;i<fill;++i){
-      sequenced_index_collate<Node>(&counter[i],&counter[i-1],comp);
-    }
-    impl_type::swap(
-      header->impl(),static_cast<impl_pointer>(&counter[fill-1]));
-  }
-  BOOST_CATCH(...)
-  {
-    impl_type::relink(
-      header->impl(),carry.next(),static_cast<impl_pointer>(&carry));
-    for(std::size_t i=0;i<=fill;++i){
-      impl_type::relink(
-        header->impl(),counter[i].next(),
-        static_cast<impl_pointer>(&counter[i]));
-    }
-    BOOST_RETHROW;
-  }
-  BOOST_CATCH_END
-}
-
-#include <boost/multi_index/detail/restore_wstrict_aliasing.hpp>
-
-} /* namespace multi_index::detail */
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/serialization_version.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/serialization_version.hpp
deleted file mode 100644
index ccd8bb4f791..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/serialization_version.hpp
+++ /dev/null
@@ -1,73 +0,0 @@
-/* Copyright 2003-2013 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_DETAIL_SERIALIZATION_VERSION_HPP
-#define BOOST_MULTI_INDEX_DETAIL_SERIALIZATION_VERSION_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <boost/serialization/split_member.hpp>
-#include <boost/serialization/version.hpp>
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-/* Helper class for storing and retrieving a given type serialization class
- * version while avoiding saving the number multiple times in the same
- * archive.
- * Behavior undefined if template partial specialization is not supported.
- */
-
-template<typename T>
-struct serialization_version
-{
-  serialization_version():
-    value(boost::serialization::version<serialization_version>::value){}
-
-  serialization_version& operator=(unsigned int x){value=x;return *this;};
-
-  operator unsigned int()const{return value;}
-
-private:
-  friend class boost::serialization::access;
-
-  BOOST_SERIALIZATION_SPLIT_MEMBER()
-
-  template<class Archive>
-  void save(Archive&,const unsigned int)const{}
-
-  template<class Archive>
-  void load(Archive&,const unsigned int version)
-  {
-    this->value=version;
-  }
-
-  unsigned int value;
-};
-
-} /* namespace multi_index::detail */
-
-} /* namespace multi_index */
-
-namespace serialization {
-template<typename T>
-struct version<boost::multi_index::detail::serialization_version<T> >
-{
-  BOOST_STATIC_CONSTANT(int,value=version<T>::value);
-};
-} /* namespace serialization */
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/uintptr_type.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/uintptr_type.hpp
deleted file mode 100644
index 9c92d01d4de..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/uintptr_type.hpp
+++ /dev/null
@@ -1,76 +0,0 @@
-/* Copyright 2003-2013 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_DETAIL_UINTPTR_TYPE_HPP
-#define BOOST_MULTI_INDEX_DETAIL_UINTPTR_TYPE_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <boost/mpl/bool.hpp>
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-/* has_uintptr_type is an MPL integral constant determining whether
- * there exists an unsigned integral type with the same size as
- * void *.
- * uintptr_type is such a type if has_uintptr is true, or unsigned int
- * otherwise.
- * Note that uintptr_type is more restrictive than C99 uintptr_t,
- * where an integral type with size greater than that of void *
- * would be conformant.
- */
-
-template<int N>struct uintptr_candidates;
-template<>struct uintptr_candidates<-1>{typedef unsigned int           type;};
-template<>struct uintptr_candidates<0> {typedef unsigned int           type;};
-template<>struct uintptr_candidates<1> {typedef unsigned short         type;};
-template<>struct uintptr_candidates<2> {typedef unsigned long          type;};
-
-#if defined(BOOST_HAS_LONG_LONG)
-template<>struct uintptr_candidates<3> {typedef boost::ulong_long_type type;};
-#else
-template<>struct uintptr_candidates<3> {typedef unsigned int           type;};
-#endif
-
-#if defined(BOOST_HAS_MS_INT64)
-template<>struct uintptr_candidates<4> {typedef unsigned __int64       type;};
-#else
-template<>struct uintptr_candidates<4> {typedef unsigned int           type;};
-#endif
-
-struct uintptr_aux
-{
-  BOOST_STATIC_CONSTANT(int,index=
-    sizeof(void*)==sizeof(uintptr_candidates<0>::type)?0:
-    sizeof(void*)==sizeof(uintptr_candidates<1>::type)?1:
-    sizeof(void*)==sizeof(uintptr_candidates<2>::type)?2:
-    sizeof(void*)==sizeof(uintptr_candidates<3>::type)?3:
-    sizeof(void*)==sizeof(uintptr_candidates<4>::type)?4:-1);
-
-  BOOST_STATIC_CONSTANT(bool,has_uintptr_type=(index>=0));
-
-  typedef uintptr_candidates<index>::type type;
-};
-
-typedef mpl::bool_<uintptr_aux::has_uintptr_type> has_uintptr_type;
-typedef uintptr_aux::type                         uintptr_type;
-
-} /* namespace multi_index::detail */
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/unbounded.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/unbounded.hpp
deleted file mode 100644
index dc09be1770d..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/unbounded.hpp
+++ /dev/null
@@ -1,66 +0,0 @@
-/* Copyright 2003-2013 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_DETAIL_UNBOUNDED_HPP
-#define BOOST_MULTI_INDEX_DETAIL_UNBOUNDED_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <boost/detail/workaround.hpp>
-
-namespace boost{
-
-namespace multi_index{
-
-/* dummy type and variable for use in ordered_index::range() */
-
-/* ODR-abiding technique shown at the example attached to
- * http://lists.boost.org/Archives/boost/2006/07/108355.php
- */
-
-namespace detail{class unbounded_helper;}
-
-detail::unbounded_helper unbounded(detail::unbounded_helper);
-
-namespace detail{
-
-class unbounded_helper
-{
-  unbounded_helper(){}
-  unbounded_helper(const unbounded_helper&){}
-  friend unbounded_helper multi_index::unbounded(unbounded_helper);
-};
-
-typedef unbounded_helper (*unbounded_type)(unbounded_helper);
-
-} /* namespace multi_index::detail */
-
-inline detail::unbounded_helper unbounded(detail::unbounded_helper)
-{
-  return detail::unbounded_helper();
-}
-
-/* tags used in the implementation of range */
-
-namespace detail{
-
-struct none_unbounded_tag{};
-struct lower_unbounded_tag{};
-struct upper_unbounded_tag{};
-struct both_unbounded_tag{};
-
-} /* namespace multi_index::detail */
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/value_compare.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/value_compare.hpp
deleted file mode 100644
index ac42e8779aa..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/value_compare.hpp
+++ /dev/null
@@ -1,56 +0,0 @@
-/* Copyright 2003-2015 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_DETAIL_VALUE_COMPARE_HPP
-#define BOOST_MULTI_INDEX_DETAIL_VALUE_COMPARE_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <boost/call_traits.hpp>
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-template<typename Value,typename KeyFromValue,typename Compare>
-struct value_comparison
-{
-  typedef Value first_argument_type;
-  typedef Value second_argument_type;
-  typedef bool  result_type;
-
-  value_comparison(
-    const KeyFromValue& key_=KeyFromValue(),const Compare& comp_=Compare()):
-    key(key_),comp(comp_)
-  {
-  }
-
-  bool operator()(
-    typename call_traits<Value>::param_type x,
-    typename call_traits<Value>::param_type y)const
-  {
-    return comp(key(x),key(y));
-  }
-
-private:
-  KeyFromValue key;
-  Compare      comp;
-};
-
-} /* namespace multi_index::detail */
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/vartempl_support.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/vartempl_support.hpp
deleted file mode 100644
index 06ff430f4be..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/vartempl_support.hpp
+++ /dev/null
@@ -1,247 +0,0 @@
-/* Copyright 2003-2013 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_DETAIL_VARTEMPL_SUPPORT_HPP
-#define BOOST_MULTI_INDEX_DETAIL_VARTEMPL_SUPPORT_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-/* Utilities for emulation of variadic template functions. Variadic packs are
- * replaced by lists of BOOST_MULTI_INDEX_LIMIT_VARTEMPL_ARGS parameters:
- *
- *   - typename... Args            --> BOOST_MULTI_INDEX_TEMPLATE_PARAM_PACK
- *   - Args&&... args              --> BOOST_MULTI_INDEX_FUNCTION_PARAM_PACK
- *   - std::forward<Args>(args)... --> BOOST_MULTI_INDEX_FORWARD_PARAM_PACK
- *
- * Forwarding emulated with Boost.Move. A template functions foo_imp
- * defined in such way accepts *exactly* BOOST_MULTI_INDEX_LIMIT_VARTEMPL_ARGS
- * arguments: variable number of arguments is emulated by providing a set of
- * overloads foo forwarding to foo_impl with
- * 
- *   BOOST_MULTI_INDEX_OVERLOADS_TO_VARTEMPL
- *   BOOST_MULTI_INDEX_OVERLOADS_TO_VARTEMPL_EXTRA_ARG (initial extra arg)
- *
- * which fill the extra args with boost::multi_index::detail::noarg's.
- * boost::multi_index::detail::vartempl_placement_new works the opposite
- * way: it acceps a full a pointer x to Value and a
- * BOOST_MULTI_INDEX_FUNCTION_PARAM_PACK and forwards to
- * new(x) Value(args) where args is the argument pack after discarding
- * noarg's.
- *
- * Emulation decays to the real thing when the compiler supports variadic
- * templates and move semantics natively.
- */
-
-#include <boost/config.hpp>
-
-#if defined(BOOST_NO_CXX11_RVALUE_REFERENCES)||\
-    defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-
-#include <boost/move/core.hpp>
-#include <boost/move/utility.hpp>
-#include <boost/preprocessor/arithmetic/add.hpp>
-#include <boost/preprocessor/arithmetic/sub.hpp>
-#include <boost/preprocessor/cat.hpp>
-#include <boost/preprocessor/control/if.hpp>
-#include <boost/preprocessor/facilities/empty.hpp>
-#include <boost/preprocessor/facilities/intercept.hpp>
-#include <boost/preprocessor/logical/and.hpp>
-#include <boost/preprocessor/punctuation/comma.hpp>
-#include <boost/preprocessor/punctuation/comma_if.hpp>
-#include <boost/preprocessor/repetition/enum.hpp>
-#include <boost/preprocessor/repetition/enum_params.hpp>
-#include <boost/preprocessor/repetition/repeat_from_to.hpp>
-#include <boost/preprocessor/seq/elem.hpp>
-
-#if !defined(BOOST_MULTI_INDEX_LIMIT_VARTEMPL_ARGS)
-#define BOOST_MULTI_INDEX_LIMIT_VARTEMPL_ARGS 5
-#endif
-
-#define BOOST_MULTI_INDEX_TEMPLATE_PARAM_PACK                        \
-BOOST_PP_ENUM_PARAMS(                                                \
-  BOOST_MULTI_INDEX_LIMIT_VARTEMPL_ARGS,typename T)
-
-#define BOOST_MULTI_INDEX_VARTEMPL_ARG(z,n,_)                        \
-BOOST_FWD_REF(BOOST_PP_CAT(T,n)) BOOST_PP_CAT(t,n)
-
-#define BOOST_MULTI_INDEX_FUNCTION_PARAM_PACK                        \
-BOOST_PP_ENUM(                                                       \
-  BOOST_MULTI_INDEX_LIMIT_VARTEMPL_ARGS,                             \
-  BOOST_MULTI_INDEX_VARTEMPL_ARG,~)
-
-#define BOOST_MULTI_INDEX_VARTEMPL_FORWARD_ARG(z,n,_)                \
-boost::forward<BOOST_PP_CAT(T,n)>(BOOST_PP_CAT(t,n))
-
-#define BOOST_MULTI_INDEX_FORWARD_PARAM_PACK                         \
-BOOST_PP_ENUM(                                                       \
-  BOOST_MULTI_INDEX_LIMIT_VARTEMPL_ARGS,                             \
-  BOOST_MULTI_INDEX_VARTEMPL_FORWARD_ARG,~)
-
-namespace boost{namespace multi_index{namespace detail{
-struct noarg{};
-}}}
-
-/* call vartempl function without args */
-
-#define BOOST_MULTI_INDEX_NULL_PARAM_PACK                            \
-BOOST_PP_ENUM_PARAMS(                                                \
-  BOOST_MULTI_INDEX_LIMIT_VARTEMPL_ARGS,                             \
-  boost::multi_index::detail::noarg() BOOST_PP_INTERCEPT)
-
-#define BOOST_MULTI_INDEX_TEMPLATE_N(n)                              \
-template<BOOST_PP_ENUM_PARAMS(n,typename T)>
-
-#define BOOST_MULTI_INDEX_TEMPLATE_0(n)
-
-#define BOOST_MULTI_INDEX_OVERLOADS_TO_VARTEMPL_AUX(z,n,data)        \
-BOOST_PP_IF(n,                                                       \
-  BOOST_MULTI_INDEX_TEMPLATE_N,                                      \
-  BOOST_MULTI_INDEX_TEMPLATE_0)(n)                                   \
-BOOST_PP_SEQ_ELEM(0,data) /* ret */                                  \
-BOOST_PP_SEQ_ELEM(1,data) /* name_from */ (                          \
-  BOOST_PP_ENUM(n,BOOST_MULTI_INDEX_VARTEMPL_ARG,~))                 \
-{                                                                    \
-  return BOOST_PP_SEQ_ELEM(2,data) /* name_to */ (                   \
-    BOOST_PP_ENUM(n,BOOST_MULTI_INDEX_VARTEMPL_FORWARD_ARG,~)        \
-    BOOST_PP_COMMA_IF(                                               \
-      BOOST_PP_AND(                                                  \
-        n,BOOST_PP_SUB(BOOST_MULTI_INDEX_LIMIT_VARTEMPL_ARGS,n)))    \
-    BOOST_PP_ENUM_PARAMS(                                            \
-      BOOST_PP_SUB(BOOST_MULTI_INDEX_LIMIT_VARTEMPL_ARGS,n),         \
-      boost::multi_index::detail::noarg() BOOST_PP_INTERCEPT)        \
-  );                                                                 \
-}
-
-#define BOOST_MULTI_INDEX_OVERLOADS_TO_VARTEMPL(                     \
-  ret,name_from,name_to)                                             \
-BOOST_PP_REPEAT_FROM_TO(                                             \
-  0,BOOST_PP_ADD(BOOST_MULTI_INDEX_LIMIT_VARTEMPL_ARGS,1),           \
-  BOOST_MULTI_INDEX_OVERLOADS_TO_VARTEMPL_AUX,                       \
-  (ret)(name_from)(name_to))
-
-#define BOOST_MULTI_INDEX_OVERLOADS_TO_VARTEMPL_EXTRA_ARG_AUX(       \
-  z,n,data)                                                          \
-BOOST_PP_IF(n,                                                       \
-  BOOST_MULTI_INDEX_TEMPLATE_N,                                      \
-  BOOST_MULTI_INDEX_TEMPLATE_0)(n)                                   \
-BOOST_PP_SEQ_ELEM(0,data) /* ret */                                  \
-BOOST_PP_SEQ_ELEM(1,data) /* name_from */ (                          \
-  BOOST_PP_SEQ_ELEM(3,data) BOOST_PP_SEQ_ELEM(4,data) /* extra arg */\
-  BOOST_PP_COMMA_IF(n)                                               \
-  BOOST_PP_ENUM(n,BOOST_MULTI_INDEX_VARTEMPL_ARG,~))                 \
-{                                                                    \
-  return BOOST_PP_SEQ_ELEM(2,data) /* name_to */ (                   \
-    BOOST_PP_SEQ_ELEM(4,data) /* extra_arg_name */                   \
-    BOOST_PP_COMMA_IF(n)                                             \
-    BOOST_PP_ENUM(n,BOOST_MULTI_INDEX_VARTEMPL_FORWARD_ARG,~)        \
-    BOOST_PP_COMMA_IF(                                               \
-      BOOST_PP_SUB(BOOST_MULTI_INDEX_LIMIT_VARTEMPL_ARGS,n))         \
-    BOOST_PP_ENUM_PARAMS(                                            \
-      BOOST_PP_SUB(BOOST_MULTI_INDEX_LIMIT_VARTEMPL_ARGS,n),         \
-      boost::multi_index::detail::noarg() BOOST_PP_INTERCEPT)        \
-  );                                                                 \
-}
-
-#define BOOST_MULTI_INDEX_OVERLOADS_TO_VARTEMPL_EXTRA_ARG(           \
-  ret,name_from,name_to,extra_arg_type,extra_arg_name)               \
-BOOST_PP_REPEAT_FROM_TO(                                             \
-  0,BOOST_PP_ADD(BOOST_MULTI_INDEX_LIMIT_VARTEMPL_ARGS,1),           \
-  BOOST_MULTI_INDEX_OVERLOADS_TO_VARTEMPL_EXTRA_ARG_AUX,             \
-  (ret)(name_from)(name_to)(extra_arg_type)(extra_arg_name))
-
-namespace boost{
-  
-namespace multi_index{
-  
-namespace detail{
-
-#define BOOST_MULTI_INDEX_VARTEMPL_TO_PLACEMENT_NEW_AUX(z,n,name)    \
-template<                                                            \
-  typename Value                                                     \
-  BOOST_PP_COMMA_IF(n)                                               \
-  BOOST_PP_ENUM_PARAMS(n,typename T)                                 \
->                                                                    \
-Value* name(                                                         \
-  Value* x                                                           \
-  BOOST_PP_COMMA_IF(n)                                               \
-  BOOST_PP_ENUM(n,BOOST_MULTI_INDEX_VARTEMPL_ARG,~)                  \
-  BOOST_PP_COMMA_IF(                                                 \
-    BOOST_PP_SUB(BOOST_MULTI_INDEX_LIMIT_VARTEMPL_ARGS,n))           \
-  BOOST_PP_ENUM_PARAMS(                                              \
-    BOOST_PP_SUB(BOOST_MULTI_INDEX_LIMIT_VARTEMPL_ARGS,n),           \
-    BOOST_FWD_REF(noarg) BOOST_PP_INTERCEPT))                        \
-{                                                                    \
-  return new(x) Value(                                               \
-    BOOST_PP_ENUM(n,BOOST_MULTI_INDEX_VARTEMPL_FORWARD_ARG,~));      \
-}
-
-#define BOOST_MULTI_INDEX_VARTEMPL_TO_PLACEMENT_NEW(name)            \
-BOOST_PP_REPEAT_FROM_TO(                                             \
-  0,BOOST_PP_ADD(BOOST_MULTI_INDEX_LIMIT_VARTEMPL_ARGS,1),           \
-  BOOST_MULTI_INDEX_VARTEMPL_TO_PLACEMENT_NEW_AUX,                   \
-  name)
-
-BOOST_MULTI_INDEX_VARTEMPL_TO_PLACEMENT_NEW(vartempl_placement_new)
-
-#undef BOOST_MULTI_INDEX_VARTEMPL_TO_PLACEMENT_NEW_AUX
-#undef BOOST_MULTI_INDEX_VARTEMPL_TO_PLACEMENT_NEW
-
-} /* namespace multi_index::detail */
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#else
-
-/* native variadic templates support */
-
-#include <utility>
-
-#define BOOST_MULTI_INDEX_TEMPLATE_PARAM_PACK typename... Args
-#define BOOST_MULTI_INDEX_FUNCTION_PARAM_PACK Args&&... args
-#define BOOST_MULTI_INDEX_FORWARD_PARAM_PACK  std::forward<Args>(args)...
-#define BOOST_MULTI_INDEX_NULL_PARAM_PACK
-
-#define BOOST_MULTI_INDEX_OVERLOADS_TO_VARTEMPL(                     \
-  ret,name_from,name_to)                                             \
-template<typename... Args> ret name_from(Args&&... args)             \
-{                                                                    \
-  return name_to(std::forward<Args>(args)...);                       \
-}
-
-#define BOOST_MULTI_INDEX_OVERLOADS_TO_VARTEMPL_EXTRA_ARG(           \
-  ret,name_from,name_to,extra_arg_type,extra_arg_name)               \
-template<typename... Args> ret name_from(                            \
-  extra_arg_type extra_arg_name,Args&&... args)                      \
-{                                                                    \
-  return name_to(extra_arg_name,std::forward<Args>(args)...);        \
-}
-
-namespace boost{
-  
-namespace multi_index{
-  
-namespace detail{
-
-template<typename Value,typename... Args>
-Value* vartempl_placement_new(Value*x,Args&&... args)
-{
-  return new(x) Value(std::forward<Args>(args)...);
-}
-
-} /* namespace multi_index::detail */
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/global_fun.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/global_fun.hpp
deleted file mode 100644
index 2c13769100c..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/global_fun.hpp
+++ /dev/null
@@ -1,185 +0,0 @@
-/* Copyright 2003-2015 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_GLOBAL_FUN_HPP
-#define BOOST_MULTI_INDEX_GLOBAL_FUN_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <boost/detail/workaround.hpp>
-#include <boost/mpl/if.hpp>
-#include <boost/type_traits/is_const.hpp>
-#include <boost/type_traits/is_reference.hpp>
-#include <boost/type_traits/remove_const.hpp>
-#include <boost/type_traits/remove_reference.hpp>
-#include <boost/utility/enable_if.hpp>
-
-#if !defined(BOOST_NO_SFINAE)
-#include <boost/type_traits/is_convertible.hpp>
-#endif
-
-namespace boost{
-
-template<class T> class reference_wrapper; /* fwd decl. */
-
-namespace multi_index{
-
-namespace detail{
-
-/* global_fun is a read-only key extractor from Value based on a given global
- * (or static member) function with signature:
- *
- *   Type f([const] Value [&]);
- *
- * Additionally, global_fun  and const_global_fun are overloaded to support
- * referece_wrappers of Value and "chained pointers" to Value's. By chained
- * pointer to T we  mean a type P such that, given a p of Type P
- *   *...n...*x is convertible to T&, for some n>=1.
- * Examples of chained pointers are raw and smart pointers, iterators and
- * arbitrary combinations of these (vg. T** or unique_ptr<T*>.)
- */
-
-template<class Value,typename Type,Type (*PtrToFunction)(Value)>
-struct const_ref_global_fun_base
-{
-  typedef typename remove_reference<Type>::type result_type;
-
-  template<typename ChainedPtr>
-
-#if !defined(BOOST_NO_SFINAE)
-  typename disable_if<
-    is_convertible<const ChainedPtr&,Value>,Type>::type
-#else
-  Type
-#endif
-
-  operator()(const ChainedPtr& x)const
-  {
-    return operator()(*x);
-  }
-
-  Type operator()(Value x)const
-  {
-    return PtrToFunction(x);
-  }
-
-  Type operator()(
-    const reference_wrapper<
-      typename remove_reference<Value>::type>& x)const
-  { 
-    return operator()(x.get());
-  }
-
-  Type operator()(
-    const reference_wrapper<
-      typename remove_const<
-        typename remove_reference<Value>::type>::type>& x
-
-#if BOOST_WORKAROUND(BOOST_MSVC,==1310)
-/* http://lists.boost.org/Archives/boost/2015/10/226135.php */
-    ,int=0
-#endif
-
-  )const
-  { 
-    return operator()(x.get());
-  }
-};
-
-template<class Value,typename Type,Type (*PtrToFunction)(Value)>
-struct non_const_ref_global_fun_base
-{
-  typedef typename remove_reference<Type>::type result_type;
-
-  template<typename ChainedPtr>
-
-#if !defined(BOOST_NO_SFINAE)
-  typename disable_if<
-    is_convertible<ChainedPtr&,Value>,Type>::type
-#else
-  Type
-#endif
-
-  operator()(const ChainedPtr& x)const
-  {
-    return operator()(*x);
-  }
-
-  Type operator()(Value x)const
-  {
-    return PtrToFunction(x);
-  }
-
-  Type operator()(
-    const reference_wrapper<
-      typename remove_reference<Value>::type>& x)const
-  { 
-    return operator()(x.get());
-  }
-};
-
-template<class Value,typename Type,Type (*PtrToFunction)(Value)>
-struct non_ref_global_fun_base
-{
-  typedef typename remove_reference<Type>::type result_type;
-
-  template<typename ChainedPtr>
-
-#if !defined(BOOST_NO_SFINAE)
-  typename disable_if<
-    is_convertible<const ChainedPtr&,const Value&>,Type>::type
-#else
-  Type
-#endif
-
-  operator()(const ChainedPtr& x)const
-  {
-    return operator()(*x);
-  }
-
-  Type operator()(const Value& x)const
-  {
-    return PtrToFunction(x);
-  }
-
-  Type operator()(const reference_wrapper<const Value>& x)const
-  { 
-    return operator()(x.get());
-  }
-
-  Type operator()(
-    const reference_wrapper<typename remove_const<Value>::type>& x)const
-  { 
-    return operator()(x.get());
-  }
-};
-
-} /* namespace multi_index::detail */
-
-template<class Value,typename Type,Type (*PtrToFunction)(Value)>
-struct global_fun:
-  mpl::if_c<
-    is_reference<Value>::value,
-    typename mpl::if_c<
-      is_const<typename remove_reference<Value>::type>::value,
-      detail::const_ref_global_fun_base<Value,Type,PtrToFunction>,
-      detail::non_const_ref_global_fun_base<Value,Type,PtrToFunction>
-    >::type,
-    detail::non_ref_global_fun_base<Value,Type,PtrToFunction>
-  >::type
-{
-};
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/hashed_index.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/hashed_index.hpp
deleted file mode 100644
index 352d0c13f17..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/hashed_index.hpp
+++ /dev/null
@@ -1,1725 +0,0 @@
-/* Copyright 2003-2015 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_HASHED_INDEX_HPP
-#define BOOST_MULTI_INDEX_HASHED_INDEX_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <algorithm>
-#include <boost/call_traits.hpp>
-#include <boost/detail/allocator_utilities.hpp>
-#include <boost/detail/no_exceptions_support.hpp>
-#include <boost/detail/workaround.hpp>
-#include <boost/foreach_fwd.hpp>
-#include <boost/limits.hpp>
-#include <boost/move/core.hpp>
-#include <boost/mpl/bool.hpp>
-#include <boost/mpl/if.hpp>
-#include <boost/mpl/push_front.hpp>
-#include <boost/multi_index/detail/access_specifier.hpp>
-#include <boost/multi_index/detail/auto_space.hpp>
-#include <boost/multi_index/detail/bucket_array.hpp>
-#include <boost/multi_index/detail/do_not_copy_elements_tag.hpp>
-#include <boost/multi_index/detail/hash_index_iterator.hpp>
-#include <boost/multi_index/detail/index_node_base.hpp>
-#include <boost/multi_index/detail/modify_key_adaptor.hpp>
-#include <boost/multi_index/detail/promotes_arg.hpp>
-#include <boost/multi_index/detail/safe_mode.hpp>
-#include <boost/multi_index/detail/scope_guard.hpp>
-#include <boost/multi_index/detail/vartempl_support.hpp>
-#include <boost/multi_index/hashed_index_fwd.hpp>
-#include <boost/tuple/tuple.hpp>
-#include <boost/type_traits/is_same.hpp>
-#include <cmath>
-#include <cstddef>
-#include <functional>
-#include <iterator>
-#include <utility>
-
-#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
-#include <initializer_list>
-#endif
-
-#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
-#include <boost/serialization/nvp.hpp>
-#endif
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING)
-#define BOOST_MULTI_INDEX_HASHED_INDEX_CHECK_INVARIANT_OF(x)                 \
-  detail::scope_guard BOOST_JOIN(check_invariant_,__LINE__)=                 \
-    detail::make_obj_guard(x,&hashed_index::check_invariant_);               \
-  BOOST_JOIN(check_invariant_,__LINE__).touch();
-#define BOOST_MULTI_INDEX_HASHED_INDEX_CHECK_INVARIANT                       \
-  BOOST_MULTI_INDEX_HASHED_INDEX_CHECK_INVARIANT_OF(*this)
-#else
-#define BOOST_MULTI_INDEX_HASHED_INDEX_CHECK_INVARIANT_OF(x)
-#define BOOST_MULTI_INDEX_HASHED_INDEX_CHECK_INVARIANT
-#endif
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-/* hashed_index adds a layer of hashed indexing to a given Super */
-
-/* Most of the implementation of unique and non-unique indices is
- * shared. We tell from one another on instantiation time by using
- * Category tags defined in hash_index_node.hpp.
- */
-
-template<
-  typename KeyFromValue,typename Hash,typename Pred,
-  typename SuperMeta,typename TagList,typename Category
->
-class hashed_index:
-  BOOST_MULTI_INDEX_PROTECTED_IF_MEMBER_TEMPLATE_FRIENDS SuperMeta::type
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-  ,public safe_mode::safe_container<
-    hashed_index<KeyFromValue,Hash,Pred,SuperMeta,TagList,Category> >
-#endif
-
-{ 
-#if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING)&&\
-    BOOST_WORKAROUND(__MWERKS__,<=0x3003)
-/* The "ISO C++ Template Parser" option in CW8.3 has a problem with the
- * lifetime of const references bound to temporaries --precisely what
- * scopeguards are.
- */
-
-#pragma parse_mfunc_templ off
-#endif
-
-  typedef typename SuperMeta::type                   super;
-
-protected:
-  typedef hashed_index_node<
-    typename super::node_type,Category>              node_type;
-
-private:
-  typedef typename node_type::node_alg               node_alg;
-  typedef typename node_type::impl_type              node_impl_type;
-  typedef typename node_impl_type::pointer           node_impl_pointer;
-  typedef typename node_impl_type::base_pointer      node_impl_base_pointer;
-  typedef bucket_array<
-    typename super::final_allocator_type>            bucket_array_type;
-
-public:
-  /* types */
-
-  typedef typename KeyFromValue::result_type         key_type;
-  typedef typename node_type::value_type             value_type;
-  typedef KeyFromValue                               key_from_value;
-  typedef Hash                                       hasher;
-  typedef Pred                                       key_equal;
-  typedef tuple<std::size_t,
-    key_from_value,hasher,key_equal>                 ctor_args;
-  typedef typename super::final_allocator_type       allocator_type;
-  typedef typename allocator_type::pointer           pointer;
-  typedef typename allocator_type::const_pointer     const_pointer;
-  typedef typename allocator_type::reference         reference;
-  typedef typename allocator_type::const_reference   const_reference;
-  typedef std::size_t                                size_type;      
-  typedef std::ptrdiff_t                             difference_type;
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-  typedef safe_mode::safe_iterator<
-    hashed_index_iterator<
-      node_type,bucket_array_type,
-      hashed_index_global_iterator_tag>,
-    hashed_index>                                    iterator;
-#else
-  typedef hashed_index_iterator<
-    node_type,bucket_array_type,
-    hashed_index_global_iterator_tag>                iterator;
-#endif
-
-  typedef iterator                                   const_iterator;
-
-  typedef hashed_index_iterator<
-    node_type,bucket_array_type,
-    hashed_index_local_iterator_tag>                 local_iterator;
-  typedef local_iterator                             const_local_iterator;
-
-  typedef TagList                                    tag_list;
-
-protected:
-  typedef typename super::final_node_type     final_node_type;
-  typedef tuples::cons<
-    ctor_args, 
-    typename super::ctor_args_list>           ctor_args_list;
-  typedef typename mpl::push_front<
-    typename super::index_type_list,
-    hashed_index>::type                       index_type_list;
-  typedef typename mpl::push_front<
-    typename super::iterator_type_list,
-    iterator>::type                           iterator_type_list;
-  typedef typename mpl::push_front<
-    typename super::const_iterator_type_list,
-    const_iterator>::type                     const_iterator_type_list;
-  typedef typename super::copy_map_type       copy_map_type;
-
-#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
-  typedef typename super::index_saver_type    index_saver_type;
-  typedef typename super::index_loader_type   index_loader_type;
-#endif
-
-private:
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-  typedef safe_mode::safe_container<
-    hashed_index>                             safe_super;
-#endif
-
-  typedef typename call_traits<value_type>::param_type value_param_type;
-  typedef typename call_traits<
-    key_type>::param_type                              key_param_type;
-
-  /* Needed to avoid commas in BOOST_MULTI_INDEX_OVERLOADS_TO_VARTEMPL
-   * expansion.
-   */
-
-  typedef std::pair<iterator,bool>                     emplace_return_type;
-
-public:
-
-  /* construct/destroy/copy
-   * Default and copy ctors are in the protected section as indices are
-   * not supposed to be created on their own. No range ctor either.
-   */
-
-  hashed_index<KeyFromValue,Hash,Pred,SuperMeta,TagList,Category>& operator=(
-    const hashed_index<KeyFromValue,Hash,Pred,SuperMeta,TagList,Category>& x)
-  {
-    this->final()=x.final();
-    return *this;
-  }
-
-#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
-  hashed_index<KeyFromValue,Hash,Pred,SuperMeta,TagList,Category>& operator=(
-    std::initializer_list<value_type> list)
-  {
-    this->final()=list;
-    return *this;
-  }
-#endif
-
-  allocator_type get_allocator()const BOOST_NOEXCEPT
-  {
-    return this->final().get_allocator();
-  }
-
-  /* size and capacity */
-
-  bool      empty()const BOOST_NOEXCEPT{return this->final_empty_();}
-  size_type size()const BOOST_NOEXCEPT{return this->final_size_();}
-  size_type max_size()const BOOST_NOEXCEPT{return this->final_max_size_();}
-
-  /* iterators */
-
-  iterator begin()BOOST_NOEXCEPT
-    {return make_iterator(node_type::from_impl(header()->next()->prior()));}
-  const_iterator begin()const BOOST_NOEXCEPT
-    {return make_iterator(node_type::from_impl(header()->next()->prior()));}
-  iterator       end()BOOST_NOEXCEPT{return make_iterator(header());}
-  const_iterator end()const BOOST_NOEXCEPT{return make_iterator(header());}
-  const_iterator cbegin()const BOOST_NOEXCEPT{return begin();}
-  const_iterator cend()const BOOST_NOEXCEPT{return end();}
-
-  iterator iterator_to(const value_type& x)
-  {
-    return make_iterator(node_from_value<node_type>(&x));
-  }
-
-  const_iterator iterator_to(const value_type& x)const
-  {
-    return make_iterator(node_from_value<node_type>(&x));
-  }
-
-  /* modifiers */
-
-  BOOST_MULTI_INDEX_OVERLOADS_TO_VARTEMPL(
-    emplace_return_type,emplace,emplace_impl)
-
-  BOOST_MULTI_INDEX_OVERLOADS_TO_VARTEMPL_EXTRA_ARG(
-    iterator,emplace_hint,emplace_hint_impl,iterator,position)
-
-  std::pair<iterator,bool> insert(const value_type& x)
-  {
-    BOOST_MULTI_INDEX_HASHED_INDEX_CHECK_INVARIANT;
-    std::pair<final_node_type*,bool> p=this->final_insert_(x);
-    return std::pair<iterator,bool>(make_iterator(p.first),p.second);
-  }
-
-  std::pair<iterator,bool> insert(BOOST_RV_REF(value_type) x)
-  {
-    BOOST_MULTI_INDEX_HASHED_INDEX_CHECK_INVARIANT;
-    std::pair<final_node_type*,bool> p=this->final_insert_rv_(x);
-    return std::pair<iterator,bool>(make_iterator(p.first),p.second);
-  }
-
-  iterator insert(iterator position,const value_type& x)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
-    BOOST_MULTI_INDEX_HASHED_INDEX_CHECK_INVARIANT;
-    std::pair<final_node_type*,bool> p=this->final_insert_(
-      x,static_cast<final_node_type*>(position.get_node()));
-    return make_iterator(p.first);
-  }
-    
-  iterator insert(iterator position,BOOST_RV_REF(value_type) x)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
-    BOOST_MULTI_INDEX_HASHED_INDEX_CHECK_INVARIANT;
-    std::pair<final_node_type*,bool> p=this->final_insert_rv_(
-      x,static_cast<final_node_type*>(position.get_node()));
-    return make_iterator(p.first);
-  }
-
-  template<typename InputIterator>
-  void insert(InputIterator first,InputIterator last)
-  {
-    BOOST_MULTI_INDEX_HASHED_INDEX_CHECK_INVARIANT;
-    for(;first!=last;++first)this->final_insert_ref_(*first);
-  }
-
-#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
-  void insert(std::initializer_list<value_type> list)
-  {
-    insert(list.begin(),list.end());
-  }
-#endif
-
-  iterator erase(iterator position)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
-    BOOST_MULTI_INDEX_HASHED_INDEX_CHECK_INVARIANT;
-    this->final_erase_(static_cast<final_node_type*>(position++.get_node()));
-    return position;
-  }
-
-  size_type erase(key_param_type k)
-  {
-    BOOST_MULTI_INDEX_HASHED_INDEX_CHECK_INVARIANT;
-
-    std::size_t buc=buckets.position(hash_(k));
-    for(node_impl_pointer x=buckets.at(buc)->prior();
-        x!=node_impl_pointer(0);x=node_alg::next_to_inspect(x)){
-      if(eq_(k,key(node_type::from_impl(x)->value()))){
-        node_impl_pointer y=end_of_range(x);
-        size_type         s=0;
-        do{
-          node_impl_pointer z=node_alg::after(x);
-          this->final_erase_(
-            static_cast<final_node_type*>(node_type::from_impl(x)));
-          x=z;
-          ++s;
-        }while(x!=y);
-        return s;
-      }
-    }
-    return 0;
-  }
-
-  iterator erase(iterator first,iterator last)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(first);
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(last);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(first,*this);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(last,*this);
-    BOOST_MULTI_INDEX_CHECK_VALID_RANGE(first,last);
-    BOOST_MULTI_INDEX_HASHED_INDEX_CHECK_INVARIANT;
-    while(first!=last){
-      first=erase(first);
-    }
-    return first;
-  }
-
-  bool replace(iterator position,const value_type& x)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
-    BOOST_MULTI_INDEX_HASHED_INDEX_CHECK_INVARIANT;
-    return this->final_replace_(
-      x,static_cast<final_node_type*>(position.get_node()));
-  }
-
-  bool replace(iterator position,BOOST_RV_REF(value_type) x)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
-    BOOST_MULTI_INDEX_HASHED_INDEX_CHECK_INVARIANT;
-    return this->final_replace_rv_(
-      x,static_cast<final_node_type*>(position.get_node()));
-  }
-
-  template<typename Modifier>
-  bool modify(iterator position,Modifier mod)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
-    BOOST_MULTI_INDEX_HASHED_INDEX_CHECK_INVARIANT;
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-    /* MSVC++ 6.0 optimizer on safe mode code chokes if this
-     * this is not added. Left it for all compilers as it does no
-     * harm.
-     */
-
-    position.detach();
-#endif
-
-    return this->final_modify_(
-      mod,static_cast<final_node_type*>(position.get_node()));
-  }
-
-  template<typename Modifier,typename Rollback>
-  bool modify(iterator position,Modifier mod,Rollback back_)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
-    BOOST_MULTI_INDEX_HASHED_INDEX_CHECK_INVARIANT;
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-    /* MSVC++ 6.0 optimizer on safe mode code chokes if this
-     * this is not added. Left it for all compilers as it does no
-     * harm.
-     */
-
-    position.detach();
-#endif
-
-    return this->final_modify_(
-      mod,back_,static_cast<final_node_type*>(position.get_node()));
-  }
-
-  template<typename Modifier>
-  bool modify_key(iterator position,Modifier mod)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
-    BOOST_MULTI_INDEX_HASHED_INDEX_CHECK_INVARIANT;
-    return modify(
-      position,modify_key_adaptor<Modifier,value_type,KeyFromValue>(mod,key));
-  }
-
-  template<typename Modifier,typename Rollback>
-  bool modify_key(iterator position,Modifier mod,Rollback back_)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
-    BOOST_MULTI_INDEX_HASHED_INDEX_CHECK_INVARIANT;
-    return modify(
-      position,
-      modify_key_adaptor<Modifier,value_type,KeyFromValue>(mod,key),
-      modify_key_adaptor<Rollback,value_type,KeyFromValue>(back_,key));
-  }
-
-  void clear()BOOST_NOEXCEPT
-  {
-    BOOST_MULTI_INDEX_HASHED_INDEX_CHECK_INVARIANT;
-    this->final_clear_();
-  }
-
-  void swap(hashed_index<KeyFromValue,Hash,Pred,SuperMeta,TagList,Category>& x)
-  {
-    BOOST_MULTI_INDEX_HASHED_INDEX_CHECK_INVARIANT;
-    BOOST_MULTI_INDEX_HASHED_INDEX_CHECK_INVARIANT_OF(x);
-    this->final_swap_(x.final());
-  }
-
-  /* observers */
-
-  key_from_value key_extractor()const{return key;}
-  hasher         hash_function()const{return hash_;}
-  key_equal      key_eq()const{return eq_;}
-  
-  /* lookup */
-
-  /* Internally, these ops rely on const_iterator being the same
-   * type as iterator.
-   */
-
-  /* Implementation note: When CompatibleKey is consistently promoted to
-   * KeyFromValue::result_type for equality comparison, the promotion is made
-   * once in advance to increase efficiency.
-   */
-
-  template<typename CompatibleKey>
-  iterator find(const CompatibleKey& k)const
-  {
-    return find(k,hash_,eq_);
-  }
-
-  template<
-    typename CompatibleKey,typename CompatibleHash,typename CompatiblePred
-  >
-  iterator find(
-    const CompatibleKey& k,
-    const CompatibleHash& hash,const CompatiblePred& eq)const
-  {
-    return find(
-      k,hash,eq,promotes_1st_arg<CompatiblePred,CompatibleKey,key_type>());
-  }
-
-  template<typename CompatibleKey>
-  size_type count(const CompatibleKey& k)const
-  {
-    return count(k,hash_,eq_);
-  }
-
-  template<
-    typename CompatibleKey,typename CompatibleHash,typename CompatiblePred
-  >
-  size_type count(
-    const CompatibleKey& k,
-    const CompatibleHash& hash,const CompatiblePred& eq)const
-  {
-    return count(
-      k,hash,eq,promotes_1st_arg<CompatiblePred,CompatibleKey,key_type>());
-  }
-
-  template<typename CompatibleKey>
-  std::pair<iterator,iterator> equal_range(const CompatibleKey& k)const
-  {
-    return equal_range(k,hash_,eq_);
-  }
-
-  template<
-    typename CompatibleKey,typename CompatibleHash,typename CompatiblePred
-  >
-  std::pair<iterator,iterator> equal_range(
-    const CompatibleKey& k,
-    const CompatibleHash& hash,const CompatiblePred& eq)const
-  {
-    return equal_range(
-      k,hash,eq,promotes_1st_arg<CompatiblePred,CompatibleKey,key_type>());
-  }
-
-  /* bucket interface */
-
-  size_type bucket_count()const BOOST_NOEXCEPT{return buckets.size();}
-  size_type max_bucket_count()const BOOST_NOEXCEPT{return static_cast<size_type>(-1);}
-
-  size_type bucket_size(size_type n)const
-  {
-    size_type res=0;
-    for(node_impl_pointer x=buckets.at(n)->prior();
-        x!=node_impl_pointer(0);x=node_alg::after_local(x)){
-      ++res;
-    }
-    return res;
-  }
-
-  size_type bucket(key_param_type k)const
-  {
-    return buckets.position(hash_(k));
-  }
-
-  local_iterator begin(size_type n)
-  {
-    return const_cast<const hashed_index*>(this)->begin(n);
-  }
-
-  const_local_iterator begin(size_type n)const
-  {
-    node_impl_pointer x=buckets.at(n)->prior();
-    if(x==node_impl_pointer(0))return end(n);
-    return make_local_iterator(node_type::from_impl(x));
-  }
-
-  local_iterator end(size_type n)
-  {
-    return const_cast<const hashed_index*>(this)->end(n);
-  }
-
-  const_local_iterator end(size_type)const
-  {
-    return make_local_iterator(0);
-  }
-
-  const_local_iterator cbegin(size_type n)const{return begin(n);}
-  const_local_iterator cend(size_type n)const{return end(n);}
-
-  local_iterator local_iterator_to(const value_type& x)
-  {
-    return make_local_iterator(node_from_value<node_type>(&x));
-  }
-
-  const_local_iterator local_iterator_to(const value_type& x)const
-  {
-    return make_local_iterator(node_from_value<node_type>(&x));
-  }
-
-  /* hash policy */
-
-  float load_factor()const BOOST_NOEXCEPT
-    {return static_cast<float>(size())/bucket_count();}
-  float max_load_factor()const BOOST_NOEXCEPT{return mlf;}
-  void  max_load_factor(float z){mlf=z;calculate_max_load();}
-
-  void rehash(size_type n)
-  {
-    BOOST_MULTI_INDEX_HASHED_INDEX_CHECK_INVARIANT;
-    if(size()<=max_load&&n<=bucket_count())return;
-
-    size_type bc =(std::numeric_limits<size_type>::max)();
-    float     fbc=static_cast<float>(1+size()/mlf);
-    if(bc>fbc){
-      bc=static_cast<size_type>(fbc);
-      if(bc<n)bc=n;
-    }
-    unchecked_rehash(bc);
-  }
-
-  void reserve(size_type n)
-  {
-    rehash(static_cast<size_type>(std::ceil(static_cast<double>(n)/mlf)));
-  }
-
-BOOST_MULTI_INDEX_PROTECTED_IF_MEMBER_TEMPLATE_FRIENDS:
-  hashed_index(const ctor_args_list& args_list,const allocator_type& al):
-    super(args_list.get_tail(),al),
-    key(tuples::get<1>(args_list.get_head())),
-    hash_(tuples::get<2>(args_list.get_head())),
-    eq_(tuples::get<3>(args_list.get_head())),
-    buckets(al,header()->impl(),tuples::get<0>(args_list.get_head())),
-    mlf(1.0f)
-  {
-    calculate_max_load();
-  }
-
-  hashed_index(
-    const hashed_index<KeyFromValue,Hash,Pred,SuperMeta,TagList,Category>& x):
-    super(x),
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-    safe_super(),
-#endif
-
-    key(x.key),
-    hash_(x.hash_),
-    eq_(x.eq_),
-    buckets(x.get_allocator(),header()->impl(),x.buckets.size()),
-    mlf(x.mlf),
-    max_load(x.max_load)
-  {
-    /* Copy ctor just takes the internal configuration objects from x. The rest
-     * is done in subsequent call to copy_().
-     */
-  }
-
-  hashed_index(
-    const hashed_index<KeyFromValue,Hash,Pred,SuperMeta,TagList,Category>& x,
-    do_not_copy_elements_tag):
-    super(x,do_not_copy_elements_tag()),
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-    safe_super(),
-#endif
-
-    key(x.key),
-    hash_(x.hash_),
-    eq_(x.eq_),
-    buckets(x.get_allocator(),header()->impl(),0),
-    mlf(1.0f)
-  {
-     calculate_max_load();
-  }
-
-  ~hashed_index()
-  {
-    /* the container is guaranteed to be empty by now */
-  }
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-  iterator make_iterator(node_type* node)
-  {
-    return iterator(node,this);
-  }
-
-  const_iterator make_iterator(node_type* node)const
-  {
-    return const_iterator(node,const_cast<hashed_index*>(this));
-  }
-#else
-  iterator make_iterator(node_type* node)
-  {
-    return iterator(node);
-  }
-
-  const_iterator make_iterator(node_type* node)const
-  {
-    return const_iterator(node);
-  }
-#endif
-
-  local_iterator make_local_iterator(node_type* node)
-  {
-    return local_iterator(node);
-  }
-
-  const_local_iterator make_local_iterator(node_type* node)const
-  {
-    return const_local_iterator(node);
-  }
-
-  void copy_(
-    const hashed_index<KeyFromValue,Hash,Pred,SuperMeta,TagList,Category>& x,
-    const copy_map_type& map)
-  {
-    copy_(x,map,Category());
-  }
-
-  void copy_(
-    const hashed_index<KeyFromValue,Hash,Pred,SuperMeta,TagList,Category>& x,
-    const copy_map_type& map,hashed_unique_tag)
-  {
-    if(x.size()!=0){
-      node_impl_pointer end_org=x.header()->impl(),
-                        org=end_org,
-                        cpy=header()->impl();
-      do{
-        node_impl_pointer prev_org=org->prior(),
-                          prev_cpy=
-          static_cast<node_type*>(map.find(static_cast<final_node_type*>(
-            node_type::from_impl(prev_org))))->impl();
-        cpy->prior()=prev_cpy;
-        if(node_alg::is_first_of_bucket(org)){
-          node_impl_base_pointer buc_org=prev_org->next(),
-                                 buc_cpy=
-            buckets.begin()+(buc_org-x.buckets.begin());
-          prev_cpy->next()=buc_cpy;
-          buc_cpy->prior()=cpy;
-        }
-        else{
-          prev_cpy->next()=node_impl_type::base_pointer_from(cpy);
-        }
-        org=prev_org;
-        cpy=prev_cpy;
-      }while(org!=end_org);
-    }
-
-    super::copy_(x,map);
-  }
-  
-  void copy_(
-    const hashed_index<KeyFromValue,Hash,Pred,SuperMeta,TagList,Category>& x,
-    const copy_map_type& map,hashed_non_unique_tag)
-  {
-    if(x.size()!=0){
-      node_impl_pointer end_org=x.header()->impl(),
-                        org=end_org,
-                        cpy=header()->impl();
-      do{
-        node_impl_pointer next_org=node_alg::after(org),
-                          next_cpy=
-          static_cast<node_type*>(map.find(static_cast<final_node_type*>(
-            node_type::from_impl(next_org))))->impl();
-        if(node_alg::is_first_of_bucket(next_org)){
-          node_impl_base_pointer buc_org=org->next(),
-                                 buc_cpy=
-            buckets.begin()+(buc_org-x.buckets.begin());
-          cpy->next()=buc_cpy;
-          buc_cpy->prior()=next_cpy;
-          next_cpy->prior()=cpy;
-        }
-        else{
-          if(org->next()==node_impl_type::base_pointer_from(next_org)){
-            cpy->next()=node_impl_type::base_pointer_from(next_cpy);
-          }
-          else{
-            cpy->next()=
-              node_impl_type::base_pointer_from(
-                static_cast<node_type*>(map.find(static_cast<final_node_type*>(
-                  node_type::from_impl(
-                    node_impl_type::pointer_from(org->next())))))->impl());
-          }
-
-          if(next_org->prior()!=org){
-            next_cpy->prior()=
-              static_cast<node_type*>(map.find(static_cast<final_node_type*>(
-                node_type::from_impl(next_org->prior()))))->impl();
-          }
-          else{
-            next_cpy->prior()=cpy;
-          }
-        }
-        org=next_org;
-        cpy=next_cpy;
-      }while(org!=end_org);
-    }
-
-    super::copy_(x,map);
-  }
-
-  template<typename Variant>
-  final_node_type* insert_(
-    value_param_type v,final_node_type*& x,Variant variant)
-  {
-    reserve_for_insert(size()+1);
-
-    std::size_t buc=find_bucket(v);
-    link_info   pos(buckets.at(buc));
-    if(!link_point(v,pos)){
-      return static_cast<final_node_type*>(
-        node_type::from_impl(node_impl_type::pointer_from(pos)));
-    }
-
-    final_node_type* res=super::insert_(v,x,variant);
-    if(res==x)link(static_cast<node_type*>(x),pos);
-    return res;
-  }
-
-  template<typename Variant>
-  final_node_type* insert_(
-    value_param_type v,node_type* position,final_node_type*& x,Variant variant)
-  {
-    reserve_for_insert(size()+1);
-
-    std::size_t buc=find_bucket(v);
-    link_info   pos(buckets.at(buc));
-    if(!link_point(v,pos)){
-      return static_cast<final_node_type*>(
-        node_type::from_impl(node_impl_type::pointer_from(pos)));
-    }
-
-    final_node_type* res=super::insert_(v,position,x,variant);
-    if(res==x)link(static_cast<node_type*>(x),pos);
-    return res;
-  }
-
-  void erase_(node_type* x)
-  {
-    unlink(x);
-    super::erase_(x);
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-    detach_iterators(x);
-#endif
-  }
-
-  void delete_all_nodes_()
-  {
-    delete_all_nodes_(Category());
-  }
-
-  void delete_all_nodes_(hashed_unique_tag)
-  {
-    for(node_impl_pointer x_end=header()->impl(),x=x_end->prior();x!=x_end;){
-      node_impl_pointer y=x->prior();
-      this->final_delete_node_(
-        static_cast<final_node_type*>(node_type::from_impl(x)));
-      x=y;
-    }
-  }
-
-  void delete_all_nodes_(hashed_non_unique_tag)
-  {
-    for(node_impl_pointer x_end=header()->impl(),x=x_end->prior();x!=x_end;){
-      node_impl_pointer y=x->prior();
-      if(y->next()!=node_impl_type::base_pointer_from(x)&&
-         y->next()->prior()!=x){ /* n-1 of group */
-        /* Make the second node prior() pointer back-linked so that it won't
-         * refer to a deleted node when the time for its own destruction comes.
-         */
-
-        node_impl_pointer first=node_impl_type::pointer_from(y->next());
-        first->next()->prior()=first;
-      }
-      this->final_delete_node_(
-        static_cast<final_node_type*>(node_type::from_impl(x)));
-      x=y;
-    }
-  }
-
-  void clear_()
-  {
-    super::clear_();
-    buckets.clear(header()->impl());
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-    safe_super::detach_dereferenceable_iterators();
-#endif
-  }
-
-  void swap_(
-    hashed_index<KeyFromValue,Hash,Pred,SuperMeta,TagList,Category>& x)
-  {
-    std::swap(key,x.key);
-    std::swap(hash_,x.hash_);
-    std::swap(eq_,x.eq_);
-    buckets.swap(x.buckets);
-    std::swap(mlf,x.mlf);
-    std::swap(max_load,x.max_load);
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-    safe_super::swap(x);
-#endif
-
-    super::swap_(x);
-  }
-
-  void swap_elements_(
-    hashed_index<KeyFromValue,Hash,Pred,SuperMeta,TagList,Category>& x)
-  {
-    buckets.swap(x.buckets);
-    std::swap(mlf,x.mlf);
-    std::swap(max_load,x.max_load);
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-    safe_super::swap(x);
-#endif
-
-    super::swap_elements_(x);
-  }
-
-  template<typename Variant>
-  bool replace_(value_param_type v,node_type* x,Variant variant)
-  {
-    if(eq_(key(v),key(x->value()))){
-      return super::replace_(v,x,variant);
-    }
-      
-    unlink_undo undo;
-    unlink(x,undo);
-
-    BOOST_TRY{
-      std::size_t  buc=find_bucket(v);
-      link_info    pos(buckets.at(buc));
-      if(link_point(v,pos)&&super::replace_(v,x,variant)){
-        link(x,pos);
-        return true;
-      }
-      undo();
-      return false;
-    }
-    BOOST_CATCH(...){
-      undo();
-      BOOST_RETHROW;
-    }
-    BOOST_CATCH_END
-  }
-
-  bool modify_(node_type* x)
-  {
-    std::size_t buc;
-    bool        b; 
-    BOOST_TRY{
-      buc=find_bucket(x->value());
-      b=in_place(x->impl(),key(x->value()),buc);
-    }
-    BOOST_CATCH(...){
-      erase_(x);
-      BOOST_RETHROW;
-    }
-    BOOST_CATCH_END
-    if(!b){
-      unlink(x);
-      BOOST_TRY{
-        link_info pos(buckets.at(buc));
-        if(!link_point(x->value(),pos)){
-          super::erase_(x);
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-          detach_iterators(x);
-#endif
-          return false;
-        }
-        link(x,pos);
-      }
-      BOOST_CATCH(...){
-        super::erase_(x);
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-      detach_iterators(x);
-#endif
-
-        BOOST_RETHROW;
-      }
-      BOOST_CATCH_END
-    }
-
-    BOOST_TRY{
-      if(!super::modify_(x)){
-        unlink(x);
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-        detach_iterators(x);
-#endif
-        return false;
-      }
-      else return true;
-    }
-    BOOST_CATCH(...){
-      unlink(x);
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-      detach_iterators(x);
-#endif
-
-      BOOST_RETHROW;
-    }
-    BOOST_CATCH_END
-  }
-
-  bool modify_rollback_(node_type* x)
-  {
-    std::size_t buc=find_bucket(x->value());
-    if(in_place(x->impl(),key(x->value()),buc)){
-      return super::modify_rollback_(x);
-    }
-
-    unlink_undo undo;
-    unlink(x,undo);
-
-    BOOST_TRY{
-      link_info pos(buckets.at(buc));
-      if(link_point(x->value(),pos)&&super::modify_rollback_(x)){
-        link(x,pos);
-        return true;
-      }
-      undo();
-      return false;
-    }
-    BOOST_CATCH(...){
-      undo();
-      BOOST_RETHROW;
-    }
-    BOOST_CATCH_END
-  }
-
-  /* comparison */
-
-#if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
-  /* defect macro refers to class, not function, templates, but anyway */
-
-  template<typename K,typename H,typename P,typename S,typename T,typename C>
-  friend bool operator==(
-    const hashed_index<K,H,P,S,T,C>&,const hashed_index<K,H,P,S,T,C>& y);
-#endif
-
-  bool equals(const hashed_index& x)const{return equals(x,Category());}
-
-  bool equals(const hashed_index& x,hashed_unique_tag)const
-  {
-    if(size()!=x.size())return false;
-    for(const_iterator it=begin(),it_end=end(),it2_end=x.end();
-        it!=it_end;++it){
-      const_iterator it2=x.find(key(*it));
-      if(it2==it2_end||!(*it==*it2))return false;
-    }
-    return true;
-  }
-
-  bool equals(const hashed_index& x,hashed_non_unique_tag)const
-  {
-    if(size()!=x.size())return false;
-    for(const_iterator it=begin(),it_end=end();it!=it_end;){
-      const_iterator it2,it2_last;
-      boost::tie(it2,it2_last)=x.equal_range(key(*it));
-      if(it2==it2_last)return false;
-
-      const_iterator it_last=make_iterator(
-        node_type::from_impl(end_of_range(it.get_node()->impl())));
-      if(std::distance(it,it_last)!=std::distance(it2,it2_last))return false;
-
-      /* From is_permutation code in
-       * http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3068.pdf
-       */
-
-      for(;it!=it_last;++it,++it2){
-        if(!(*it==*it2))break;
-      }
-      if(it!=it_last){
-        for(const_iterator scan=it;scan!=it_last;++scan){
-          if(std::find(it,scan,*scan)!=scan)continue;
-          std::ptrdiff_t matches=std::count(it2,it2_last,*scan);
-          if(matches==0||matches!=std::count(scan,it_last,*scan))return false;
-        }
-        it=it_last;
-      }
-    }
-    return true;
-  }
-
-#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
-  /* serialization */
-
-  template<typename Archive>
-  void save_(
-    Archive& ar,const unsigned int version,const index_saver_type& sm)const
-  {
-    ar<<serialization::make_nvp("position",buckets);
-    super::save_(ar,version,sm);
-  }
-
-  template<typename Archive>
-  void load_(Archive& ar,const unsigned int version,const index_loader_type& lm)
-  {
-    ar>>serialization::make_nvp("position",buckets);
-    super::load_(ar,version,lm);
-  }
-#endif
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING)
-  /* invariant stuff */
-
-  bool invariant_()const
-  {
-    if(size()==0||begin()==end()){
-      if(size()!=0||begin()!=end())return false;
-    }
-    else{
-      size_type s0=0;
-      for(const_iterator it=begin(),it_end=end();it!=it_end;++it,++s0){}
-      if(s0!=size())return false;
-
-      size_type s1=0;
-      for(size_type buc=0;buc<bucket_count();++buc){
-        size_type ss1=0;
-        for(const_local_iterator it=begin(buc),it_end=end(buc);
-            it!=it_end;++it,++ss1){
-          if(find_bucket(*it)!=buc)return false;
-        }
-        if(ss1!=bucket_size(buc))return false;
-        s1+=ss1;
-      }
-      if(s1!=size())return false;
-    }
-
-    return super::invariant_();
-  }
-
-  /* This forwarding function eases things for the boost::mem_fn construct
-   * in BOOST_MULTI_INDEX_HASHED_INDEX_CHECK_INVARIANT. Actually,
-   * final_check_invariant is already an inherited member function of index.
-   */
-  void check_invariant_()const{this->final_check_invariant_();}
-#endif
-
-private:
-  node_type* header()const{return this->final_header();}
-
-  std::size_t find_bucket(value_param_type v)const
-  {
-    return bucket(key(v));
-  }
-
-  struct link_info_non_unique
-  {
-    link_info_non_unique(node_impl_base_pointer pos):
-      first(pos),last(node_impl_base_pointer(0)){}
-
-    operator const node_impl_base_pointer&()const{return this->first;}
-
-    node_impl_base_pointer first,last;
-  };
-
-  typedef typename mpl::if_<
-    is_same<Category,hashed_unique_tag>,
-    node_impl_base_pointer,
-    link_info_non_unique
-  >::type                                link_info;
-
-  bool link_point(value_param_type v,link_info& pos)
-  {
-    return link_point(v,pos,Category());
-  }
-
-  bool link_point(
-    value_param_type v,node_impl_base_pointer& pos,hashed_unique_tag)
-  {
-    for(node_impl_pointer x=pos->prior();x!=node_impl_pointer(0);
-        x=node_alg::after_local(x)){
-      if(eq_(key(v),key(node_type::from_impl(x)->value()))){
-        pos=node_impl_type::base_pointer_from(x);
-        return false;
-      }
-    }
-    return true;
-  }
-
-  bool link_point(
-    value_param_type v,link_info_non_unique& pos,hashed_non_unique_tag)
-  {
-    for(node_impl_pointer x=pos.first->prior();x!=node_impl_pointer(0);
-        x=node_alg::next_to_inspect(x)){
-      if(eq_(key(v),key(node_type::from_impl(x)->value()))){
-        pos.first=node_impl_type::base_pointer_from(x);
-        pos.last=node_impl_type::base_pointer_from(last_of_range(x));
-        return true;
-      }
-    }
-    return true;
-  }
-
-  node_impl_pointer last_of_range(node_impl_pointer x)const
-  {
-    return last_of_range(x,Category());
-  }
-
-  node_impl_pointer last_of_range(node_impl_pointer x,hashed_unique_tag)const
-  {
-    return x;
-  }
-
-  node_impl_pointer last_of_range(
-    node_impl_pointer x,hashed_non_unique_tag)const
-  {
-    node_impl_base_pointer y=x->next();
-    node_impl_pointer      z=y->prior();
-    if(z==x){                      /* range of size 1 or 2 */
-      node_impl_pointer yy=node_impl_type::pointer_from(y);
-      return
-        eq_(
-          key(node_type::from_impl(x)->value()),
-          key(node_type::from_impl(yy)->value()))?yy:x;
-    }
-    else if(z->prior()==x)               /* last of bucket */
-      return x;
-    else                                /* group of size>2 */        
-      return z;
-  }
-
-  node_impl_pointer end_of_range(node_impl_pointer x)const
-  {
-    return end_of_range(x,Category());
-  }
-
-  node_impl_pointer end_of_range(node_impl_pointer x,hashed_unique_tag)const
-  {
-    return node_alg::after(last_of_range(x));
-  }
-
-  node_impl_pointer end_of_range(
-    node_impl_pointer x,hashed_non_unique_tag)const
-  {
-    node_impl_base_pointer y=x->next();
-    node_impl_pointer      z=y->prior();
-    if(z==x){                      /* range of size 1 or 2 */
-      node_impl_pointer yy=node_impl_type::pointer_from(y);
-      if(!eq_(
-           key(node_type::from_impl(x)->value()),
-           key(node_type::from_impl(yy)->value())))yy=x;
-      return yy->next()->prior()==yy?
-               node_impl_type::pointer_from(yy->next()):
-               yy->next()->prior();
-    }
-    else if(z->prior()==x)               /* last of bucket */
-      return z;
-    else                                /* group of size>2 */        
-      return z->next()->prior()==z?
-               node_impl_type::pointer_from(z->next()):
-               z->next()->prior();
-  }
-
-  void link(node_type* x,const link_info& pos)
-  {
-    link(x,pos,Category());
-  }
-
-  void link(node_type* x,node_impl_base_pointer pos,hashed_unique_tag)
-  {
-    node_alg::link(x->impl(),pos,header()->impl());
-  }
-
-  void link(node_type* x,const link_info_non_unique& pos,hashed_non_unique_tag)
-  {
-    if(pos.last==node_impl_base_pointer(0)){
-      node_alg::link(x->impl(),pos.first,header()->impl());
-    }
-    else{
-      node_alg::link(
-        x->impl(),
-        node_impl_type::pointer_from(pos.first),
-        node_impl_type::pointer_from(pos.last));
-    }
-  }
-
-  void unlink(node_type* x)
-  {
-    node_alg::unlink(x->impl());
-  }
-
-  typedef typename node_alg::unlink_undo unlink_undo;
-
-  void unlink(node_type* x,unlink_undo& undo)
-  {
-    node_alg::unlink(x->impl(),undo);
-  }
-
-  void calculate_max_load()
-  {
-    float fml=static_cast<float>(mlf*static_cast<float>(bucket_count()));
-    max_load=(std::numeric_limits<size_type>::max)();
-    if(max_load>fml)max_load=static_cast<size_type>(fml);
-  }
-
-  void reserve_for_insert(size_type n)
-  {
-    if(n>max_load){
-      size_type bc =(std::numeric_limits<size_type>::max)();
-      float     fbc=static_cast<float>(1+static_cast<double>(n)/mlf);
-      if(bc>fbc)bc =static_cast<size_type>(fbc);
-      unchecked_rehash(bc);
-    }
-  }
-
-  void unchecked_rehash(size_type n){unchecked_rehash(n,Category());}
-
-  void unchecked_rehash(size_type n,hashed_unique_tag)
-  {
-    node_impl_type    cpy_end_node;
-    node_impl_pointer cpy_end=node_impl_pointer(&cpy_end_node),
-                      end_=header()->impl();
-    bucket_array_type buckets_cpy(get_allocator(),cpy_end,n);
-
-    if(size()!=0){
-      auto_space<
-        std::size_t,allocator_type>       hashes(get_allocator(),size());
-      auto_space<
-        node_impl_pointer,allocator_type> node_ptrs(get_allocator(),size());
-      std::size_t                         i=0,size_=size();
-      bool                                within_bucket=false;
-      BOOST_TRY{
-        for(;i!=size_;++i){
-          node_impl_pointer x=end_->prior();
-
-          /* only this can possibly throw */
-          std::size_t h=hash_(key(node_type::from_impl(x)->value()));
-
-          hashes.data()[i]=h;
-          node_ptrs.data()[i]=x;
-          within_bucket=!node_alg::unlink_last(end_);
-          node_alg::link(x,buckets_cpy.at(buckets_cpy.position(h)),cpy_end);
-        }
-      }
-      BOOST_CATCH(...){
-        if(i!=0){
-          std::size_t prev_buc=buckets.position(hashes.data()[i-1]);
-          if(!within_bucket)prev_buc=~prev_buc;
-
-          for(std::size_t j=i;j--;){
-            std::size_t       buc=buckets.position(hashes.data()[j]);
-            node_impl_pointer x=node_ptrs.data()[j];
-            if(buc==prev_buc)node_alg::append(x,end_);
-            else node_alg::link(x,buckets.at(buc),end_);
-            prev_buc=buc;
-          }
-        }
-        BOOST_RETHROW;
-      }
-      BOOST_CATCH_END
-    }
-
-    end_->prior()=cpy_end->prior()!=cpy_end?cpy_end->prior():end_;
-    end_->next()=cpy_end->next();
-    end_->prior()->next()->prior()=end_->next()->prior()->prior()=end_;
-    buckets.swap(buckets_cpy);
-    calculate_max_load();
-  }
-
-  void unchecked_rehash(size_type n,hashed_non_unique_tag)
-  {
-    node_impl_type    cpy_end_node;
-    node_impl_pointer cpy_end=node_impl_pointer(&cpy_end_node),
-                      end_=header()->impl();
-    bucket_array_type buckets_cpy(get_allocator(),cpy_end,n);
-
-    if(size()!=0){
-      auto_space<
-        std::size_t,allocator_type>       hashes(get_allocator(),size());
-      auto_space<
-        node_impl_pointer,allocator_type> node_ptrs(get_allocator(),size());
-      std::size_t                         i=0;
-      bool                                within_bucket=false;
-      BOOST_TRY{
-        for(;;++i){
-          node_impl_pointer x=end_->prior();
-          if(x==end_)break;
-
-          /* only this can possibly throw */
-          std::size_t h=hash_(key(node_type::from_impl(x)->value()));
-
-          hashes.data()[i]=h;
-          node_ptrs.data()[i]=x;
-          std::pair<node_impl_pointer,bool> p=
-            node_alg::unlink_last_group(end_);
-          node_alg::link_range(
-            p.first,x,buckets_cpy.at(buckets_cpy.position(h)),cpy_end);
-          within_bucket=!(p.second);
-        }
-      }
-      BOOST_CATCH(...){
-        if(i!=0){
-          std::size_t prev_buc=buckets.position(hashes.data()[i-1]);
-          if(!within_bucket)prev_buc=~prev_buc;
-
-          for(std::size_t j=i;j--;){
-            std::size_t       buc=buckets.position(hashes.data()[j]);
-            node_impl_pointer x=node_ptrs.data()[j],
-                              y=
-              x->prior()->next()!=node_impl_type::base_pointer_from(x)&&
-              x->prior()->next()->prior()!=x?
-                node_impl_type::pointer_from(x->prior()->next()):x;
-            node_alg::unlink_range(y,x);
-            if(buc==prev_buc)node_alg::append_range(y,x,end_);
-            else node_alg::link_range(y,x,buckets.at(buc),end_);
-            prev_buc=buc;
-          }
-        }
-        BOOST_RETHROW;
-      }
-      BOOST_CATCH_END
-    }
-
-    end_->prior()=cpy_end->prior()!=cpy_end?cpy_end->prior():end_;
-    end_->next()=cpy_end->next();
-    end_->prior()->next()->prior()=end_->next()->prior()->prior()=end_;
-    buckets.swap(buckets_cpy);
-    calculate_max_load();
-  }
-
-  bool in_place(node_impl_pointer x,key_param_type k,std::size_t buc)const
-  {
-    return in_place(x,k,buc,Category());
-  }
-
-  bool in_place(
-    node_impl_pointer x,key_param_type k,std::size_t buc,
-    hashed_unique_tag)const
-  {
-    bool found=false;
-    for(node_impl_pointer y=buckets.at(buc)->prior();
-        y!=node_impl_pointer(0);y=node_alg::after_local(y)){
-      if(y==x)found=true;
-      else if(eq_(k,key(node_type::from_impl(y)->value())))return false;
-    }
-    return found;
-  }
-
-  bool in_place(
-    node_impl_pointer x,key_param_type k,std::size_t buc,
-    hashed_non_unique_tag)const
-  {
-    bool found=false;
-    int  range_size=0;
-    for(node_impl_pointer y=buckets.at(buc)->prior();y!=node_impl_pointer(0);){
-      if(node_alg::is_first_of_group(y)){ /* group of 3 or more */
-        if(y==x){
-          /* in place <-> equal to some other member of the group */
-          return eq_(
-            k,
-            key(node_type::from_impl(
-              node_impl_type::pointer_from(y->next()))->value()));
-        }
-        else{
-          node_impl_pointer z=
-            node_alg::after_local(y->next()->prior()); /* end of range */
-          if(eq_(k,key(node_type::from_impl(y)->value()))){
-            if(found)return false; /* x lies outside */
-            do{
-              if(y==x)return true;
-              y=node_alg::after_local(y);
-            }while(y!=z);
-            return false; /* x not found */
-          }
-          else{
-            if(range_size==1&&!found)return false;
-            if(range_size==2)return found;
-            range_size=0;
-            y=z; /* skip range (and potentially x, too, which is fine) */
-          }
-        }
-      }
-      else{ /* group of 1 or 2 */
-        if(y==x){
-          if(range_size==1)return true;
-          range_size=1;
-          found=true;
-        }
-        else if(eq_(k,key(node_type::from_impl(y)->value()))){
-          if(range_size==0&&found)return false;
-          if(range_size==1&&!found)return false;
-          if(range_size==2)return false;
-          ++range_size;
-        }
-        else{
-          if(range_size==1&&!found)return false;
-          if(range_size==2)return found;
-          range_size=0;
-        }
-        y=node_alg::after_local(y);
-      }
-    }
-    return found;
-  }
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-  void detach_iterators(node_type* x)
-  {
-    iterator it=make_iterator(x);
-    safe_mode::detach_equivalent_iterators(it);
-  }
-#endif
-
-  template<BOOST_MULTI_INDEX_TEMPLATE_PARAM_PACK>
-  std::pair<iterator,bool> emplace_impl(BOOST_MULTI_INDEX_FUNCTION_PARAM_PACK)
-  {
-    BOOST_MULTI_INDEX_HASHED_INDEX_CHECK_INVARIANT;
-    std::pair<final_node_type*,bool>p=
-      this->final_emplace_(BOOST_MULTI_INDEX_FORWARD_PARAM_PACK);
-    return std::pair<iterator,bool>(make_iterator(p.first),p.second);
-  }
-
-  template<BOOST_MULTI_INDEX_TEMPLATE_PARAM_PACK>
-  iterator emplace_hint_impl(
-    iterator position,BOOST_MULTI_INDEX_FUNCTION_PARAM_PACK)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
-    BOOST_MULTI_INDEX_HASHED_INDEX_CHECK_INVARIANT;
-    std::pair<final_node_type*,bool>p=
-      this->final_emplace_hint_(
-        static_cast<final_node_type*>(position.get_node()),
-        BOOST_MULTI_INDEX_FORWARD_PARAM_PACK);
-    return make_iterator(p.first);
-  }
-
-  template<
-    typename CompatibleHash,typename CompatiblePred
-  >
-  iterator find(
-    const key_type& k,
-    const CompatibleHash& hash,const CompatiblePred& eq,mpl::true_)const
-  {
-    return find(k,hash,eq,mpl::false_());
-  }
-
-  template<
-    typename CompatibleKey,typename CompatibleHash,typename CompatiblePred
-  >
-  iterator find(
-    const CompatibleKey& k,
-    const CompatibleHash& hash,const CompatiblePred& eq,mpl::false_)const
-  {
-    std::size_t buc=buckets.position(hash(k));
-    for(node_impl_pointer x=buckets.at(buc)->prior();
-        x!=node_impl_pointer(0);x=node_alg::next_to_inspect(x)){
-      if(eq(k,key(node_type::from_impl(x)->value()))){
-        return make_iterator(node_type::from_impl(x));
-      }
-    }
-    return end();
-  }
-
-  template<
-    typename CompatibleHash,typename CompatiblePred
-  >
-  size_type count(
-    const key_type& k,
-    const CompatibleHash& hash,const CompatiblePred& eq,mpl::true_)const
-  {
-    return count(k,hash,eq,mpl::false_());
-  }
-
-  template<
-    typename CompatibleKey,typename CompatibleHash,typename CompatiblePred
-  >
-  size_type count(
-    const CompatibleKey& k,
-    const CompatibleHash& hash,const CompatiblePred& eq,mpl::false_)const
-  {
-    std::size_t buc=buckets.position(hash(k));
-    for(node_impl_pointer x=buckets.at(buc)->prior();
-        x!=node_impl_pointer(0);x=node_alg::next_to_inspect(x)){
-      if(eq(k,key(node_type::from_impl(x)->value()))){
-        size_type         res=0;
-        node_impl_pointer y=end_of_range(x);
-        do{
-          ++res;
-          x=node_alg::after(x);
-        }while(x!=y);
-        return res;
-      }
-    }
-    return 0;
-  }
-
-  template<
-    typename CompatibleHash,typename CompatiblePred
-  >
-  std::pair<iterator,iterator> equal_range(
-    const key_type& k,
-    const CompatibleHash& hash,const CompatiblePred& eq,mpl::true_)const
-  {
-    return equal_range(k,hash,eq,mpl::false_());
-  }
-
-  template<
-    typename CompatibleKey,typename CompatibleHash,typename CompatiblePred
-  >
-  std::pair<iterator,iterator> equal_range(
-    const CompatibleKey& k,
-    const CompatibleHash& hash,const CompatiblePred& eq,mpl::false_)const
-  {
-    std::size_t buc=buckets.position(hash(k));
-    for(node_impl_pointer x=buckets.at(buc)->prior();
-        x!=node_impl_pointer(0);x=node_alg::next_to_inspect(x)){
-      if(eq(k,key(node_type::from_impl(x)->value()))){
-        return std::pair<iterator,iterator>(
-          make_iterator(node_type::from_impl(x)),
-          make_iterator(node_type::from_impl(end_of_range(x))));
-      }
-    }
-    return std::pair<iterator,iterator>(end(),end());
-  }
-
-  key_from_value               key;
-  hasher                       hash_;
-  key_equal                    eq_;
-  bucket_array_type            buckets;
-  float                        mlf;
-  size_type                    max_load;
-      
-#if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING)&&\
-    BOOST_WORKAROUND(__MWERKS__,<=0x3003)
-#pragma parse_mfunc_templ reset
-#endif
-};
-
-/* comparison */
-
-template<
-  typename KeyFromValue,typename Hash,typename Pred,
-  typename SuperMeta,typename TagList,typename Category
->
-bool operator==(
-  const hashed_index<KeyFromValue,Hash,Pred,SuperMeta,TagList,Category>& x,
-  const hashed_index<KeyFromValue,Hash,Pred,SuperMeta,TagList,Category>& y)
-{
-  return x.equals(y);
-}
-
-template<
-  typename KeyFromValue,typename Hash,typename Pred,
-  typename SuperMeta,typename TagList,typename Category
->
-bool operator!=(
-  const hashed_index<KeyFromValue,Hash,Pred,SuperMeta,TagList,Category>& x,
-  const hashed_index<KeyFromValue,Hash,Pred,SuperMeta,TagList,Category>& y)
-{
-  return !(x==y);
-}
-
-/*  specialized algorithms */
-
-template<
-  typename KeyFromValue,typename Hash,typename Pred,
-  typename SuperMeta,typename TagList,typename Category
->
-void swap(
-  hashed_index<KeyFromValue,Hash,Pred,SuperMeta,TagList,Category>& x,
-  hashed_index<KeyFromValue,Hash,Pred,SuperMeta,TagList,Category>& y)
-{
-  x.swap(y);
-}
-
-} /* namespace multi_index::detail */
-
-/* hashed index specifiers */
-
-template<typename Arg1,typename Arg2,typename Arg3,typename Arg4>
-struct hashed_unique
-{
-  typedef typename detail::hashed_index_args<
-    Arg1,Arg2,Arg3,Arg4>                           index_args;
-  typedef typename index_args::tag_list_type::type tag_list_type;
-  typedef typename index_args::key_from_value_type key_from_value_type;
-  typedef typename index_args::hash_type           hash_type;
-  typedef typename index_args::pred_type           pred_type;
-
-  template<typename Super>
-  struct node_class
-  {
-    typedef detail::hashed_index_node<Super,detail::hashed_unique_tag> type;
-  };
-
-  template<typename SuperMeta>
-  struct index_class
-  {
-    typedef detail::hashed_index<
-      key_from_value_type,hash_type,pred_type,
-      SuperMeta,tag_list_type,detail::hashed_unique_tag> type;
-  };
-};
-
-template<typename Arg1,typename Arg2,typename Arg3,typename Arg4>
-struct hashed_non_unique
-{
-  typedef typename detail::hashed_index_args<
-    Arg1,Arg2,Arg3,Arg4>                           index_args;
-  typedef typename index_args::tag_list_type::type tag_list_type;
-  typedef typename index_args::key_from_value_type key_from_value_type;
-  typedef typename index_args::hash_type           hash_type;
-  typedef typename index_args::pred_type           pred_type;
-
-  template<typename Super>
-  struct node_class
-  {
-    typedef detail::hashed_index_node<
-      Super,detail::hashed_non_unique_tag> type;
-  };
-
-  template<typename SuperMeta>
-  struct index_class
-  {
-    typedef detail::hashed_index<
-      key_from_value_type,hash_type,pred_type,
-      SuperMeta,tag_list_type,detail::hashed_non_unique_tag> type;
-  };
-};
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-/* Boost.Foreach compatibility */
-
-template<
-  typename KeyFromValue,typename Hash,typename Pred,
-  typename SuperMeta,typename TagList,typename Category
->
-inline boost::mpl::true_* boost_foreach_is_noncopyable(
-  boost::multi_index::detail::hashed_index<
-    KeyFromValue,Hash,Pred,SuperMeta,TagList,Category>*&,
-  boost_foreach_argument_dependent_lookup_hack)
-{
-  return 0;
-}
-
-#undef BOOST_MULTI_INDEX_HASHED_INDEX_CHECK_INVARIANT
-#undef BOOST_MULTI_INDEX_HASHED_INDEX_CHECK_INVARIANT_OF
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/hashed_index_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/hashed_index_fwd.hpp
deleted file mode 100644
index d77e36c321b..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/hashed_index_fwd.hpp
+++ /dev/null
@@ -1,74 +0,0 @@
-/* Copyright 2003-2013 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_HASHED_INDEX_FWD_HPP
-#define BOOST_MULTI_INDEX_HASHED_INDEX_FWD_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/multi_index/detail/hash_index_args.hpp>
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-template<
-  typename KeyFromValue,typename Hash,typename Pred,
-  typename SuperMeta,typename TagList,typename Category
->
-class hashed_index;
-
-template<
-  typename KeyFromValue,typename Hash,typename Pred,
-  typename SuperMeta,typename TagList,typename Category
->
-bool operator==(
-  const hashed_index<KeyFromValue,Hash,Pred,SuperMeta,TagList,Category>& x,
-  const hashed_index<KeyFromValue,Hash,Pred,SuperMeta,TagList,Category>& y);
-
-template<
-  typename KeyFromValue,typename Hash,typename Pred,
-  typename SuperMeta,typename TagList,typename Category
->
-bool operator!=(
-  const hashed_index<KeyFromValue,Hash,Pred,SuperMeta,TagList,Category>& x,
-  const hashed_index<KeyFromValue,Hash,Pred,SuperMeta,TagList,Category>& y);
-
-template<
-  typename KeyFromValue,typename Hash,typename Pred,
-  typename SuperMeta,typename TagList,typename Category
->
-void swap(
-  hashed_index<KeyFromValue,Hash,Pred,SuperMeta,TagList,Category>& x,
-  hashed_index<KeyFromValue,Hash,Pred,SuperMeta,TagList,Category>& y);
-
-} /* namespace multi_index::detail */
-
-/* hashed_index specifiers */
-
-template<
-  typename Arg1,typename Arg2=mpl::na,
-  typename Arg3=mpl::na,typename Arg4=mpl::na
->
-struct hashed_unique;
-
-template<
-  typename Arg1,typename Arg2=mpl::na,
-  typename Arg3=mpl::na,typename Arg4=mpl::na
->
-struct hashed_non_unique;
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/identity.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/identity.hpp
deleted file mode 100644
index 6c832ce1562..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/identity.hpp
+++ /dev/null
@@ -1,145 +0,0 @@
-/* Copyright 2003-2015 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_IDENTITY_HPP
-#define BOOST_MULTI_INDEX_IDENTITY_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp>
-#include <boost/detail/workaround.hpp>
-#include <boost/mpl/if.hpp>
-#include <boost/multi_index/identity_fwd.hpp>
-#include <boost/type_traits/is_const.hpp>
-#include <boost/type_traits/remove_const.hpp>
-#include <boost/utility/enable_if.hpp>
-
-#if !defined(BOOST_NO_SFINAE)
-#include <boost/type_traits/is_convertible.hpp>
-#endif
-
-namespace boost{
-
-template<class Type> class reference_wrapper; /* fwd decl. */
-
-namespace multi_index{
-
-namespace detail{
-
-/* identity is a do-nothing key extractor that returns the [const] Type&
- * object passed.
- * Additionally, identity is overloaded to support referece_wrappers
- * of Type and "chained pointers" to Type's. By chained pointer to Type we
- * mean a  type  P such that, given a p of type P
- *   *...n...*x is convertible to Type&, for some n>=1.
- * Examples of chained pointers are raw and smart pointers, iterators and
- * arbitrary combinations of these (vg. Type** or unique_ptr<Type*>.)
- */
-
-template<typename Type>
-struct const_identity_base
-{
-  typedef Type result_type;
-
-  template<typename ChainedPtr>
-
-#if !defined(BOOST_NO_SFINAE)
-  typename disable_if<is_convertible<const ChainedPtr&,Type&>,Type&>::type
-#else
-  Type&
-#endif 
-  
-  operator()(const ChainedPtr& x)const
-  {
-    return operator()(*x);
-  }
-
-  Type& operator()(Type& x)const
-  {
-    return x;
-  }
-
-  Type& operator()(const reference_wrapper<Type>& x)const
-  { 
-    return x.get();
-  }
-
-  Type& operator()(
-    const reference_wrapper<typename remove_const<Type>::type>& x
-
-#if BOOST_WORKAROUND(BOOST_MSVC,==1310)
-/* http://lists.boost.org/Archives/boost/2015/10/226135.php */
-    ,int=0
-#endif
-
-  )const
-  { 
-    return x.get();
-  }
-};
-
-template<typename Type>
-struct non_const_identity_base
-{
-  typedef Type result_type;
-
-  /* templatized for pointer-like types */
-  
-  template<typename ChainedPtr>
-
-#if !defined(BOOST_NO_SFINAE)
-  typename disable_if<
-    is_convertible<const ChainedPtr&,const Type&>,Type&>::type
-#else
-  Type&
-#endif 
-    
-  operator()(const ChainedPtr& x)const
-  {
-    return operator()(*x);
-  }
-
-  const Type& operator()(const Type& x)const
-  {
-    return x;
-  }
-
-  Type& operator()(Type& x)const
-  {
-    return x;
-  }
-
-  const Type& operator()(const reference_wrapper<const Type>& x)const
-  { 
-    return x.get();
-  }
-
-  Type& operator()(const reference_wrapper<Type>& x)const
-  { 
-    return x.get();
-  }
-};
-
-} /* namespace multi_index::detail */
-
-template<class Type>
-struct identity:
-  mpl::if_c<
-    is_const<Type>::value,
-    detail::const_identity_base<Type>,detail::non_const_identity_base<Type>
-  >::type
-{
-};
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/identity_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/identity_fwd.hpp
deleted file mode 100644
index af6bd55ef5f..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/identity_fwd.hpp
+++ /dev/null
@@ -1,26 +0,0 @@
-/* Copyright 2003-2013 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_IDENTITY_FWD_HPP
-#define BOOST_MULTI_INDEX_IDENTITY_FWD_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-namespace boost{
-
-namespace multi_index{
-
-template<class Type> struct identity;
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/indexed_by.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/indexed_by.hpp
deleted file mode 100644
index d2217e39166..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/indexed_by.hpp
+++ /dev/null
@@ -1,68 +0,0 @@
-/* Copyright 2003-2013 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_INDEXED_BY_HPP
-#define BOOST_MULTI_INDEX_INDEXED_BY_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <boost/mpl/vector.hpp>
-#include <boost/preprocessor/cat.hpp>
-#include <boost/preprocessor/control/expr_if.hpp>
-#include <boost/preprocessor/repetition/enum.hpp>
-#include <boost/preprocessor/repetition/enum_params.hpp> 
-
-/* An alias to mpl::vector used to hide MPL from the user.
- * indexed_by contains the index specifiers for instantiation
- * of a multi_index_container.
- */
-
-/* This user_definable macro limits the number of elements of an index list;
- * useful for shortening resulting symbol names (MSVC++ 6.0, for instance,
- * has problems coping with very long symbol names.)
- */
-
-#if !defined(BOOST_MULTI_INDEX_LIMIT_INDEXED_BY_SIZE)
-#define BOOST_MULTI_INDEX_LIMIT_INDEXED_BY_SIZE BOOST_MPL_LIMIT_VECTOR_SIZE
-#endif
-
-#if BOOST_MULTI_INDEX_LIMIT_INDEXED_BY_SIZE<BOOST_MPL_LIMIT_VECTOR_SIZE
-#define BOOST_MULTI_INDEX_INDEXED_BY_SIZE \
-  BOOST_MULTI_INDEX_LIMIT_INDEXED_BY_SIZE
-#else
-#define BOOST_MULTI_INDEX_INDEXED_BY_SIZE BOOST_MPL_LIMIT_VECTOR_SIZE
-#endif
-
-#define BOOST_MULTI_INDEX_INDEXED_BY_TEMPLATE_PARM(z,n,var) \
-  typename BOOST_PP_CAT(var,n) BOOST_PP_EXPR_IF(n,=mpl::na)
-
-namespace boost{
-
-namespace multi_index{
-
-template<
-  BOOST_PP_ENUM(
-    BOOST_MULTI_INDEX_INDEXED_BY_SIZE,
-    BOOST_MULTI_INDEX_INDEXED_BY_TEMPLATE_PARM,T)
->
-struct indexed_by:
-  mpl::vector<BOOST_PP_ENUM_PARAMS(BOOST_MULTI_INDEX_INDEXED_BY_SIZE,T)>
-{
-};
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#undef BOOST_MULTI_INDEX_INDEXED_BY_TEMPLATE_PARM
-#undef BOOST_MULTI_INDEX_INDEXED_BY_SIZE
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/key_extractors.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/key_extractors.hpp
deleted file mode 100644
index 60179ba2339..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/key_extractors.hpp
+++ /dev/null
@@ -1,22 +0,0 @@
-/* Copyright 2003-2013 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_KEY_EXTRACTORS_HPP
-#define BOOST_MULTI_INDEX_KEY_EXTRACTORS_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/multi_index/composite_key.hpp>
-#include <boost/multi_index/identity.hpp>
-#include <boost/multi_index/global_fun.hpp>
-#include <boost/multi_index/member.hpp>
-#include <boost/multi_index/mem_fun.hpp>
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/mem_fun.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/mem_fun.hpp
deleted file mode 100644
index 111c386c5f5..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/mem_fun.hpp
+++ /dev/null
@@ -1,205 +0,0 @@
-/* Copyright 2003-2015 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_MEM_FUN_HPP
-#define BOOST_MULTI_INDEX_MEM_FUN_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <boost/mpl/if.hpp>
-#include <boost/type_traits/remove_reference.hpp>
-#include <boost/utility/enable_if.hpp>
-
-#if !defined(BOOST_NO_SFINAE)
-#include <boost/type_traits/is_convertible.hpp>
-#endif
-
-namespace boost{
-
-template<class T> class reference_wrapper; /* fwd decl. */
-
-namespace multi_index{
-
-/* mem_fun implements a read-only key extractor based on a given non-const
- * member function of a class.
- * const_mem_fun does the same for const member functions.
- * Additionally, mem_fun  and const_mem_fun are overloaded to support
- * referece_wrappers of T and "chained pointers" to T's. By chained pointer
- * to T we  mean a type P such that, given a p of Type P
- *   *...n...*x is convertible to T&, for some n>=1.
- * Examples of chained pointers are raw and smart pointers, iterators and
- * arbitrary combinations of these (vg. T** or unique_ptr<T*>.)
- */
-
-template<class Class,typename Type,Type (Class::*PtrToMemberFunction)()const>
-struct const_mem_fun
-{
-  typedef typename remove_reference<Type>::type result_type;
-
-  template<typename ChainedPtr>
-
-#if !defined(BOOST_NO_SFINAE)
-  typename disable_if<
-    is_convertible<const ChainedPtr&,const Class&>,Type>::type
-#else
-  Type
-#endif
-
-  operator()(const ChainedPtr& x)const
-  {
-    return operator()(*x);
-  }
-
-  Type operator()(const Class& x)const
-  {
-    return (x.*PtrToMemberFunction)();
-  }
-
-  Type operator()(const reference_wrapper<const Class>& x)const
-  { 
-    return operator()(x.get());
-  }
-
-  Type operator()(const reference_wrapper<Class>& x)const
-  { 
-    return operator()(x.get());
-  }
-};
-
-template<class Class,typename Type,Type (Class::*PtrToMemberFunction)()>
-struct mem_fun
-{
-  typedef typename remove_reference<Type>::type result_type;
-
-  template<typename ChainedPtr>
-
-#if !defined(BOOST_NO_SFINAE)
-  typename disable_if<
-    is_convertible<ChainedPtr&,Class&>,Type>::type
-#else
-  Type
-#endif
-
-  operator()(const ChainedPtr& x)const
-  {
-    return operator()(*x);
-  }
-
-  Type operator()(Class& x)const
-  {
-    return (x.*PtrToMemberFunction)();
-  }
-
-  Type operator()(const reference_wrapper<Class>& x)const
-  { 
-    return operator()(x.get());
-  }
-};
-
-/* MSVC++ 6.0 has problems with const member functions as non-type template
- * parameters, somehow it takes them as non-const. const_mem_fun_explicit
- * workarounds this deficiency by accepting an extra type parameter that
- * specifies the signature of the member function. The workaround was found at:
- *   Daniel, C.:"Re: weird typedef problem in VC",
- *   news:microsoft.public.vc.language, 21st nov 2002, 
- *   http://groups.google.com/groups?
- *     hl=en&lr=&ie=UTF-8&selm=ukwvg3O0BHA.1512%40tkmsftngp05
- *
- * MSVC++ 6.0 support has been dropped and [const_]mem_fun_explicit is
- * deprecated.
- */
-
-template<
-  class Class,typename Type,
-  typename PtrToMemberFunctionType,PtrToMemberFunctionType PtrToMemberFunction>
-struct const_mem_fun_explicit
-{
-  typedef typename remove_reference<Type>::type result_type;
-
-  template<typename ChainedPtr>
-
-#if !defined(BOOST_NO_SFINAE)
-  typename disable_if<
-    is_convertible<const ChainedPtr&,const Class&>,Type>::type
-#else
-  Type
-#endif
-
-  operator()(const ChainedPtr& x)const
-  {
-    return operator()(*x);
-  }
-
-  Type operator()(const Class& x)const
-  {
-    return (x.*PtrToMemberFunction)();
-  }
-
-  Type operator()(const reference_wrapper<const Class>& x)const
-  { 
-    return operator()(x.get());
-  }
-
-  Type operator()(const reference_wrapper<Class>& x)const
-  { 
-    return operator()(x.get());
-  }
-};
-
-template<
-  class Class,typename Type,
-  typename PtrToMemberFunctionType,PtrToMemberFunctionType PtrToMemberFunction>
-struct mem_fun_explicit
-{
-  typedef typename remove_reference<Type>::type result_type;
-
-  template<typename ChainedPtr>
-
-#if !defined(BOOST_NO_SFINAE)
-  typename disable_if<
-    is_convertible<ChainedPtr&,Class&>,Type>::type
-#else
-  Type
-#endif
-
-  operator()(const ChainedPtr& x)const
-  {
-    return operator()(*x);
-  }
-
-  Type operator()(Class& x)const
-  {
-    return (x.*PtrToMemberFunction)();
-  }
-
-  Type operator()(const reference_wrapper<Class>& x)const
-  { 
-    return operator()(x.get());
-  }
-};
-
-/* BOOST_MULTI_INDEX_CONST_MEM_FUN and BOOST_MULTI_INDEX_MEM_FUN used to
- * resolve to [const_]mem_fun_explicit for MSVC++ 6.0 and to
- * [const_]mem_fun otherwise. Support for this compiler having been dropped,
- * they are now just wrappers over [const_]mem_fun kept for backwards-
- * compatibility reasons.
- */
-
-#define BOOST_MULTI_INDEX_CONST_MEM_FUN(Class,Type,MemberFunName) \
-::boost::multi_index::const_mem_fun< Class,Type,&Class::MemberFunName >
-#define BOOST_MULTI_INDEX_MEM_FUN(Class,Type,MemberFunName) \
-::boost::multi_index::mem_fun< Class,Type,&Class::MemberFunName >
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/member.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/member.hpp
deleted file mode 100644
index a8e645074a2..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/member.hpp
+++ /dev/null
@@ -1,262 +0,0 @@
-/* Copyright 2003-2015 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_MEMBER_HPP
-#define BOOST_MULTI_INDEX_MEMBER_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <boost/mpl/if.hpp>
-#include <boost/type_traits/is_const.hpp>
-#include <boost/utility/enable_if.hpp>
-#include <cstddef>
-
-#if !defined(BOOST_NO_SFINAE)
-#include <boost/type_traits/is_convertible.hpp>
-#endif
-
-namespace boost{
-
-template<class T> class reference_wrapper; /* fwd decl. */
-
-namespace multi_index{
-
-namespace detail{
-
-/* member is a read/write key extractor for accessing a given
- * member of a class.
- * Additionally, member is overloaded to support referece_wrappers
- * of T and "chained pointers" to T's. By chained pointer to T we mean
- * a type P  such that, given a p of Type P
- *   *...n...*x is convertible to T&, for some n>=1.
- * Examples of chained pointers are raw and smart pointers, iterators and
- * arbitrary combinations of these (vg. T** or unique_ptr<T*>.)
- */
-
-template<class Class,typename Type,Type Class::*PtrToMember>
-struct const_member_base
-{
-  typedef Type result_type;
-
-  template<typename ChainedPtr>
-
-#if !defined(BOOST_NO_SFINAE)
-  typename disable_if<
-    is_convertible<const ChainedPtr&,const Class&>,Type&>::type
-#else
-  Type&
-#endif
-  
-  operator()(const ChainedPtr& x)const
-  {
-    return operator()(*x);
-  }
-
-  Type& operator()(const Class& x)const
-  {
-    return x.*PtrToMember;
-  }
-
-  Type& operator()(const reference_wrapper<const Class>& x)const
-  {
-    return operator()(x.get());
-  }
-
-  Type& operator()(const reference_wrapper<Class>& x)const
-  { 
-    return operator()(x.get());
-  }
-};
-
-template<class Class,typename Type,Type Class::*PtrToMember>
-struct non_const_member_base
-{
-  typedef Type result_type;
-
-  template<typename ChainedPtr>
-
-#if !defined(BOOST_NO_SFINAE)
-  typename disable_if<
-    is_convertible<const ChainedPtr&,const Class&>,Type&>::type
-#else
-  Type&
-#endif
-
-  operator()(const ChainedPtr& x)const
-  {
-    return operator()(*x);
-  }
-
-  const Type& operator()(const Class& x)const
-  {
-    return x.*PtrToMember;
-  }
-
-  Type& operator()(Class& x)const
-  { 
-    return x.*PtrToMember;
-  }
-
-  const Type& operator()(const reference_wrapper<const Class>& x)const
-  {
-    return operator()(x.get());
-  }
-
-  Type& operator()(const reference_wrapper<Class>& x)const
-  { 
-    return operator()(x.get());
-  }
-};
-
-} /* namespace multi_index::detail */
-
-template<class Class,typename Type,Type Class::*PtrToMember>
-struct member:
-  mpl::if_c<
-    is_const<Type>::value,
-    detail::const_member_base<Class,Type,PtrToMember>,
-    detail::non_const_member_base<Class,Type,PtrToMember>
-  >::type
-{
-};
-
-namespace detail{
-
-/* MSVC++ 6.0 does not support properly pointers to members as
- * non-type template arguments, as reported in
- *   http://support.microsoft.com/default.aspx?scid=kb;EN-US;249045
- * A similar problem (though not identical) is shown by MSVC++ 7.0.
- * We provide an alternative to member<> accepting offsets instead
- * of pointers to members. This happens to work even for non-POD
- * types (although the standard forbids use of offsetof on these),
- * so it serves as a workaround in this compiler for all practical
- * purposes.
- * Surprisingly enough, other compilers, like Intel C++ 7.0/7.1 and
- * Visual Age 6.0, have similar bugs. This replacement of member<>
- * can be used for them too.
- *
- * Support for such old compilers is dropped and
- * [non_]const_member_offset_base is deprecated.
- */
-
-template<class Class,typename Type,std::size_t OffsetOfMember>
-struct const_member_offset_base
-{
-  typedef Type result_type;
-
-  template<typename ChainedPtr>
-
-#if !defined(BOOST_NO_SFINAE)
-  typename disable_if<
-    is_convertible<const ChainedPtr&,const Class&>,Type&>::type
-#else
-  Type&
-#endif 
-    
-  operator()(const ChainedPtr& x)const
-  {
-    return operator()(*x);
-  }
-
-  Type& operator()(const Class& x)const
-  {
-    return *static_cast<const Type*>(
-      static_cast<const void*>(
-        static_cast<const char*>(
-          static_cast<const void *>(&x))+OffsetOfMember));
-  }
-
-  Type& operator()(const reference_wrapper<const Class>& x)const
-  {
-    return operator()(x.get());
-  }
-
-  Type& operator()(const reference_wrapper<Class>& x)const
-  {
-    return operator()(x.get());
-  }
-};
-
-template<class Class,typename Type,std::size_t OffsetOfMember>
-struct non_const_member_offset_base
-{
-  typedef Type result_type;
-
-  template<typename ChainedPtr>
-
-#if !defined(BOOST_NO_SFINAE)
-  typename disable_if<
-    is_convertible<const ChainedPtr&,const Class&>,Type&>::type
-#else
-  Type&
-#endif 
-  
-  operator()(const ChainedPtr& x)const
-  {
-    return operator()(*x);
-  }
-
-  const Type& operator()(const Class& x)const
-  {
-    return *static_cast<const Type*>(
-      static_cast<const void*>(
-        static_cast<const char*>(
-          static_cast<const void *>(&x))+OffsetOfMember));
-  }
-
-  Type& operator()(Class& x)const
-  { 
-    return *static_cast<Type*>(
-      static_cast<void*>(
-        static_cast<char*>(static_cast<void *>(&x))+OffsetOfMember));
-  }
-
-  const Type& operator()(const reference_wrapper<const Class>& x)const
-  {
-    return operator()(x.get());
-  }
-
-  Type& operator()(const reference_wrapper<Class>& x)const
-  {
-    return operator()(x.get());
-  }
-};
-
-} /* namespace multi_index::detail */
-
-template<class Class,typename Type,std::size_t OffsetOfMember>
-struct member_offset:
-  mpl::if_c<
-    is_const<Type>::value,
-    detail::const_member_offset_base<Class,Type,OffsetOfMember>,
-    detail::non_const_member_offset_base<Class,Type,OffsetOfMember>
-  >::type
-{
-};
-
-/* BOOST_MULTI_INDEX_MEMBER resolves to member in the normal cases,
- * and to member_offset as a workaround in those defective compilers for
- * which BOOST_NO_POINTER_TO_MEMBER_TEMPLATE_PARAMETERS is defined.
- */
-
-#if defined(BOOST_NO_POINTER_TO_MEMBER_TEMPLATE_PARAMETERS)
-#define BOOST_MULTI_INDEX_MEMBER(Class,Type,MemberName) \
-::boost::multi_index::member_offset< Class,Type,offsetof(Class,MemberName) >
-#else
-#define BOOST_MULTI_INDEX_MEMBER(Class,Type,MemberName) \
-::boost::multi_index::member< Class,Type,&Class::MemberName >
-#endif
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/ordered_index.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/ordered_index.hpp
deleted file mode 100644
index 5bcd69de8c9..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/ordered_index.hpp
+++ /dev/null
@@ -1,114 +0,0 @@
-/* Copyright 2003-2015 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_ORDERED_INDEX_HPP
-#define BOOST_MULTI_INDEX_ORDERED_INDEX_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <boost/multi_index/detail/ord_index_impl.hpp>
-#include <boost/multi_index/ordered_index_fwd.hpp>
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-/* no augment policy for plain ordered indices */
-
-struct null_augment_policy
-{
-  template<typename OrderedIndexImpl>
-  struct augmented_interface
-  {
-    typedef OrderedIndexImpl type;
-  };
-
-  template<typename OrderedIndexNodeImpl>
-  struct augmented_node
-  {
-    typedef OrderedIndexNodeImpl type;
-  };
-
-  template<typename Pointer> static void add(Pointer,Pointer){}
-  template<typename Pointer> static void remove(Pointer,Pointer){}
-  template<typename Pointer> static void copy(Pointer,Pointer){}
-  template<typename Pointer> static void rotate_left(Pointer,Pointer){}
-  template<typename Pointer> static void rotate_right(Pointer,Pointer){}
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING)
-  /* invariant stuff */
-
-  template<typename Pointer> static bool invariant(Pointer){return true;}
-
-#endif
-};
-
-} /* namespace multi_index::detail */
-
-/* ordered_index specifiers */
-
-template<typename Arg1,typename Arg2,typename Arg3>
-struct ordered_unique
-{
-  typedef typename detail::ordered_index_args<
-    Arg1,Arg2,Arg3>                                index_args;
-  typedef typename index_args::tag_list_type::type tag_list_type;
-  typedef typename index_args::key_from_value_type key_from_value_type;
-  typedef typename index_args::compare_type        compare_type;
-
-  template<typename Super>
-  struct node_class
-  {
-    typedef detail::ordered_index_node<detail::null_augment_policy,Super> type;
-  };
-
-  template<typename SuperMeta>
-  struct index_class
-  {
-    typedef detail::ordered_index<
-      key_from_value_type,compare_type,
-      SuperMeta,tag_list_type,detail::ordered_unique_tag,
-      detail::null_augment_policy>                        type;
-  };
-};
-
-template<typename Arg1,typename Arg2,typename Arg3>
-struct ordered_non_unique
-{
-  typedef detail::ordered_index_args<
-    Arg1,Arg2,Arg3>                                index_args;
-  typedef typename index_args::tag_list_type::type tag_list_type;
-  typedef typename index_args::key_from_value_type key_from_value_type;
-  typedef typename index_args::compare_type        compare_type;
-
-  template<typename Super>
-  struct node_class
-  {
-    typedef detail::ordered_index_node<detail::null_augment_policy,Super> type;
-  };
-
-  template<typename SuperMeta>
-  struct index_class
-  {
-    typedef detail::ordered_index<
-      key_from_value_type,compare_type,
-      SuperMeta,tag_list_type,detail::ordered_non_unique_tag,
-      detail::null_augment_policy>                            type;
-  };
-};
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/ordered_index_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/ordered_index_fwd.hpp
deleted file mode 100644
index fe44aaf860d..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/ordered_index_fwd.hpp
+++ /dev/null
@@ -1,35 +0,0 @@
-/* Copyright 2003-2015 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_ORDERED_INDEX_FWD_HPP
-#define BOOST_MULTI_INDEX_ORDERED_INDEX_FWD_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/multi_index/detail/ord_index_args.hpp>
-#include <boost/multi_index/detail/ord_index_impl_fwd.hpp>
-
-namespace boost{
-
-namespace multi_index{
-
-/* ordered_index specifiers */
-
-template<typename Arg1,typename Arg2=mpl::na,typename Arg3=mpl::na>
-struct ordered_unique;
-
-template<typename Arg1,typename Arg2=mpl::na,typename Arg3=mpl::na>
-struct ordered_non_unique;
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/random_access_index.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/random_access_index.hpp
deleted file mode 100644
index fe1884ddd38..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/random_access_index.hpp
+++ /dev/null
@@ -1,1167 +0,0 @@
-/* Copyright 2003-2015 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_RANDOM_ACCESS_INDEX_HPP
-#define BOOST_MULTI_INDEX_RANDOM_ACCESS_INDEX_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <algorithm>
-#include <boost/bind.hpp>
-#include <boost/call_traits.hpp>
-#include <boost/detail/no_exceptions_support.hpp>
-#include <boost/detail/workaround.hpp>
-#include <boost/foreach_fwd.hpp>
-#include <boost/iterator/reverse_iterator.hpp>
-#include <boost/move/core.hpp>
-#include <boost/move/utility.hpp>
-#include <boost/mpl/bool.hpp>
-#include <boost/mpl/not.hpp>
-#include <boost/mpl/push_front.hpp>
-#include <boost/multi_index/detail/access_specifier.hpp>
-#include <boost/multi_index/detail/do_not_copy_elements_tag.hpp>
-#include <boost/multi_index/detail/index_node_base.hpp>
-#include <boost/multi_index/detail/rnd_node_iterator.hpp>
-#include <boost/multi_index/detail/rnd_index_node.hpp>
-#include <boost/multi_index/detail/rnd_index_ops.hpp>
-#include <boost/multi_index/detail/rnd_index_ptr_array.hpp>
-#include <boost/multi_index/detail/safe_mode.hpp>
-#include <boost/multi_index/detail/scope_guard.hpp>
-#include <boost/multi_index/detail/vartempl_support.hpp>
-#include <boost/multi_index/random_access_index_fwd.hpp>
-#include <boost/throw_exception.hpp> 
-#include <boost/tuple/tuple.hpp>
-#include <boost/type_traits/is_integral.hpp>
-#include <cstddef>
-#include <functional>
-#include <stdexcept> 
-#include <utility>
-
-#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
-#include<initializer_list>
-#endif
-
-#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
-#include <boost/multi_index/detail/rnd_index_loader.hpp>
-#endif
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING)
-#define BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT_OF(x)                    \
-  detail::scope_guard BOOST_JOIN(check_invariant_,__LINE__)=                 \
-    detail::make_obj_guard(x,&random_access_index::check_invariant_);        \
-  BOOST_JOIN(check_invariant_,__LINE__).touch();
-#define BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT                          \
-  BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT_OF(*this)
-#else
-#define BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT_OF(x)
-#define BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT
-#endif
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-/* random_access_index adds a layer of random access indexing
- * to a given Super
- */
-
-template<typename SuperMeta,typename TagList>
-class random_access_index:
-  BOOST_MULTI_INDEX_PROTECTED_IF_MEMBER_TEMPLATE_FRIENDS SuperMeta::type
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-  ,public safe_mode::safe_container<
-    random_access_index<SuperMeta,TagList> >
-#endif
-
-{ 
-#if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING)&&\
-    BOOST_WORKAROUND(__MWERKS__,<=0x3003)
-/* The "ISO C++ Template Parser" option in CW8.3 has a problem with the
- * lifetime of const references bound to temporaries --precisely what
- * scopeguards are.
- */
-
-#pragma parse_mfunc_templ off
-#endif
-
-  typedef typename SuperMeta::type                 super;
-
-protected:
-  typedef random_access_index_node<
-    typename super::node_type>                     node_type;
-
-private:
-  typedef typename node_type::impl_type            node_impl_type;
-  typedef random_access_index_ptr_array<
-    typename super::final_allocator_type>          ptr_array;
-  typedef typename ptr_array::pointer              node_impl_ptr_pointer;
-
-public:
-  /* types */
-
-  typedef typename node_type::value_type           value_type;
-  typedef tuples::null_type                        ctor_args;
-  typedef typename super::final_allocator_type     allocator_type;
-  typedef typename allocator_type::reference       reference;
-  typedef typename allocator_type::const_reference const_reference;
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-  typedef safe_mode::safe_iterator<
-    rnd_node_iterator<node_type>,
-    random_access_index>                           iterator;
-#else
-  typedef rnd_node_iterator<node_type>             iterator;
-#endif
-
-  typedef iterator                                 const_iterator;
-
-  typedef std::size_t                              size_type;      
-  typedef std::ptrdiff_t                           difference_type;
-  typedef typename allocator_type::pointer         pointer;
-  typedef typename allocator_type::const_pointer   const_pointer;
-  typedef typename
-    boost::reverse_iterator<iterator>              reverse_iterator;
-  typedef typename
-    boost::reverse_iterator<const_iterator>        const_reverse_iterator;
-  typedef TagList                                  tag_list;
-
-protected:
-  typedef typename super::final_node_type     final_node_type;
-  typedef tuples::cons<
-    ctor_args, 
-    typename super::ctor_args_list>           ctor_args_list;
-  typedef typename mpl::push_front<
-    typename super::index_type_list,
-    random_access_index>::type                index_type_list;
-  typedef typename mpl::push_front<
-    typename super::iterator_type_list,
-    iterator>::type                           iterator_type_list;
-  typedef typename mpl::push_front<
-    typename super::const_iterator_type_list,
-    const_iterator>::type                     const_iterator_type_list;
-  typedef typename super::copy_map_type       copy_map_type;
-
-#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
-  typedef typename super::index_saver_type    index_saver_type;
-  typedef typename super::index_loader_type   index_loader_type;
-#endif
-
-private:
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-  typedef safe_mode::safe_container<
-    random_access_index>                      safe_super;
-#endif
-
-  typedef typename call_traits<
-    value_type>::param_type                   value_param_type;
-
-  /* Needed to avoid commas in BOOST_MULTI_INDEX_OVERLOADS_TO_VARTEMPL
-   * expansion.
-   */
-
-  typedef std::pair<iterator,bool>            emplace_return_type;
-
-public:
-
-  /* construct/copy/destroy
-   * Default and copy ctors are in the protected section as indices are
-   * not supposed to be created on their own. No range ctor either.
-   */
-
-  random_access_index<SuperMeta,TagList>& operator=(
-    const random_access_index<SuperMeta,TagList>& x)
-  {
-    this->final()=x.final();
-    return *this;
-  }
-
-#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
-  random_access_index<SuperMeta,TagList>& operator=(
-    std::initializer_list<value_type> list)
-  {
-    this->final()=list;
-    return *this;
-  }
-#endif
-
-  template <class InputIterator>
-  void assign(InputIterator first,InputIterator last)
-  {
-    assign_iter(first,last,mpl::not_<is_integral<InputIterator> >());
-  }
-
-#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
-  void assign(std::initializer_list<value_type> list)
-  {
-    assign(list.begin(),list.end());
-  }
-#endif
-
-  void assign(size_type n,value_param_type value)
-  {
-    BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
-    clear();
-    for(size_type i=0;i<n;++i)push_back(value);
-  }
-    
-  allocator_type get_allocator()const BOOST_NOEXCEPT
-  {
-    return this->final().get_allocator();
-  }
-
-  /* iterators */
-
-  iterator begin()BOOST_NOEXCEPT
-    {return make_iterator(node_type::from_impl(*ptrs.begin()));}
-  const_iterator begin()const BOOST_NOEXCEPT
-    {return make_iterator(node_type::from_impl(*ptrs.begin()));}
-  iterator
-    end()BOOST_NOEXCEPT{return make_iterator(header());}
-  const_iterator
-    end()const BOOST_NOEXCEPT{return make_iterator(header());}
-  reverse_iterator
-    rbegin()BOOST_NOEXCEPT{return boost::make_reverse_iterator(end());}
-  const_reverse_iterator
-    rbegin()const BOOST_NOEXCEPT{return boost::make_reverse_iterator(end());}
-  reverse_iterator
-    rend()BOOST_NOEXCEPT{return boost::make_reverse_iterator(begin());}
-  const_reverse_iterator
-    rend()const BOOST_NOEXCEPT{return boost::make_reverse_iterator(begin());}
-  const_iterator
-    cbegin()const BOOST_NOEXCEPT{return begin();}
-  const_iterator
-    cend()const BOOST_NOEXCEPT{return end();}
-  const_reverse_iterator
-    crbegin()const BOOST_NOEXCEPT{return rbegin();}
-  const_reverse_iterator
-    crend()const BOOST_NOEXCEPT{return rend();}
-
-  iterator iterator_to(const value_type& x)
-  {
-    return make_iterator(node_from_value<node_type>(&x));
-  }
-
-  const_iterator iterator_to(const value_type& x)const
-  {
-    return make_iterator(node_from_value<node_type>(&x));
-  }
-
-  /* capacity */
-
-  bool      empty()const BOOST_NOEXCEPT{return this->final_empty_();}
-  size_type size()const BOOST_NOEXCEPT{return this->final_size_();}
-  size_type max_size()const BOOST_NOEXCEPT{return this->final_max_size_();}
-  size_type capacity()const BOOST_NOEXCEPT{return ptrs.capacity();}
-
-  void reserve(size_type n)
-  {
-    BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
-    ptrs.reserve(n);
-  }
-  
-  void shrink_to_fit()
-  {
-    BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
-    ptrs.shrink_to_fit();
-  }
-
-  void resize(size_type n)
-  {
-    BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
-    if(n>size())
-      for(size_type m=n-size();m--;)
-        this->final_emplace_(BOOST_MULTI_INDEX_NULL_PARAM_PACK);
-    else if(n<size())erase(begin()+n,end());
-  }
-
-  void resize(size_type n,value_param_type x)
-  {
-    BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
-    if(n>size())for(size_type m=n-size();m--;)this->final_insert_(x); 
-    else if(n<size())erase(begin()+n,end());
-  }
-
-  /* access: no non-const versions provided as random_access_index
-   * handles const elements.
-   */
-
-  const_reference operator[](size_type n)const
-  {
-    BOOST_MULTI_INDEX_SAFE_MODE_ASSERT(n<size(),safe_mode::out_of_bounds);
-    return node_type::from_impl(*ptrs.at(n))->value();
-  }
-
-  const_reference at(size_type n)const
-  {
-    if(n>=size())throw_exception(std::out_of_range("random access index"));
-    return node_type::from_impl(*ptrs.at(n))->value();
-  }
-
-  const_reference front()const{return operator[](0);}
-  const_reference back()const{return operator[](size()-1);}
-
-  /* modifiers */
-
-  BOOST_MULTI_INDEX_OVERLOADS_TO_VARTEMPL(
-    emplace_return_type,emplace_front,emplace_front_impl)
-    
-  std::pair<iterator,bool> push_front(const value_type& x)
-                             {return insert(begin(),x);}
-  std::pair<iterator,bool> push_front(BOOST_RV_REF(value_type) x)
-                             {return insert(begin(),boost::move(x));}
-  void                     pop_front(){erase(begin());}
-
-  BOOST_MULTI_INDEX_OVERLOADS_TO_VARTEMPL(
-    emplace_return_type,emplace_back,emplace_back_impl)
-
-  std::pair<iterator,bool> push_back(const value_type& x)
-                             {return insert(end(),x);}
-  std::pair<iterator,bool> push_back(BOOST_RV_REF(value_type) x)
-                             {return insert(end(),boost::move(x));}
-  void                     pop_back(){erase(--end());}
-
-  BOOST_MULTI_INDEX_OVERLOADS_TO_VARTEMPL_EXTRA_ARG(
-    emplace_return_type,emplace,emplace_impl,iterator,position)
-    
-  std::pair<iterator,bool> insert(iterator position,const value_type& x)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
-    BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
-    std::pair<final_node_type*,bool> p=this->final_insert_(x);
-    if(p.second&&position.get_node()!=header()){
-      relocate(position.get_node(),p.first);
-    }
-    return std::pair<iterator,bool>(make_iterator(p.first),p.second);
-  }
-
-  std::pair<iterator,bool> insert(iterator position,BOOST_RV_REF(value_type) x)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
-    BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
-    std::pair<final_node_type*,bool> p=this->final_insert_rv_(x);
-    if(p.second&&position.get_node()!=header()){
-      relocate(position.get_node(),p.first);
-    }
-    return std::pair<iterator,bool>(make_iterator(p.first),p.second);
-  }
-
-  void insert(iterator position,size_type n,value_param_type x)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
-    BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
-    size_type s=0;
-    BOOST_TRY{
-      while(n--){
-        if(push_back(x).second)++s;
-      }
-    }
-    BOOST_CATCH(...){
-      relocate(position,end()-s,end());
-      BOOST_RETHROW;
-    }
-    BOOST_CATCH_END
-    relocate(position,end()-s,end());
-  }
- 
-  template<typename InputIterator>
-  void insert(iterator position,InputIterator first,InputIterator last)
-  {
-    insert_iter(position,first,last,mpl::not_<is_integral<InputIterator> >());
-  }
-
-#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
-  void insert(iterator position,std::initializer_list<value_type> list)
-  {
-    insert(position,list.begin(),list.end());
-  }
-#endif
-
-  iterator erase(iterator position)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
-    BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
-    this->final_erase_(static_cast<final_node_type*>(position++.get_node()));
-    return position;
-  }
-  
-  iterator erase(iterator first,iterator last)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(first);
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(last);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(first,*this);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(last,*this);
-    BOOST_MULTI_INDEX_CHECK_VALID_RANGE(first,last);
-    BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
-    difference_type n=last-first;
-    relocate(end(),first,last);
-    while(n--)pop_back();
-    return last;
-  }
-
-  bool replace(iterator position,const value_type& x)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
-    BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
-    return this->final_replace_(
-      x,static_cast<final_node_type*>(position.get_node()));
-  }
-
-  bool replace(iterator position,BOOST_RV_REF(value_type) x)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
-    BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
-    return this->final_replace_rv_(
-      x,static_cast<final_node_type*>(position.get_node()));
-  }
-
-  template<typename Modifier>
-  bool modify(iterator position,Modifier mod)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
-    BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-    /* MSVC++ 6.0 optimizer on safe mode code chokes if this
-     * this is not added. Left it for all compilers as it does no
-     * harm.
-     */
-
-    position.detach();
-#endif
-
-    return this->final_modify_(
-      mod,static_cast<final_node_type*>(position.get_node()));
-  }
-
-  template<typename Modifier,typename Rollback>
-  bool modify(iterator position,Modifier mod,Rollback back_)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
-    BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-    /* MSVC++ 6.0 optimizer on safe mode code chokes if this
-     * this is not added. Left it for all compilers as it does no
-     * harm.
-     */
-
-    position.detach();
-#endif
-
-    return this->final_modify_(
-      mod,back_,static_cast<final_node_type*>(position.get_node()));
-  }
-
-  void swap(random_access_index<SuperMeta,TagList>& x)
-  {
-    BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
-    BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT_OF(x);
-    this->final_swap_(x.final());
-  }
-
-  void clear()BOOST_NOEXCEPT
-  {
-    BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
-    this->final_clear_();
-  }
-
-  /* list operations */
-
-  void splice(iterator position,random_access_index<SuperMeta,TagList>& x)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
-    BOOST_MULTI_INDEX_CHECK_DIFFERENT_CONTAINER(*this,x);
-    BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
-    iterator  first=x.begin(),last=x.end();
-    size_type n=0;
-    BOOST_TRY{
-      while(first!=last){
-        if(push_back(*first).second){
-          first=x.erase(first);
-          ++n;
-        }
-        else ++first;
-      }
-    }
-    BOOST_CATCH(...){
-      relocate(position,end()-n,end());
-      BOOST_RETHROW;
-    }
-    BOOST_CATCH_END
-    relocate(position,end()-n,end());
-  }
-
-  void splice(
-    iterator position,random_access_index<SuperMeta,TagList>& x,iterator i)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(i);
-    BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(i);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(i,x);
-    BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
-    if(&x==this)relocate(position,i);
-    else{
-      if(insert(position,*i).second){
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-    /* MSVC++ 6.0 optimizer has a hard time with safe mode, and the following
-     * workaround is needed. Left it for all compilers as it does no
-     * harm.
-     */
-        i.detach();
-        x.erase(x.make_iterator(i.get_node()));
-#else
-        x.erase(i);
-#endif
-
-      }
-    }
-  }
-
-  void splice(
-    iterator position,random_access_index<SuperMeta,TagList>& x,
-    iterator first,iterator last)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(first);
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(last);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(first,x);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(last,x);
-    BOOST_MULTI_INDEX_CHECK_VALID_RANGE(first,last);
-    BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
-    if(&x==this)relocate(position,first,last);
-    else{
-      size_type n=0;
-      BOOST_TRY{
-        while(first!=last){
-          if(push_back(*first).second){
-            first=x.erase(first);
-            ++n;
-          }
-          else ++first;
-        }
-      }
-      BOOST_CATCH(...){
-        relocate(position,end()-n,end());
-        BOOST_RETHROW;
-      }
-      BOOST_CATCH_END
-      relocate(position,end()-n,end());
-    }
-  }
-
-  void remove(value_param_type value)
-  {
-    BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
-    difference_type n=
-      end()-make_iterator(
-        random_access_index_remove<node_type>(
-          ptrs,
-          ::boost::bind(std::equal_to<value_type>(),::boost::arg<1>(),value)));
-    while(n--)pop_back();
-  }
-
-  template<typename Predicate>
-  void remove_if(Predicate pred)
-  {
-    BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
-    difference_type n=
-      end()-make_iterator(random_access_index_remove<node_type>(ptrs,pred));
-    while(n--)pop_back();
-  }
-
-  void unique()
-  {
-    BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
-    difference_type n=
-      end()-make_iterator(
-        random_access_index_unique<node_type>(
-          ptrs,std::equal_to<value_type>()));
-    while(n--)pop_back();
-  }
-
-  template <class BinaryPredicate>
-  void unique(BinaryPredicate binary_pred)
-  {
-    BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
-    difference_type n=
-      end()-make_iterator(
-        random_access_index_unique<node_type>(ptrs,binary_pred));
-    while(n--)pop_back();
-  }
-
-  void merge(random_access_index<SuperMeta,TagList>& x)
-  {
-    if(this!=&x){
-      BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
-      size_type s=size();
-      splice(end(),x);
-      random_access_index_inplace_merge<node_type>(
-        get_allocator(),ptrs,ptrs.at(s),std::less<value_type>());
-    }
-  }
-
-  template <typename Compare>
-  void merge(random_access_index<SuperMeta,TagList>& x,Compare comp)
-  {
-    if(this!=&x){
-      BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
-      size_type s=size();
-      splice(end(),x);
-      random_access_index_inplace_merge<node_type>(
-        get_allocator(),ptrs,ptrs.at(s),comp);
-    }
-  }
-
-  void sort()
-  {
-    BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
-    random_access_index_sort<node_type>(
-      get_allocator(),ptrs,std::less<value_type>());
-  }
-
-  template <typename Compare>
-  void sort(Compare comp)
-  {
-    BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
-    random_access_index_sort<node_type>(
-      get_allocator(),ptrs,comp);
-  }
-
-  void reverse()BOOST_NOEXCEPT
-  {
-    BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
-    node_impl_type::reverse(ptrs.begin(),ptrs.end());
-  }
-
-  /* rearrange operations */
-
-  void relocate(iterator position,iterator i)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(i);
-    BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(i);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(i,*this);
-    BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
-    if(position!=i)relocate(position.get_node(),i.get_node());
-  }
-
-  void relocate(iterator position,iterator first,iterator last)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(first);
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(last);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(first,*this);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(last,*this);
-    BOOST_MULTI_INDEX_CHECK_VALID_RANGE(first,last);
-    BOOST_MULTI_INDEX_CHECK_OUTSIDE_RANGE(position,first,last);
-    BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
-    if(position!=last)relocate(
-      position.get_node(),first.get_node(),last.get_node());
-  }
-
-  template<typename InputIterator>
-  void rearrange(InputIterator first)
-  {
-    BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
-    for(node_impl_ptr_pointer p0=ptrs.begin(),p0_end=ptrs.end();
-        p0!=p0_end;++first,++p0){
-      const value_type& v1=*first;
-      node_impl_ptr_pointer p1=node_from_value<node_type>(&v1)->up();
-
-      std::swap(*p0,*p1);
-      (*p0)->up()=p0;
-      (*p1)->up()=p1;
-    }
-  }
-    
-BOOST_MULTI_INDEX_PROTECTED_IF_MEMBER_TEMPLATE_FRIENDS:
-  random_access_index(
-    const ctor_args_list& args_list,const allocator_type& al):
-    super(args_list.get_tail(),al),
-    ptrs(al,header()->impl(),0)
-  {
-  }
-
-  random_access_index(const random_access_index<SuperMeta,TagList>& x):
-    super(x),
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-    safe_super(),
-#endif
-
-    ptrs(x.get_allocator(),header()->impl(),x.size())
-  {
-    /* The actual copying takes place in subsequent call to copy_().
-     */
-  }
-
-  random_access_index(
-    const random_access_index<SuperMeta,TagList>& x,do_not_copy_elements_tag):
-    super(x,do_not_copy_elements_tag()),
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-    safe_super(),
-#endif
-
-    ptrs(x.get_allocator(),header()->impl(),0)
-  {
-  }
-
-  ~random_access_index()
-  {
-    /* the container is guaranteed to be empty by now */
-  }
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-  iterator       make_iterator(node_type* node){return iterator(node,this);}
-  const_iterator make_iterator(node_type* node)const
-    {return const_iterator(node,const_cast<random_access_index*>(this));}
-#else
-  iterator       make_iterator(node_type* node){return iterator(node);}
-  const_iterator make_iterator(node_type* node)const
-                   {return const_iterator(node);}
-#endif
-
-  void copy_(
-    const random_access_index<SuperMeta,TagList>& x,const copy_map_type& map)
-  {
-    for(node_impl_ptr_pointer begin_org=x.ptrs.begin(),
-                              begin_cpy=ptrs.begin(),
-                              end_org=x.ptrs.end();
-        begin_org!=end_org;++begin_org,++begin_cpy){
-      *begin_cpy=
-         static_cast<node_type*>(
-           map.find(
-             static_cast<final_node_type*>(
-               node_type::from_impl(*begin_org))))->impl();
-      (*begin_cpy)->up()=begin_cpy;
-    }
-
-    super::copy_(x,map);
-  }
-
-  template<typename Variant>
-  final_node_type* insert_(
-    value_param_type v,final_node_type*& x,Variant variant)
-  {
-    ptrs.room_for_one();
-    final_node_type* res=super::insert_(v,x,variant);
-    if(res==x)ptrs.push_back(static_cast<node_type*>(x)->impl());
-    return res;
-  }
-
-  template<typename Variant>
-  final_node_type* insert_(
-    value_param_type v,node_type* position,final_node_type*& x,Variant variant)
-  {
-    ptrs.room_for_one();
-    final_node_type* res=super::insert_(v,position,x,variant);
-    if(res==x)ptrs.push_back(static_cast<node_type*>(x)->impl());
-    return res;
-  }
-
-  void erase_(node_type* x)
-  {
-    ptrs.erase(x->impl());
-    super::erase_(x);
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-    detach_iterators(x);
-#endif
-  }
-
-  void delete_all_nodes_()
-  {
-    for(node_impl_ptr_pointer x=ptrs.begin(),x_end=ptrs.end();x!=x_end;++x){
-      this->final_delete_node_(
-        static_cast<final_node_type*>(node_type::from_impl(*x)));
-    }
-  }
-
-  void clear_()
-  {
-    super::clear_();
-    ptrs.clear();
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-    safe_super::detach_dereferenceable_iterators();
-#endif
-  }
-
-  void swap_(random_access_index<SuperMeta,TagList>& x)
-  {
-    ptrs.swap(x.ptrs);
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-    safe_super::swap(x);
-#endif
-
-    super::swap_(x);
-  }
-
-  void swap_elements_(random_access_index<SuperMeta,TagList>& x)
-  {
-    ptrs.swap(x.ptrs);
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-    safe_super::swap(x);
-#endif
-
-    super::swap_elements_(x);
-  }
-
-  template<typename Variant>
-  bool replace_(value_param_type v,node_type* x,Variant variant)
-  {
-    return super::replace_(v,x,variant);
-  }
-
-  bool modify_(node_type* x)
-  {
-    BOOST_TRY{
-      if(!super::modify_(x)){
-        ptrs.erase(x->impl());
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-        detach_iterators(x);
-#endif
-
-        return false;
-      }
-      else return true;
-    }
-    BOOST_CATCH(...){
-      ptrs.erase(x->impl());
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-      detach_iterators(x);
-#endif
-
-      BOOST_RETHROW;
-    }
-    BOOST_CATCH_END
-  }
-
-  bool modify_rollback_(node_type* x)
-  {
-    return super::modify_rollback_(x);
-  }
-
-#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
-  /* serialization */
-
-  template<typename Archive>
-  void save_(
-    Archive& ar,const unsigned int version,const index_saver_type& sm)const
-  {
-    sm.save(begin(),end(),ar,version);
-    super::save_(ar,version,sm);
-  }
-
-  template<typename Archive>
-  void load_(
-    Archive& ar,const unsigned int version,const index_loader_type& lm)
-  {
-    {
-      typedef random_access_index_loader<node_type,allocator_type> loader;
-
-      loader ld(get_allocator(),ptrs);
-      lm.load(
-        ::boost::bind(
-          &loader::rearrange,&ld,::boost::arg<1>(),::boost::arg<2>()),
-        ar,version);
-    } /* exit scope so that ld frees its resources */
-    super::load_(ar,version,lm);
-  }
-#endif
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING)
-  /* invariant stuff */
-
-  bool invariant_()const
-  {
-    if(size()>capacity())return false;
-    if(size()==0||begin()==end()){
-      if(size()!=0||begin()!=end())return false;
-    }
-    else{
-      size_type s=0;
-      for(const_iterator it=begin(),it_end=end();;++it,++s){
-        if(*(it.get_node()->up())!=it.get_node()->impl())return false;
-        if(it==it_end)break;
-      }
-      if(s!=size())return false;
-    }
-
-    return super::invariant_();
-  }
-
-  /* This forwarding function eases things for the boost::mem_fn construct
-   * in BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT. Actually,
-   * final_check_invariant is already an inherited member function of index.
-   */
-  void check_invariant_()const{this->final_check_invariant_();}
-#endif
-
-private:
-  node_type* header()const{return this->final_header();}
-
-  static void relocate(node_type* position,node_type* x)
-  {
-    node_impl_type::relocate(position->up(),x->up());
-  }
-
-  static void relocate(node_type* position,node_type* first,node_type* last)
-  {
-    node_impl_type::relocate(
-      position->up(),first->up(),last->up());
-  }
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-  void detach_iterators(node_type* x)
-  {
-    iterator it=make_iterator(x);
-    safe_mode::detach_equivalent_iterators(it);
-  }
-#endif
-
-  template <class InputIterator>
-  void assign_iter(InputIterator first,InputIterator last,mpl::true_)
-  {
-    BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
-    clear();
-    for(;first!=last;++first)this->final_insert_ref_(*first);
-  }
-
-  void assign_iter(size_type n,value_param_type value,mpl::false_)
-  {
-    BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
-    clear();
-    for(size_type i=0;i<n;++i)push_back(value);
-  }
-
-  template<typename InputIterator>
-  void insert_iter(
-    iterator position,InputIterator first,InputIterator last,mpl::true_)
-  {
-    BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
-    size_type s=0;
-    BOOST_TRY{
-      for(;first!=last;++first){
-        if(this->final_insert_ref_(*first).second)++s;
-      }
-    }
-    BOOST_CATCH(...){
-      relocate(position,end()-s,end());
-      BOOST_RETHROW;
-    }
-    BOOST_CATCH_END
-    relocate(position,end()-s,end());
-  }
-
-  void insert_iter(
-    iterator position,size_type n,value_param_type x,mpl::false_)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
-    BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
-    size_type  s=0;
-    BOOST_TRY{
-      while(n--){
-        if(push_back(x).second)++s;
-      }
-    }
-    BOOST_CATCH(...){
-      relocate(position,end()-s,end());
-      BOOST_RETHROW;
-    }
-    BOOST_CATCH_END
-    relocate(position,end()-s,end());
-  }
- 
-  template<BOOST_MULTI_INDEX_TEMPLATE_PARAM_PACK>
-  std::pair<iterator,bool> emplace_front_impl(
-    BOOST_MULTI_INDEX_FUNCTION_PARAM_PACK)
-  {
-    return emplace_impl(begin(),BOOST_MULTI_INDEX_FORWARD_PARAM_PACK);
-  }
-
-  template<BOOST_MULTI_INDEX_TEMPLATE_PARAM_PACK>
-  std::pair<iterator,bool> emplace_back_impl(
-    BOOST_MULTI_INDEX_FUNCTION_PARAM_PACK)
-  {
-    return emplace_impl(end(),BOOST_MULTI_INDEX_FORWARD_PARAM_PACK);
-  }
-
-  template<BOOST_MULTI_INDEX_TEMPLATE_PARAM_PACK>
-  std::pair<iterator,bool> emplace_impl(
-    iterator position,BOOST_MULTI_INDEX_FUNCTION_PARAM_PACK)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
-    BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
-    std::pair<final_node_type*,bool> p=
-      this->final_emplace_(BOOST_MULTI_INDEX_FORWARD_PARAM_PACK);
-    if(p.second&&position.get_node()!=header()){
-      relocate(position.get_node(),p.first);
-    }
-    return std::pair<iterator,bool>(make_iterator(p.first),p.second);
-  }
-
-  ptr_array ptrs;
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING)&&\
-    BOOST_WORKAROUND(__MWERKS__,<=0x3003)
-#pragma parse_mfunc_templ reset
-#endif
-};
-
-/* comparison */
-
-template<
-  typename SuperMeta1,typename TagList1,
-  typename SuperMeta2,typename TagList2
->
-bool operator==(
-  const random_access_index<SuperMeta1,TagList1>& x,
-  const random_access_index<SuperMeta2,TagList2>& y)
-{
-  return x.size()==y.size()&&std::equal(x.begin(),x.end(),y.begin());
-}
-
-template<
-  typename SuperMeta1,typename TagList1,
-  typename SuperMeta2,typename TagList2
->
-bool operator<(
-  const random_access_index<SuperMeta1,TagList1>& x,
-  const random_access_index<SuperMeta2,TagList2>& y)
-{
-  return std::lexicographical_compare(x.begin(),x.end(),y.begin(),y.end());
-}
-
-template<
-  typename SuperMeta1,typename TagList1,
-  typename SuperMeta2,typename TagList2
->
-bool operator!=(
-  const random_access_index<SuperMeta1,TagList1>& x,
-  const random_access_index<SuperMeta2,TagList2>& y)
-{
-  return !(x==y);
-}
-
-template<
-  typename SuperMeta1,typename TagList1,
-  typename SuperMeta2,typename TagList2
->
-bool operator>(
-  const random_access_index<SuperMeta1,TagList1>& x,
-  const random_access_index<SuperMeta2,TagList2>& y)
-{
-  return y<x;
-}
-
-template<
-  typename SuperMeta1,typename TagList1,
-  typename SuperMeta2,typename TagList2
->
-bool operator>=(
-  const random_access_index<SuperMeta1,TagList1>& x,
-  const random_access_index<SuperMeta2,TagList2>& y)
-{
-  return !(x<y);
-}
-
-template<
-  typename SuperMeta1,typename TagList1,
-  typename SuperMeta2,typename TagList2
->
-bool operator<=(
-  const random_access_index<SuperMeta1,TagList1>& x,
-  const random_access_index<SuperMeta2,TagList2>& y)
-{
-  return !(x>y);
-}
-
-/*  specialized algorithms */
-
-template<typename SuperMeta,typename TagList>
-void swap(
-  random_access_index<SuperMeta,TagList>& x,
-  random_access_index<SuperMeta,TagList>& y)
-{
-  x.swap(y);
-}
-
-} /* namespace multi_index::detail */
-
-/* random access index specifier */
-
-template <typename TagList>
-struct random_access
-{
-  BOOST_STATIC_ASSERT(detail::is_tag<TagList>::value);
-
-  template<typename Super>
-  struct node_class
-  {
-    typedef detail::random_access_index_node<Super> type;
-  };
-
-  template<typename SuperMeta>
-  struct index_class
-  {
-    typedef detail::random_access_index<
-      SuperMeta,typename TagList::type>  type;
-  };
-};
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-/* Boost.Foreach compatibility */
-
-template<typename SuperMeta,typename TagList>
-inline boost::mpl::true_* boost_foreach_is_noncopyable(
-  boost::multi_index::detail::random_access_index<SuperMeta,TagList>*&,
-  boost_foreach_argument_dependent_lookup_hack)
-{
-  return 0;
-}
-
-#undef BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT
-#undef BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT_OF
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/random_access_index_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/random_access_index_fwd.hpp
deleted file mode 100644
index 2ea19295426..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/random_access_index_fwd.hpp
+++ /dev/null
@@ -1,91 +0,0 @@
-/* Copyright 2003-2013 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_RANDOM_ACCESS_INDEX_FWD_HPP
-#define BOOST_MULTI_INDEX_RANDOM_ACCESS_INDEX_FWD_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/multi_index/tag.hpp>
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-template<typename SuperMeta,typename TagList>
-class random_access_index;
-
-template<
-  typename SuperMeta1,typename TagList1,
-  typename SuperMeta2,typename TagList2
->
-bool operator==(
-  const random_access_index<SuperMeta1,TagList1>& x,
-  const random_access_index<SuperMeta2,TagList2>& y);
-
-template<
-  typename SuperMeta1,typename TagList1,
-  typename SuperMeta2,typename TagList2
->
-bool operator<(
-  const random_access_index<SuperMeta1,TagList1>& x,
-  const random_access_index<SuperMeta2,TagList2>& y);
-
-template<
-  typename SuperMeta1,typename TagList1,
-  typename SuperMeta2,typename TagList2
->
-bool operator!=(
-  const random_access_index<SuperMeta1,TagList1>& x,
-  const random_access_index<SuperMeta2,TagList2>& y);
-
-template<
-  typename SuperMeta1,typename TagList1,
-  typename SuperMeta2,typename TagList2
->
-bool operator>(
-  const random_access_index<SuperMeta1,TagList1>& x,
-  const random_access_index<SuperMeta2,TagList2>& y);
-
-template<
-  typename SuperMeta1,typename TagList1,
-  typename SuperMeta2,typename TagList2
->
-bool operator>=(
-  const random_access_index<SuperMeta1,TagList1>& x,
-  const random_access_index<SuperMeta2,TagList2>& y);
-
-template<
-  typename SuperMeta1,typename TagList1,
-  typename SuperMeta2,typename TagList2
->
-bool operator<=(
-  const random_access_index<SuperMeta1,TagList1>& x,
-  const random_access_index<SuperMeta2,TagList2>& y);
-
-template<typename SuperMeta,typename TagList>
-void swap(
-  random_access_index<SuperMeta,TagList>& x,
-  random_access_index<SuperMeta,TagList>& y);
-
-} /* namespace multi_index::detail */
-
-/* index specifiers */
-
-template <typename TagList=tag<> >
-struct random_access;
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/ranked_index.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/ranked_index.hpp
deleted file mode 100644
index 4b24c4f5937..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/ranked_index.hpp
+++ /dev/null
@@ -1,382 +0,0 @@
-/* Copyright 2003-2017 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_RANKED_INDEX_HPP
-#define BOOST_MULTI_INDEX_RANKED_INDEX_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <boost/multi_index/detail/ord_index_impl.hpp>
-#include <boost/multi_index/detail/rnk_index_ops.hpp>
-#include <boost/multi_index/ranked_index_fwd.hpp>
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-/* ranked_index augments a given ordered index to provide rank operations */
-
-template<typename OrderedIndexNodeImpl>
-struct ranked_node:OrderedIndexNodeImpl
-{
-  std::size_t size;
-};
-
-template<typename OrderedIndexImpl>
-class ranked_index:public OrderedIndexImpl
-{
-  typedef          OrderedIndexImpl         super;
-
-protected:
-  typedef typename super::node_type         node_type;
-  typedef typename super::node_impl_pointer node_impl_pointer;
-
-public:
-  typedef typename super::ctor_args_list ctor_args_list;
-  typedef typename super::allocator_type allocator_type;
-  typedef typename super::iterator       iterator;
-
-  /* rank operations */
-
-  iterator nth(std::size_t n)const
-  {
-    return this->make_iterator(node_type::from_impl(
-      ranked_index_nth(n,this->header()->impl())));
-  }
-
-  std::size_t rank(iterator position)const
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
-
-    return ranked_index_rank(
-      position.get_node()->impl(),this->header()->impl());
-  }
-
-  template<typename CompatibleKey>
-  std::size_t find_rank(const CompatibleKey& x)const
-  {
-    return ranked_index_find_rank(
-      this->root(),this->header(),this->key,x,this->comp_);
-  }
-
-  template<typename CompatibleKey,typename CompatibleCompare>
-  std::size_t find_rank(
-    const CompatibleKey& x,const CompatibleCompare& comp)const
-  {
-    return ranked_index_find_rank(
-      this->root(),this->header(),this->key,x,comp);
-  }
-
-  template<typename CompatibleKey>
-  std::size_t lower_bound_rank(const CompatibleKey& x)const
-  {
-    return ranked_index_lower_bound_rank(
-      this->root(),this->header(),this->key,x,this->comp_);
-  }
-
-  template<typename CompatibleKey,typename CompatibleCompare>
-  std::size_t lower_bound_rank(
-    const CompatibleKey& x,const CompatibleCompare& comp)const
-  {
-    return ranked_index_lower_bound_rank(
-      this->root(),this->header(),this->key,x,comp);
-  }
-
-  template<typename CompatibleKey>
-  std::size_t upper_bound_rank(const CompatibleKey& x)const
-  {
-    return ranked_index_upper_bound_rank(
-      this->root(),this->header(),this->key,x,this->comp_);
-  }
-
-  template<typename CompatibleKey,typename CompatibleCompare>
-  std::size_t upper_bound_rank(
-    const CompatibleKey& x,const CompatibleCompare& comp)const
-  {
-    return ranked_index_upper_bound_rank(
-      this->root(),this->header(),this->key,x,comp);
-  }
-
-  template<typename CompatibleKey>
-  std::pair<std::size_t,std::size_t> equal_range_rank(
-    const CompatibleKey& x)const
-  {
-    return ranked_index_equal_range_rank(
-      this->root(),this->header(),this->key,x,this->comp_);
-  }
-
-  template<typename CompatibleKey,typename CompatibleCompare>
-  std::pair<std::size_t,std::size_t> equal_range_rank(
-    const CompatibleKey& x,const CompatibleCompare& comp)const
-  {
-    return ranked_index_equal_range_rank(
-      this->root(),this->header(),this->key,x,comp);
-  }
-
-  template<typename LowerBounder,typename UpperBounder>
-  std::pair<std::size_t,std::size_t>
-  range_rank(LowerBounder lower,UpperBounder upper)const
-  {
-    typedef typename mpl::if_<
-      is_same<LowerBounder,unbounded_type>,
-      BOOST_DEDUCED_TYPENAME mpl::if_<
-        is_same<UpperBounder,unbounded_type>,
-        both_unbounded_tag,
-        lower_unbounded_tag
-      >::type,
-      BOOST_DEDUCED_TYPENAME mpl::if_<
-        is_same<UpperBounder,unbounded_type>,
-        upper_unbounded_tag,
-        none_unbounded_tag
-      >::type
-    >::type dispatch;
-
-    return range_rank(lower,upper,dispatch());
-  }
-
-protected:
-  ranked_index(const ranked_index& x):super(x){};
-
-  ranked_index(const ranked_index& x,do_not_copy_elements_tag):
-    super(x,do_not_copy_elements_tag()){};
-
-  ranked_index(
-    const ctor_args_list& args_list,const allocator_type& al):
-    super(args_list,al){}
-
-private:
-  template<typename LowerBounder,typename UpperBounder>
-  std::pair<std::size_t,std::size_t>
-  range_rank(LowerBounder lower,UpperBounder upper,none_unbounded_tag)const
-  {
-    node_type* y=this->header();
-    node_type* z=this->root();
-
-    if(!z)return std::pair<std::size_t,std::size_t>(0,0);
-
-    std::size_t s=z->impl()->size;
-
-    do{
-      if(!lower(this->key(z->value()))){
-        z=node_type::from_impl(z->right());
-      }
-      else if(!upper(this->key(z->value()))){
-        y=z;
-        s-=ranked_node_size(y->right())+1;
-        z=node_type::from_impl(z->left());
-      }
-      else{
-        return std::pair<std::size_t,std::size_t>(
-          s-z->impl()->size+
-            lower_range_rank(node_type::from_impl(z->left()),z,lower),
-          s-ranked_node_size(z->right())+
-            upper_range_rank(node_type::from_impl(z->right()),y,upper));
-      }
-    }while(z);
-
-    return std::pair<std::size_t,std::size_t>(s,s);
-  }
-
-  template<typename LowerBounder,typename UpperBounder>
-  std::pair<std::size_t,std::size_t>
-  range_rank(LowerBounder,UpperBounder upper,lower_unbounded_tag)const
-  {
-    return std::pair<std::size_t,std::size_t>(
-      0,
-      upper_range_rank(this->root(),this->header(),upper));
-  }
-
-  template<typename LowerBounder,typename UpperBounder>
-  std::pair<std::size_t,std::size_t>
-  range_rank(LowerBounder lower,UpperBounder,upper_unbounded_tag)const
-  {
-    return std::pair<std::size_t,std::size_t>(
-      lower_range_rank(this->root(),this->header(),lower),
-      this->size());
-  }
-
-  template<typename LowerBounder,typename UpperBounder>
-  std::pair<std::size_t,std::size_t>
-  range_rank(LowerBounder,UpperBounder,both_unbounded_tag)const
-  {
-    return std::pair<std::size_t,std::size_t>(0,this->size());
-  }
-
-  template<typename LowerBounder>
-  std::size_t
-  lower_range_rank(node_type* top,node_type* y,LowerBounder lower)const
-  {
-    if(!top)return 0;
-
-    std::size_t s=top->impl()->size;
-
-    do{
-      if(lower(this->key(top->value()))){
-        y=top;
-        s-=ranked_node_size(y->right())+1;
-        top=node_type::from_impl(top->left());
-      }
-      else top=node_type::from_impl(top->right());
-    }while(top);
-
-    return s;
-  }
-
-  template<typename UpperBounder>
-  std::size_t
-  upper_range_rank(node_type* top,node_type* y,UpperBounder upper)const
-  {
-    if(!top)return 0;
-
-    std::size_t s=top->impl()->size;
-
-    do{
-      if(!upper(this->key(top->value()))){
-        y=top;
-        s-=ranked_node_size(y->right())+1;
-        top=node_type::from_impl(top->left());
-      }
-      else top=node_type::from_impl(top->right());
-    }while(top);
-
-    return s;
-  }
-};
-
-/* augmenting policy for ordered_index */
-
-struct rank_policy
-{
-  template<typename OrderedIndexNodeImpl>
-  struct augmented_node
-  {
-    typedef ranked_node<OrderedIndexNodeImpl> type;
-  };
-
-  template<typename OrderedIndexImpl>
-  struct augmented_interface
-  {
-    typedef ranked_index<OrderedIndexImpl> type;
-  };
-
-  /* algorithmic stuff */
-
-  template<typename Pointer>
-  static void add(Pointer x,Pointer root)
-  {
-    x->size=1;
-    while(x!=root){
-      x=x->parent();
-      ++(x->size);
-    }
-  }
-
-  template<typename Pointer>
-  static void remove(Pointer x,Pointer root)
-  {
-    while(x!=root){
-      x=x->parent();
-      --(x->size);
-    }
-  }
-
-  template<typename Pointer>
-  static void copy(Pointer x,Pointer y)
-  {
-    y->size=x->size;
-  }
-
-  template<typename Pointer>
-  static void rotate_left(Pointer x,Pointer y) /* in: x==y->left() */
-  {
-    y->size=x->size;
-    x->size=ranked_node_size(x->left())+ranked_node_size(x->right())+1;
-  }
-
-  template<typename Pointer>
-  static void rotate_right(Pointer x,Pointer y) /* in: x==y->right() */
-  {
-    rotate_left(x,y);
-  }
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING)
-  /* invariant stuff */
-
-  template<typename Pointer>
-  static bool invariant(Pointer x)
-  {
-    return x->size==ranked_node_size(x->left())+ranked_node_size(x->right())+1;
-  }
-#endif
-};
-
-} /* namespace multi_index::detail */
-
-/* ranked_index specifiers */
-
-template<typename Arg1,typename Arg2,typename Arg3>
-struct ranked_unique
-{
-  typedef typename detail::ordered_index_args<
-    Arg1,Arg2,Arg3>                                index_args;
-  typedef typename index_args::tag_list_type::type tag_list_type;
-  typedef typename index_args::key_from_value_type key_from_value_type;
-  typedef typename index_args::compare_type        compare_type;
-
-  template<typename Super>
-  struct node_class
-  {
-    typedef detail::ordered_index_node<detail::rank_policy,Super> type;
-  };
-
-  template<typename SuperMeta>
-  struct index_class
-  {
-    typedef detail::ordered_index<
-      key_from_value_type,compare_type,
-      SuperMeta,tag_list_type,detail::ordered_unique_tag,
-      detail::rank_policy>                                type;
-  };
-};
-
-template<typename Arg1,typename Arg2,typename Arg3>
-struct ranked_non_unique
-{
-  typedef detail::ordered_index_args<
-    Arg1,Arg2,Arg3>                                index_args;
-  typedef typename index_args::tag_list_type::type tag_list_type;
-  typedef typename index_args::key_from_value_type key_from_value_type;
-  typedef typename index_args::compare_type        compare_type;
-
-  template<typename Super>
-  struct node_class
-  {
-    typedef detail::ordered_index_node<detail::rank_policy,Super> type;
-  };
-
-  template<typename SuperMeta>
-  struct index_class
-  {
-    typedef detail::ordered_index<
-      key_from_value_type,compare_type,
-      SuperMeta,tag_list_type,detail::ordered_non_unique_tag,
-      detail::rank_policy>                                    type;
-  };
-};
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/ranked_index_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/ranked_index_fwd.hpp
deleted file mode 100644
index 380d3480736..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/ranked_index_fwd.hpp
+++ /dev/null
@@ -1,35 +0,0 @@
-/* Copyright 2003-2015 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_RANKED_INDEX_FWD_HPP
-#define BOOST_MULTI_INDEX_RANKED_INDEX_FWD_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/multi_index/detail/ord_index_args.hpp>
-#include <boost/multi_index/detail/ord_index_impl_fwd.hpp>
-
-namespace boost{
-
-namespace multi_index{
-
-/* ranked_index specifiers */
-
-template<typename Arg1,typename Arg2=mpl::na,typename Arg3=mpl::na>
-struct ranked_unique;
-
-template<typename Arg1,typename Arg2=mpl::na,typename Arg3=mpl::na>
-struct ranked_non_unique;
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/safe_mode_errors.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/safe_mode_errors.hpp
deleted file mode 100644
index 1904706edec..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/safe_mode_errors.hpp
+++ /dev/null
@@ -1,48 +0,0 @@
-/* Copyright 2003-2013 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_SAFE_MODE_ERRORS_HPP
-#define BOOST_MULTI_INDEX_SAFE_MODE_ERRORS_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-namespace boost{
-
-namespace multi_index{
-
-namespace safe_mode{
-
-/* Error codes for Boost.MultiIndex safe mode. These go in a separate
- * header so that the user can include it when redefining
- * BOOST_MULTI_INDEX_SAFE_MODE_ASSERT prior to the inclusion of
- * any other header of Boost.MultiIndex.
- */
-
-enum error_code
-{
-  invalid_iterator=0,
-  not_dereferenceable_iterator,
-  not_incrementable_iterator,
-  not_decrementable_iterator,
-  not_owner,
-  not_same_owner,
-  invalid_range,
-  inside_range,
-  out_of_bounds,
-  same_container
-};
-
-} /* namespace multi_index::safe_mode */
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/sequenced_index.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/sequenced_index.hpp
deleted file mode 100644
index 424eebc376d..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/sequenced_index.hpp
+++ /dev/null
@@ -1,1062 +0,0 @@
-/* Copyright 2003-2015 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_SEQUENCED_INDEX_HPP
-#define BOOST_MULTI_INDEX_SEQUENCED_INDEX_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <boost/bind.hpp>
-#include <boost/call_traits.hpp>
-#include <boost/detail/allocator_utilities.hpp>
-#include <boost/detail/no_exceptions_support.hpp>
-#include <boost/detail/workaround.hpp>
-#include <boost/foreach_fwd.hpp>
-#include <boost/iterator/reverse_iterator.hpp>
-#include <boost/move/core.hpp>
-#include <boost/move/utility.hpp>
-#include <boost/mpl/bool.hpp>
-#include <boost/mpl/not.hpp>
-#include <boost/mpl/push_front.hpp>
-#include <boost/multi_index/detail/access_specifier.hpp>
-#include <boost/multi_index/detail/bidir_node_iterator.hpp>
-#include <boost/multi_index/detail/do_not_copy_elements_tag.hpp>
-#include <boost/multi_index/detail/index_node_base.hpp>
-#include <boost/multi_index/detail/safe_mode.hpp>
-#include <boost/multi_index/detail/scope_guard.hpp>
-#include <boost/multi_index/detail/seq_index_node.hpp>
-#include <boost/multi_index/detail/seq_index_ops.hpp>
-#include <boost/multi_index/detail/vartempl_support.hpp>
-#include <boost/multi_index/sequenced_index_fwd.hpp>
-#include <boost/tuple/tuple.hpp>
-#include <boost/type_traits/is_integral.hpp>
-#include <cstddef>
-#include <functional>
-#include <utility>
-
-#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
-#include<initializer_list>
-#endif
-
-#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
-#include <boost/bind.hpp>
-#endif
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING)
-#define BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT_OF(x)                    \
-  detail::scope_guard BOOST_JOIN(check_invariant_,__LINE__)=                 \
-    detail::make_obj_guard(x,&sequenced_index::check_invariant_);            \
-  BOOST_JOIN(check_invariant_,__LINE__).touch();
-#define BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT                          \
-  BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT_OF(*this)
-#else
-#define BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT_OF(x)
-#define BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT
-#endif
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-/* sequenced_index adds a layer of sequenced indexing to a given Super */
-
-template<typename SuperMeta,typename TagList>
-class sequenced_index:
-  BOOST_MULTI_INDEX_PROTECTED_IF_MEMBER_TEMPLATE_FRIENDS SuperMeta::type
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-  ,public safe_mode::safe_container<
-    sequenced_index<SuperMeta,TagList> >
-#endif
-
-{ 
-#if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING)&&\
-    BOOST_WORKAROUND(__MWERKS__,<=0x3003)
-/* The "ISO C++ Template Parser" option in CW8.3 has a problem with the
- * lifetime of const references bound to temporaries --precisely what
- * scopeguards are.
- */
-
-#pragma parse_mfunc_templ off
-#endif
-
-  typedef typename SuperMeta::type                    super;
-
-protected:
-  typedef sequenced_index_node<
-    typename super::node_type>                        node_type;
-
-private:
-  typedef typename node_type::impl_type               node_impl_type;
- 
-public:
-  /* types */
-
-  typedef typename node_type::value_type              value_type;
-  typedef tuples::null_type                           ctor_args;
-  typedef typename super::final_allocator_type        allocator_type;
-  typedef typename allocator_type::reference          reference;
-  typedef typename allocator_type::const_reference    const_reference;
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-  typedef safe_mode::safe_iterator<
-    bidir_node_iterator<node_type>,
-    sequenced_index>                                  iterator;
-#else
-  typedef bidir_node_iterator<node_type>              iterator;
-#endif
-
-  typedef iterator                                    const_iterator;
-
-  typedef std::size_t                                 size_type;      
-  typedef std::ptrdiff_t                              difference_type;
-  typedef typename allocator_type::pointer            pointer;
-  typedef typename allocator_type::const_pointer      const_pointer;
-  typedef typename
-    boost::reverse_iterator<iterator>                 reverse_iterator;
-  typedef typename
-    boost::reverse_iterator<const_iterator>           const_reverse_iterator;
-  typedef TagList                                     tag_list;
-
-protected:
-  typedef typename super::final_node_type     final_node_type;
-  typedef tuples::cons<
-    ctor_args, 
-    typename super::ctor_args_list>           ctor_args_list;
-  typedef typename mpl::push_front<
-    typename super::index_type_list,
-    sequenced_index>::type                    index_type_list;
-  typedef typename mpl::push_front<
-    typename super::iterator_type_list,
-    iterator>::type                           iterator_type_list;
-  typedef typename mpl::push_front<
-    typename super::const_iterator_type_list,
-    const_iterator>::type                     const_iterator_type_list;
-  typedef typename super::copy_map_type       copy_map_type;
-
-#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
-  typedef typename super::index_saver_type    index_saver_type;
-  typedef typename super::index_loader_type   index_loader_type;
-#endif
-
-private:
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-  typedef safe_mode::safe_container<
-    sequenced_index>                          safe_super;
-#endif
-
-  typedef typename call_traits<value_type>::param_type value_param_type;
-
-  /* Needed to avoid commas in BOOST_MULTI_INDEX_OVERLOADS_TO_VARTEMPL
-   * expansion.
-   */
-
-  typedef std::pair<iterator,bool>                     emplace_return_type;
-
-public:
-
-  /* construct/copy/destroy
-   * Default and copy ctors are in the protected section as indices are
-   * not supposed to be created on their own. No range ctor either.
-   */
-
-  sequenced_index<SuperMeta,TagList>& operator=(
-    const sequenced_index<SuperMeta,TagList>& x)
-  {
-    this->final()=x.final();
-    return *this;
-  }
-
-#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
-  sequenced_index<SuperMeta,TagList>& operator=(
-    std::initializer_list<value_type> list)
-  {
-    this->final()=list;
-    return *this;
-  }
-#endif
-
-  template <class InputIterator>
-  void assign(InputIterator first,InputIterator last)
-  {
-    assign_iter(first,last,mpl::not_<is_integral<InputIterator> >());
-  }
-
-#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
-  void assign(std::initializer_list<value_type> list)
-  {
-    assign(list.begin(),list.end());
-  }
-#endif
-
-  void assign(size_type n,value_param_type value)
-  {
-    BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT;
-    clear();
-    for(size_type i=0;i<n;++i)push_back(value);
-  }
-    
-  allocator_type get_allocator()const BOOST_NOEXCEPT
-  {
-    return this->final().get_allocator();
-  }
-
-  /* iterators */
-
-  iterator  begin()BOOST_NOEXCEPT
-    {return make_iterator(node_type::from_impl(header()->next()));}
-  const_iterator begin()const BOOST_NOEXCEPT
-    {return make_iterator(node_type::from_impl(header()->next()));}
-  iterator
-    end()BOOST_NOEXCEPT{return make_iterator(header());}
-  const_iterator
-    end()const BOOST_NOEXCEPT{return make_iterator(header());}
-  reverse_iterator
-    rbegin()BOOST_NOEXCEPT{return boost::make_reverse_iterator(end());}
-  const_reverse_iterator
-    rbegin()const BOOST_NOEXCEPT{return boost::make_reverse_iterator(end());}
-  reverse_iterator
-    rend()BOOST_NOEXCEPT{return boost::make_reverse_iterator(begin());}
-  const_reverse_iterator
-    rend()const BOOST_NOEXCEPT{return boost::make_reverse_iterator(begin());}
-  const_iterator
-    cbegin()const BOOST_NOEXCEPT{return begin();}
-  const_iterator
-    cend()const BOOST_NOEXCEPT{return end();}
-  const_reverse_iterator
-    crbegin()const BOOST_NOEXCEPT{return rbegin();}
-  const_reverse_iterator
-    crend()const BOOST_NOEXCEPT{return rend();}
-
-  iterator iterator_to(const value_type& x)
-  {
-    return make_iterator(node_from_value<node_type>(&x));
-  }
-
-  const_iterator iterator_to(const value_type& x)const
-  {
-    return make_iterator(node_from_value<node_type>(&x));
-  }
-
-  /* capacity */
-
-  bool      empty()const BOOST_NOEXCEPT{return this->final_empty_();}
-  size_type size()const BOOST_NOEXCEPT{return this->final_size_();}
-  size_type max_size()const BOOST_NOEXCEPT{return this->final_max_size_();}
-
-  void resize(size_type n)
-  {
-    BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT;
-    if(n>size()){
-      for(size_type m=n-size();m--;)
-        this->final_emplace_(BOOST_MULTI_INDEX_NULL_PARAM_PACK);
-    }
-    else if(n<size()){for(size_type m=size()-n;m--;)pop_back();}
-  }
-
-  void resize(size_type n,value_param_type x)
-  {
-    BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT;
-    if(n>size())insert(end(),n-size(),x);
-    else if(n<size())for(size_type m=size()-n;m--;)pop_back();
-  }
-
-  /* access: no non-const versions provided as sequenced_index
-   * handles const elements.
-   */
-
-  const_reference front()const{return *begin();}
-  const_reference back()const{return *--end();}
-
-  /* modifiers */
-
-  BOOST_MULTI_INDEX_OVERLOADS_TO_VARTEMPL(
-    emplace_return_type,emplace_front,emplace_front_impl)
-
-  std::pair<iterator,bool> push_front(const value_type& x)
-                             {return insert(begin(),x);}
-  std::pair<iterator,bool> push_front(BOOST_RV_REF(value_type) x)
-                             {return insert(begin(),boost::move(x));}
-  void                     pop_front(){erase(begin());}
-
-  BOOST_MULTI_INDEX_OVERLOADS_TO_VARTEMPL(
-    emplace_return_type,emplace_back,emplace_back_impl)
-
-  std::pair<iterator,bool> push_back(const value_type& x)
-                             {return insert(end(),x);}
-  std::pair<iterator,bool> push_back(BOOST_RV_REF(value_type) x)
-                             {return insert(end(),boost::move(x));}
-  void                     pop_back(){erase(--end());}
-
-  BOOST_MULTI_INDEX_OVERLOADS_TO_VARTEMPL_EXTRA_ARG(
-    emplace_return_type,emplace,emplace_impl,iterator,position)
-
-  std::pair<iterator,bool> insert(iterator position,const value_type& x)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
-    BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT;
-    std::pair<final_node_type*,bool> p=this->final_insert_(x);
-    if(p.second&&position.get_node()!=header()){
-      relink(position.get_node(),p.first);
-    }
-    return std::pair<iterator,bool>(make_iterator(p.first),p.second);
-  }
-
-  std::pair<iterator,bool> insert(iterator position,BOOST_RV_REF(value_type) x)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
-    BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT;
-    std::pair<final_node_type*,bool> p=this->final_insert_rv_(x);
-    if(p.second&&position.get_node()!=header()){
-      relink(position.get_node(),p.first);
-    }
-    return std::pair<iterator,bool>(make_iterator(p.first),p.second);
-  }
-
-  void insert(iterator position,size_type n,value_param_type x)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
-    BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT;
-    for(size_type i=0;i<n;++i)insert(position,x);
-  }
- 
-  template<typename InputIterator>
-  void insert(iterator position,InputIterator first,InputIterator last)
-  {
-    insert_iter(position,first,last,mpl::not_<is_integral<InputIterator> >());
-  }
-
-#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
-  void insert(iterator position,std::initializer_list<value_type> list)
-  {
-    insert(position,list.begin(),list.end());
-  }
-#endif
-
-  iterator erase(iterator position)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
-    BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT;
-    this->final_erase_(static_cast<final_node_type*>(position++.get_node()));
-    return position;
-  }
-  
-  iterator erase(iterator first,iterator last)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(first);
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(last);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(first,*this);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(last,*this);
-    BOOST_MULTI_INDEX_CHECK_VALID_RANGE(first,last);
-    BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT;
-    while(first!=last){
-      first=erase(first);
-    }
-    return first;
-  }
-
-  bool replace(iterator position,const value_type& x)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
-    BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT;
-    return this->final_replace_(
-      x,static_cast<final_node_type*>(position.get_node()));
-  }
-
-  bool replace(iterator position,BOOST_RV_REF(value_type) x)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
-    BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT;
-    return this->final_replace_rv_(
-      x,static_cast<final_node_type*>(position.get_node()));
-  }
-
-  template<typename Modifier>
-  bool modify(iterator position,Modifier mod)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
-    BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT;
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-    /* MSVC++ 6.0 optimizer on safe mode code chokes if this
-     * this is not added. Left it for all compilers as it does no
-     * harm.
-     */
-
-    position.detach();
-#endif
-
-    return this->final_modify_(
-      mod,static_cast<final_node_type*>(position.get_node()));
-  }
-
-  template<typename Modifier,typename Rollback>
-  bool modify(iterator position,Modifier mod,Rollback back_)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
-    BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT;
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-    /* MSVC++ 6.0 optimizer on safe mode code chokes if this
-     * this is not added. Left it for all compilers as it does no
-     * harm.
-     */
-
-    position.detach();
-#endif
-
-    return this->final_modify_(
-      mod,back_,static_cast<final_node_type*>(position.get_node()));
-  }
-
-  void swap(sequenced_index<SuperMeta,TagList>& x)
-  {
-    BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT;
-    BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT_OF(x);
-    this->final_swap_(x.final());
-  }
-
-  void clear()BOOST_NOEXCEPT
-  {
-    BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT;
-    this->final_clear_();
-  }
-
-  /* list operations */
-
-  void splice(iterator position,sequenced_index<SuperMeta,TagList>& x)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
-    BOOST_MULTI_INDEX_CHECK_DIFFERENT_CONTAINER(*this,x);
-    BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT;
-    iterator first=x.begin(),last=x.end();
-    while(first!=last){
-      if(insert(position,*first).second)first=x.erase(first);
-      else ++first;
-    }
-  }
-
-  void splice(iterator position,sequenced_index<SuperMeta,TagList>& x,iterator i)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(i);
-    BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(i);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(i,x);
-    BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT;
-    if(&x==this){
-      if(position!=i)relink(position.get_node(),i.get_node());
-    }
-    else{
-      if(insert(position,*i).second){
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-    /* MSVC++ 6.0 optimizer has a hard time with safe mode, and the following
-     * workaround is needed. Left it for all compilers as it does no
-     * harm.
-     */
-        i.detach();
-        x.erase(x.make_iterator(i.get_node()));
-#else
-        x.erase(i);
-#endif
-
-      }
-    }
-  }
-
-  void splice(
-    iterator position,sequenced_index<SuperMeta,TagList>& x,
-    iterator first,iterator last)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(first);
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(last);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(first,x);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(last,x);
-    BOOST_MULTI_INDEX_CHECK_VALID_RANGE(first,last);
-    BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT;
-    if(&x==this){
-      BOOST_MULTI_INDEX_CHECK_OUTSIDE_RANGE(position,first,last);
-      if(position!=last)relink(
-        position.get_node(),first.get_node(),last.get_node());
-    }
-    else{
-      while(first!=last){
-        if(insert(position,*first).second)first=x.erase(first);
-        else ++first;
-      }
-    }
-  }
-
-  void remove(value_param_type value)
-  {
-    sequenced_index_remove(
-      *this,
-      ::boost::bind(std::equal_to<value_type>(),::boost::arg<1>(),value));
-  }
-
-  template<typename Predicate>
-  void remove_if(Predicate pred)
-  {
-    sequenced_index_remove(*this,pred);
-  }
-
-  void unique()
-  {
-    sequenced_index_unique(*this,std::equal_to<value_type>());
-  }
-
-  template <class BinaryPredicate>
-  void unique(BinaryPredicate binary_pred)
-  {
-    sequenced_index_unique(*this,binary_pred);
-  }
-
-  void merge(sequenced_index<SuperMeta,TagList>& x)
-  {
-    sequenced_index_merge(*this,x,std::less<value_type>());
-  }
-
-  template <typename Compare>
-  void merge(sequenced_index<SuperMeta,TagList>& x,Compare comp)
-  {
-    sequenced_index_merge(*this,x,comp);
-  }
-
-  void sort()
-  {
-    BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT;
-    sequenced_index_sort(header(),std::less<value_type>());
-  }
-
-  template <typename Compare>
-  void sort(Compare comp)
-  {
-    BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT;
-    sequenced_index_sort(header(),comp);
-  }
-
-  void reverse()BOOST_NOEXCEPT
-  {
-    BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT;
-    node_impl_type::reverse(header()->impl());
-  }
-
-  /* rearrange operations */
-
-  void relocate(iterator position,iterator i)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(i);
-    BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(i);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(i,*this);
-    BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT;
-    if(position!=i)relink(position.get_node(),i.get_node());
-  }
-
-  void relocate(iterator position,iterator first,iterator last)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(first);
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(last);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(first,*this);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(last,*this);
-    BOOST_MULTI_INDEX_CHECK_VALID_RANGE(first,last);
-    BOOST_MULTI_INDEX_CHECK_OUTSIDE_RANGE(position,first,last);
-    BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT;
-    if(position!=last)relink(
-      position.get_node(),first.get_node(),last.get_node());
-  }
-    
-  template<typename InputIterator>
-  void rearrange(InputIterator first)
-  {
-    BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT;
-    node_type* pos=header();
-    for(size_type s=size();s--;){
-      const value_type& v=*first++;
-      relink(pos,node_from_value<node_type>(&v));
-    }
-  }
-
-BOOST_MULTI_INDEX_PROTECTED_IF_MEMBER_TEMPLATE_FRIENDS:
-  sequenced_index(const ctor_args_list& args_list,const allocator_type& al):
-    super(args_list.get_tail(),al)
-  {
-    empty_initialize();
-  }
-
-  sequenced_index(const sequenced_index<SuperMeta,TagList>& x):
-    super(x)
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-    ,safe_super()
-#endif
-
-  {
-    /* the actual copying takes place in subsequent call to copy_() */
-  }
-
-  sequenced_index(
-    const sequenced_index<SuperMeta,TagList>& x,do_not_copy_elements_tag):
-    super(x,do_not_copy_elements_tag())
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-    ,safe_super()
-#endif
-
-  {
-    empty_initialize();
-  }
-
-  ~sequenced_index()
-  {
-    /* the container is guaranteed to be empty by now */
-  }
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-  iterator       make_iterator(node_type* node){return iterator(node,this);}
-  const_iterator make_iterator(node_type* node)const
-    {return const_iterator(node,const_cast<sequenced_index*>(this));}
-#else
-  iterator       make_iterator(node_type* node){return iterator(node);}
-  const_iterator make_iterator(node_type* node)const
-                   {return const_iterator(node);}
-#endif
-
-  void copy_(
-    const sequenced_index<SuperMeta,TagList>& x,const copy_map_type& map)
-  {
-    node_type* org=x.header();
-    node_type* cpy=header();
-    do{
-      node_type* next_org=node_type::from_impl(org->next());
-      node_type* next_cpy=map.find(static_cast<final_node_type*>(next_org));
-      cpy->next()=next_cpy->impl();
-      next_cpy->prior()=cpy->impl();
-      org=next_org;
-      cpy=next_cpy;
-    }while(org!=x.header());
-
-    super::copy_(x,map);
-  }
-
-  template<typename Variant>
-  final_node_type* insert_(
-    value_param_type v,final_node_type*& x,Variant variant)
-  {
-    final_node_type* res=super::insert_(v,x,variant);
-    if(res==x)link(static_cast<node_type*>(x));
-    return res;
-  }
-
-  template<typename Variant>
-  final_node_type* insert_(
-    value_param_type v,node_type* position,final_node_type*& x,Variant variant)
-  {
-    final_node_type* res=super::insert_(v,position,x,variant);
-    if(res==x)link(static_cast<node_type*>(x));
-    return res;
-  }
-
-  void erase_(node_type* x)
-  {
-    unlink(x);
-    super::erase_(x);
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-    detach_iterators(x);
-#endif
-  }
-
-  void delete_all_nodes_()
-  {
-    for(node_type* x=node_type::from_impl(header()->next());x!=header();){
-      node_type* y=node_type::from_impl(x->next());
-      this->final_delete_node_(static_cast<final_node_type*>(x));
-      x=y;
-    }
-  }
-
-  void clear_()
-  {
-    super::clear_();
-    empty_initialize();
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-    safe_super::detach_dereferenceable_iterators();
-#endif
-  }
-
-  void swap_(sequenced_index<SuperMeta,TagList>& x)
-  {
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-    safe_super::swap(x);
-#endif
-
-    super::swap_(x);
-  }
-
-  void swap_elements_(sequenced_index<SuperMeta,TagList>& x)
-  {
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-    safe_super::swap(x);
-#endif
-
-    super::swap_elements_(x);
-  }
-
-  template<typename Variant>
-  bool replace_(value_param_type v,node_type* x,Variant variant)
-  {
-    return super::replace_(v,x,variant);
-  }
-
-  bool modify_(node_type* x)
-  {
-    BOOST_TRY{
-      if(!super::modify_(x)){
-        unlink(x);
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-        detach_iterators(x);
-#endif
-
-        return false;
-      }
-      else return true;
-    }
-    BOOST_CATCH(...){
-      unlink(x);
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-      detach_iterators(x);
-#endif
-
-      BOOST_RETHROW;
-    }
-    BOOST_CATCH_END
-  }
-
-  bool modify_rollback_(node_type* x)
-  {
-    return super::modify_rollback_(x);
-  }
-
-#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
-  /* serialization */
-
-  template<typename Archive>
-  void save_(
-    Archive& ar,const unsigned int version,const index_saver_type& sm)const
-  {
-    sm.save(begin(),end(),ar,version);
-    super::save_(ar,version,sm);
-  }
-
-  template<typename Archive>
-  void load_(
-    Archive& ar,const unsigned int version,const index_loader_type& lm)
-  {
-    lm.load(
-      ::boost::bind(
-        &sequenced_index::rearranger,this,::boost::arg<1>(),::boost::arg<2>()),
-      ar,version);
-    super::load_(ar,version,lm);
-  }
-#endif
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING)
-  /* invariant stuff */
-
-  bool invariant_()const
-  {
-    if(size()==0||begin()==end()){
-      if(size()!=0||begin()!=end()||
-         header()->next()!=header()->impl()||
-         header()->prior()!=header()->impl())return false;
-    }
-    else{
-      size_type s=0;
-      for(const_iterator it=begin(),it_end=end();it!=it_end;++it,++s){
-        if(it.get_node()->next()->prior()!=it.get_node()->impl())return false;
-        if(it.get_node()->prior()->next()!=it.get_node()->impl())return false;
-      }
-      if(s!=size())return false;
-    }
-
-    return super::invariant_();
-  }
-
-  /* This forwarding function eases things for the boost::mem_fn construct
-   * in BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT. Actually,
-   * final_check_invariant is already an inherited member function of index.
-   */
-  void check_invariant_()const{this->final_check_invariant_();}
-#endif
-
-private:
-  node_type* header()const{return this->final_header();}
-
-  void empty_initialize()
-  {
-    header()->prior()=header()->next()=header()->impl();
-  }
-
-  void link(node_type* x)
-  {
-    node_impl_type::link(x->impl(),header()->impl());
-  };
-
-  static void unlink(node_type* x)
-  {
-    node_impl_type::unlink(x->impl());
-  }
-
-  static void relink(node_type* position,node_type* x)
-  {
-    node_impl_type::relink(position->impl(),x->impl());
-  }
-
-  static void relink(node_type* position,node_type* first,node_type* last)
-  {
-    node_impl_type::relink(
-      position->impl(),first->impl(),last->impl());
-  }
-
-#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
-  void rearranger(node_type* position,node_type *x)
-  {
-    if(!position)position=header();
-    node_type::increment(position);
-    if(position!=x)relink(position,x);
-  }
-#endif
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-  void detach_iterators(node_type* x)
-  {
-    iterator it=make_iterator(x);
-    safe_mode::detach_equivalent_iterators(it);
-  }
-#endif
-
-  template <class InputIterator>
-  void assign_iter(InputIterator first,InputIterator last,mpl::true_)
-  {
-    BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT;
-    clear();
-    for(;first!=last;++first)this->final_insert_ref_(*first);
-  }
-
-  void assign_iter(size_type n,value_param_type value,mpl::false_)
-  {
-    BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT;
-    clear();
-    for(size_type i=0;i<n;++i)push_back(value);
-  }
-
-  template<typename InputIterator>
-  void insert_iter(
-    iterator position,InputIterator first,InputIterator last,mpl::true_)
-  {
-    BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT;
-    for(;first!=last;++first){
-      std::pair<final_node_type*,bool> p=
-        this->final_insert_ref_(*first);
-      if(p.second&&position.get_node()!=header()){
-        relink(position.get_node(),p.first);
-      }
-    }
-  }
-
-  void insert_iter(
-    iterator position,size_type n,value_param_type x,mpl::false_)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
-    BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT;
-    for(size_type i=0;i<n;++i)insert(position,x);
-  }
-
-  template<BOOST_MULTI_INDEX_TEMPLATE_PARAM_PACK>
-  std::pair<iterator,bool> emplace_front_impl(
-    BOOST_MULTI_INDEX_FUNCTION_PARAM_PACK)
-  {
-    return emplace_impl(begin(),BOOST_MULTI_INDEX_FORWARD_PARAM_PACK);
-  }
-
-  template<BOOST_MULTI_INDEX_TEMPLATE_PARAM_PACK>
-  std::pair<iterator,bool> emplace_back_impl(
-    BOOST_MULTI_INDEX_FUNCTION_PARAM_PACK)
-  {
-    return emplace_impl(end(),BOOST_MULTI_INDEX_FORWARD_PARAM_PACK);
-  }
-
-  template<BOOST_MULTI_INDEX_TEMPLATE_PARAM_PACK>
-  std::pair<iterator,bool> emplace_impl(
-    iterator position,BOOST_MULTI_INDEX_FUNCTION_PARAM_PACK)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
-    BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT;
-    std::pair<final_node_type*,bool> p=
-      this->final_emplace_(BOOST_MULTI_INDEX_FORWARD_PARAM_PACK);
-    if(p.second&&position.get_node()!=header()){
-      relink(position.get_node(),p.first);
-    }
-    return std::pair<iterator,bool>(make_iterator(p.first),p.second);
-  }
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING)&&\
-    BOOST_WORKAROUND(__MWERKS__,<=0x3003)
-#pragma parse_mfunc_templ reset
-#endif
-};
-
-/* comparison */
-
-template<
-  typename SuperMeta1,typename TagList1,
-  typename SuperMeta2,typename TagList2
->
-bool operator==(
-  const sequenced_index<SuperMeta1,TagList1>& x,
-  const sequenced_index<SuperMeta2,TagList2>& y)
-{
-  return x.size()==y.size()&&std::equal(x.begin(),x.end(),y.begin());
-}
-
-template<
-  typename SuperMeta1,typename TagList1,
-  typename SuperMeta2,typename TagList2
->
-bool operator<(
-  const sequenced_index<SuperMeta1,TagList1>& x,
-  const sequenced_index<SuperMeta2,TagList2>& y)
-{
-  return std::lexicographical_compare(x.begin(),x.end(),y.begin(),y.end());
-}
-
-template<
-  typename SuperMeta1,typename TagList1,
-  typename SuperMeta2,typename TagList2
->
-bool operator!=(
-  const sequenced_index<SuperMeta1,TagList1>& x,
-  const sequenced_index<SuperMeta2,TagList2>& y)
-{
-  return !(x==y);
-}
-
-template<
-  typename SuperMeta1,typename TagList1,
-  typename SuperMeta2,typename TagList2
->
-bool operator>(
-  const sequenced_index<SuperMeta1,TagList1>& x,
-  const sequenced_index<SuperMeta2,TagList2>& y)
-{
-  return y<x;
-}
-
-template<
-  typename SuperMeta1,typename TagList1,
-  typename SuperMeta2,typename TagList2
->
-bool operator>=(
-  const sequenced_index<SuperMeta1,TagList1>& x,
-  const sequenced_index<SuperMeta2,TagList2>& y)
-{
-  return !(x<y);
-}
-
-template<
-  typename SuperMeta1,typename TagList1,
-  typename SuperMeta2,typename TagList2
->
-bool operator<=(
-  const sequenced_index<SuperMeta1,TagList1>& x,
-  const sequenced_index<SuperMeta2,TagList2>& y)
-{
-  return !(x>y);
-}
-
-/*  specialized algorithms */
-
-template<typename SuperMeta,typename TagList>
-void swap(
-  sequenced_index<SuperMeta,TagList>& x,
-  sequenced_index<SuperMeta,TagList>& y)
-{
-  x.swap(y);
-}
-
-} /* namespace multi_index::detail */
-
-/* sequenced index specifier */
-
-template <typename TagList>
-struct sequenced
-{
-  BOOST_STATIC_ASSERT(detail::is_tag<TagList>::value);
-
-  template<typename Super>
-  struct node_class
-  {
-    typedef detail::sequenced_index_node<Super> type;
-  };
-
-  template<typename SuperMeta>
-  struct index_class
-  {
-    typedef detail::sequenced_index<SuperMeta,typename TagList::type> type;
-  };
-};
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-/* Boost.Foreach compatibility */
-
-template<typename SuperMeta,typename TagList>
-inline boost::mpl::true_* boost_foreach_is_noncopyable(
-  boost::multi_index::detail::sequenced_index<SuperMeta,TagList>*&,
-  boost_foreach_argument_dependent_lookup_hack)
-{
-  return 0;
-}
-
-#undef BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT
-#undef BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT_OF
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/sequenced_index_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/sequenced_index_fwd.hpp
deleted file mode 100644
index a019f2a6d2f..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/sequenced_index_fwd.hpp
+++ /dev/null
@@ -1,91 +0,0 @@
-/* Copyright 2003-2013 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_SEQUENCED_INDEX_FWD_HPP
-#define BOOST_MULTI_INDEX_SEQUENCED_INDEX_FWD_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/multi_index/tag.hpp>
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-template<typename SuperMeta,typename TagList>
-class sequenced_index;
-
-template<
-  typename SuperMeta1,typename TagList1,
-  typename SuperMeta2,typename TagList2
->
-bool operator==(
-  const sequenced_index<SuperMeta1,TagList1>& x,
-  const sequenced_index<SuperMeta2,TagList2>& y);
-
-template<
-  typename SuperMeta1,typename TagList1,
-  typename SuperMeta2,typename TagList2
->
-bool operator<(
-  const sequenced_index<SuperMeta1,TagList1>& x,
-  const sequenced_index<SuperMeta2,TagList2>& y);
-
-template<
-  typename SuperMeta1,typename TagList1,
-  typename SuperMeta2,typename TagList2
->
-bool operator!=(
-  const sequenced_index<SuperMeta1,TagList1>& x,
-  const sequenced_index<SuperMeta2,TagList2>& y);
-
-template<
-  typename SuperMeta1,typename TagList1,
-  typename SuperMeta2,typename TagList2
->
-bool operator>(
-  const sequenced_index<SuperMeta1,TagList1>& x,
-  const sequenced_index<SuperMeta2,TagList2>& y);
-
-template<
-  typename SuperMeta1,typename TagList1,
-  typename SuperMeta2,typename TagList2
->
-bool operator>=(
-  const sequenced_index<SuperMeta1,TagList1>& x,
-  const sequenced_index<SuperMeta2,TagList2>& y);
-
-template<
-  typename SuperMeta1,typename TagList1,
-  typename SuperMeta2,typename TagList2
->
-bool operator<=(
-  const sequenced_index<SuperMeta1,TagList1>& x,
-  const sequenced_index<SuperMeta2,TagList2>& y);
-
-template<typename SuperMeta,typename TagList>
-void swap(
-  sequenced_index<SuperMeta,TagList>& x,
-  sequenced_index<SuperMeta,TagList>& y);
-
-} /* namespace multi_index::detail */
-
-/* index specifiers */
-
-template <typename TagList=tag<> >
-struct sequenced;
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/tag.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/tag.hpp
deleted file mode 100644
index ce51f8241ee..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/tag.hpp
+++ /dev/null
@@ -1,88 +0,0 @@
-/* Copyright 2003-2013 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_TAG_HPP
-#define BOOST_MULTI_INDEX_TAG_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <boost/multi_index/detail/no_duplicate_tags.hpp>
-#include <boost/mpl/identity.hpp>
-#include <boost/mpl/transform.hpp>
-#include <boost/mpl/vector.hpp>
-#include <boost/preprocessor/facilities/intercept.hpp> 
-#include <boost/preprocessor/repetition/enum_binary_params.hpp> 
-#include <boost/preprocessor/repetition/enum_params.hpp> 
-#include <boost/static_assert.hpp>
-#include <boost/type_traits/is_base_and_derived.hpp>
-
-/* A wrapper of mpl::vector used to hide MPL from the user.
- * tag contains types used as tag names for indices in get() functions.
- */
-
-/* This user_definable macro limits the number of elements of a tag;
- * useful for shortening resulting symbol names (MSVC++ 6.0, for instance,
- * has problems coping with very long symbol names.)
- */
-
-#if !defined(BOOST_MULTI_INDEX_LIMIT_TAG_SIZE)
-#define BOOST_MULTI_INDEX_LIMIT_TAG_SIZE BOOST_MPL_LIMIT_VECTOR_SIZE
-#endif
-
-#if BOOST_MULTI_INDEX_LIMIT_TAG_SIZE<BOOST_MPL_LIMIT_VECTOR_SIZE
-#define BOOST_MULTI_INDEX_TAG_SIZE BOOST_MULTI_INDEX_LIMIT_TAG_SIZE
-#else
-#define BOOST_MULTI_INDEX_TAG_SIZE BOOST_MPL_LIMIT_VECTOR_SIZE
-#endif
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-struct tag_marker{};
-
-template<typename T>
-struct is_tag
-{
-  BOOST_STATIC_CONSTANT(bool,value=(is_base_and_derived<tag_marker,T>::value));
-};
-
-} /* namespace multi_index::detail */
-
-template<
-  BOOST_PP_ENUM_BINARY_PARAMS(
-    BOOST_MULTI_INDEX_TAG_SIZE,
-    typename T,
-    =mpl::na BOOST_PP_INTERCEPT) 
->
-struct tag:private detail::tag_marker
-{
-  /* The mpl::transform pass produces shorter symbols (without
-   * trailing mpl::na's.)
-   */
-
-  typedef typename mpl::transform<
-    mpl::vector<BOOST_PP_ENUM_PARAMS(BOOST_MULTI_INDEX_TAG_SIZE,T)>,
-    mpl::identity<mpl::_1>
-  >::type type;
-
-  BOOST_STATIC_ASSERT(detail::no_duplicate_tags<type>::value);
-};
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#undef BOOST_MULTI_INDEX_TAG_SIZE
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index_container.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index_container.hpp
deleted file mode 100644
index 9993a8dfa10..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index_container.hpp
+++ /dev/null
@@ -1,1362 +0,0 @@
-/* Multiply indexed container.
- *
- * Copyright 2003-2014 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_HPP
-#define BOOST_MULTI_INDEX_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <algorithm>
-#include <boost/detail/allocator_utilities.hpp>
-#include <boost/detail/no_exceptions_support.hpp>
-#include <boost/detail/workaround.hpp>
-#include <boost/move/core.hpp>
-#include <boost/mpl/at.hpp>
-#include <boost/mpl/contains.hpp>
-#include <boost/mpl/find_if.hpp>
-#include <boost/mpl/identity.hpp>
-#include <boost/mpl/int.hpp>
-#include <boost/mpl/size.hpp>
-#include <boost/mpl/deref.hpp>
-#include <boost/multi_index_container_fwd.hpp>
-#include <boost/multi_index/detail/access_specifier.hpp>
-#include <boost/multi_index/detail/adl_swap.hpp>
-#include <boost/multi_index/detail/base_type.hpp>
-#include <boost/multi_index/detail/do_not_copy_elements_tag.hpp>
-#include <boost/multi_index/detail/converter.hpp>
-#include <boost/multi_index/detail/header_holder.hpp>
-#include <boost/multi_index/detail/has_tag.hpp>
-#include <boost/multi_index/detail/no_duplicate_tags.hpp>
-#include <boost/multi_index/detail/safe_mode.hpp>
-#include <boost/multi_index/detail/scope_guard.hpp>
-#include <boost/multi_index/detail/vartempl_support.hpp>
-#include <boost/static_assert.hpp>
-#include <boost/type_traits/is_same.hpp>
-#include <boost/utility/base_from_member.hpp>
-
-#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
-#include <initializer_list>
-#endif
-
-#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
-#include <boost/multi_index/detail/archive_constructed.hpp>
-#include <boost/multi_index/detail/serialization_version.hpp>
-#include <boost/serialization/collection_size_type.hpp>
-#include <boost/serialization/nvp.hpp>
-#include <boost/serialization/split_member.hpp>
-#include <boost/serialization/version.hpp>
-#include <boost/throw_exception.hpp> 
-#endif
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING)
-#include <boost/multi_index/detail/invariant_assert.hpp>
-#define BOOST_MULTI_INDEX_CHECK_INVARIANT_OF(x)                              \
-  detail::scope_guard BOOST_JOIN(check_invariant_,__LINE__)=                 \
-    detail::make_obj_guard(x,&multi_index_container::check_invariant_);      \
-  BOOST_JOIN(check_invariant_,__LINE__).touch();
-#define BOOST_MULTI_INDEX_CHECK_INVARIANT                                    \
-  BOOST_MULTI_INDEX_CHECK_INVARIANT_OF(*this)
-#else
-#define BOOST_MULTI_INDEX_CHECK_INVARIANT_OF(x)
-#define BOOST_MULTI_INDEX_CHECK_INVARIANT
-#endif
-
-namespace boost{
-
-namespace multi_index{
-
-#if BOOST_WORKAROUND(BOOST_MSVC,BOOST_TESTED_AT(1500))
-#pragma warning(push)
-#pragma warning(disable:4522) /* spurious warning on multiple operator=()'s */
-#endif
-
-template<typename Value,typename IndexSpecifierList,typename Allocator>
-class multi_index_container:
-  private ::boost::base_from_member<
-    typename boost::detail::allocator::rebind_to<
-      Allocator,
-      typename detail::multi_index_node_type<
-        Value,IndexSpecifierList,Allocator>::type
-    >::type>,
-  BOOST_MULTI_INDEX_PRIVATE_IF_MEMBER_TEMPLATE_FRIENDS detail::header_holder<
-    typename boost::detail::allocator::rebind_to<
-      Allocator,
-      typename detail::multi_index_node_type<
-        Value,IndexSpecifierList,Allocator>::type
-    >::type::pointer,
-    multi_index_container<Value,IndexSpecifierList,Allocator> >,
-  public detail::multi_index_base_type<
-    Value,IndexSpecifierList,Allocator>::type
-{
-#if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING)&&\
-    BOOST_WORKAROUND(__MWERKS__,<=0x3003)
-/* The "ISO C++ Template Parser" option in CW8.3 has a problem with the
- * lifetime of const references bound to temporaries --precisely what
- * scopeguards are.
- */
-
-#pragma parse_mfunc_templ off
-#endif
-
-private:
-  BOOST_COPYABLE_AND_MOVABLE(multi_index_container)
-
-#if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
-  template <typename,typename,typename> friend class  detail::index_base;
-  template <typename,typename>          friend struct detail::header_holder;
-  template <typename,typename>          friend struct detail::converter;
-#endif
-
-  typedef typename detail::multi_index_base_type<
-      Value,IndexSpecifierList,Allocator>::type   super;
-  typedef typename
-  boost::detail::allocator::rebind_to<
-    Allocator,
-    typename super::node_type
-  >::type                                         node_allocator;
-  typedef ::boost::base_from_member<
-    node_allocator>                               bfm_allocator;
-  typedef detail::header_holder<
-    typename node_allocator::pointer,
-    multi_index_container>                        bfm_header;
-
-
-public:
-  /* All types are inherited from super, a few are explicitly
-   * brought forward here to save us some typename's.
-   */
-
-  typedef typename super::ctor_args_list           ctor_args_list;
-  typedef IndexSpecifierList                       index_specifier_type_list;
- 
-  typedef typename super::index_type_list          index_type_list;
-
-  typedef typename super::iterator_type_list       iterator_type_list;
-  typedef typename super::const_iterator_type_list const_iterator_type_list;
-  typedef typename super::value_type               value_type;
-  typedef typename super::final_allocator_type     allocator_type;
-  typedef typename super::iterator                 iterator;
-  typedef typename super::const_iterator           const_iterator;
-
-  BOOST_STATIC_ASSERT(
-    detail::no_duplicate_tags_in_index_list<index_type_list>::value);
-
-  /* global project() needs to see this publicly */
-
-  typedef typename super::node_type node_type;
-
-  /* construct/copy/destroy */
-
-  explicit multi_index_container(
-
-#if BOOST_WORKAROUND(__IBMCPP__,<=600)
-    /* VisualAge seems to have an ETI issue with the default values
-     * for arguments args_list and al.
-     */
-
-    const ctor_args_list& args_list=
-      typename mpl::identity<multi_index_container>::type::
-        ctor_args_list(),
-    const allocator_type& al=
-      typename mpl::identity<multi_index_container>::type::
-        allocator_type()):
-#else
-    const ctor_args_list& args_list=ctor_args_list(),
-    const allocator_type& al=allocator_type()):
-#endif
-
-    bfm_allocator(al),
-    super(args_list,bfm_allocator::member),
-    node_count(0)
-  {
-    BOOST_MULTI_INDEX_CHECK_INVARIANT;
-  }
-
-  explicit multi_index_container(const allocator_type& al):
-    bfm_allocator(al),
-    super(ctor_args_list(),bfm_allocator::member),
-    node_count(0)
-  {
-    BOOST_MULTI_INDEX_CHECK_INVARIANT;
-  }
-  
-  template<typename InputIterator>
-  multi_index_container(
-    InputIterator first,InputIterator last,
-
-#if BOOST_WORKAROUND(__IBMCPP__,<=600)
-    /* VisualAge seems to have an ETI issue with the default values
-     * for arguments args_list and al.
-     */
-
-    const ctor_args_list& args_list=
-      typename mpl::identity<multi_index_container>::type::
-        ctor_args_list(),
-    const allocator_type& al=
-      typename mpl::identity<multi_index_container>::type::
-        allocator_type()):
-#else
-    const ctor_args_list& args_list=ctor_args_list(),
-    const allocator_type& al=allocator_type()):
-#endif
-
-    bfm_allocator(al),
-    super(args_list,bfm_allocator::member),
-    node_count(0)
-  {
-    BOOST_MULTI_INDEX_CHECK_INVARIANT;
-    BOOST_TRY{
-      iterator hint=super::end();
-      for(;first!=last;++first){
-        hint=super::make_iterator(
-          insert_ref_(*first,hint.get_node()).first);
-        ++hint;
-      }
-    }
-    BOOST_CATCH(...){
-      clear_();
-      BOOST_RETHROW;
-    }
-    BOOST_CATCH_END
-  }
-
-#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
-  multi_index_container(
-    std::initializer_list<Value> list,
-    const ctor_args_list& args_list=ctor_args_list(),
-    const allocator_type& al=allocator_type()):
-    bfm_allocator(al),
-    super(args_list,bfm_allocator::member),
-    node_count(0)
-  {
-    BOOST_MULTI_INDEX_CHECK_INVARIANT;
-    BOOST_TRY{
-      typedef const Value* init_iterator;
-
-      iterator hint=super::end();
-      for(init_iterator first=list.begin(),last=list.end();
-          first!=last;++first){
-        hint=super::make_iterator(insert_(*first,hint.get_node()).first);
-        ++hint;
-      }
-    }
-    BOOST_CATCH(...){
-      clear_();
-      BOOST_RETHROW;
-    }
-    BOOST_CATCH_END
-  }
-#endif
-
-  multi_index_container(
-    const multi_index_container<Value,IndexSpecifierList,Allocator>& x):
-    bfm_allocator(x.bfm_allocator::member),
-    bfm_header(),
-    super(x),
-    node_count(0)
-  {
-    copy_map_type map(bfm_allocator::member,x.size(),x.header(),header());
-    for(const_iterator it=x.begin(),it_end=x.end();it!=it_end;++it){
-      map.clone(it.get_node());
-    }
-    super::copy_(x,map);
-    map.release();
-    node_count=x.size();
-
-    /* Not until this point are the indices required to be consistent,
-     * hence the position of the invariant checker.
-     */
-
-    BOOST_MULTI_INDEX_CHECK_INVARIANT;
-  }
-
-  multi_index_container(BOOST_RV_REF(multi_index_container) x):
-    bfm_allocator(x.bfm_allocator::member),
-    bfm_header(),
-    super(x,detail::do_not_copy_elements_tag()),
-    node_count(0)
-  {
-    BOOST_MULTI_INDEX_CHECK_INVARIANT;
-    BOOST_MULTI_INDEX_CHECK_INVARIANT_OF(x);
-    swap_elements_(x);
-  }
-
-  ~multi_index_container()
-  {
-    delete_all_nodes_();
-  }
-
-#if defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-  /* As per http://www.boost.org/doc/html/move/emulation_limitations.html
-   * #move.emulation_limitations.assignment_operator
-   */
-
-  multi_index_container<Value,IndexSpecifierList,Allocator>& operator=(
-    const multi_index_container<Value,IndexSpecifierList,Allocator>& x)
-  {
-    multi_index_container y(x);
-    this->swap(y);
-    return *this;
-  }
-#endif
-
-  multi_index_container<Value,IndexSpecifierList,Allocator>& operator=(
-    BOOST_COPY_ASSIGN_REF(multi_index_container) x)
-  {
-    multi_index_container y(x);
-    this->swap(y);
-    return *this;
-  }
-
-  multi_index_container<Value,IndexSpecifierList,Allocator>& operator=(
-    BOOST_RV_REF(multi_index_container) x)
-  {
-    this->swap(x);
-    return *this;
-  }
-
-#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
-  multi_index_container<Value,IndexSpecifierList,Allocator>& operator=(
-    std::initializer_list<Value> list)
-  {
-    BOOST_MULTI_INDEX_CHECK_INVARIANT;
-    typedef const Value* init_iterator;
-
-    multi_index_container x(*this,detail::do_not_copy_elements_tag());    
-    iterator hint=x.end();
-    for(init_iterator first=list.begin(),last=list.end();
-        first!=last;++first){
-      hint=x.make_iterator(x.insert_(*first,hint.get_node()).first);
-      ++hint;
-    }
-    x.swap_elements_(*this);
-    return*this;
-  }
-#endif
-
-  allocator_type get_allocator()const BOOST_NOEXCEPT
-  {
-    return allocator_type(bfm_allocator::member);
-  }
-
-  /* retrieval of indices by number */
-
-#if !defined(BOOST_NO_MEMBER_TEMPLATES)
-  template<int N>
-  struct nth_index
-  {
-    BOOST_STATIC_ASSERT(N>=0&&N<mpl::size<index_type_list>::type::value);
-    typedef typename mpl::at_c<index_type_list,N>::type type;
-  };
-
-  template<int N>
-  typename nth_index<N>::type& get()BOOST_NOEXCEPT
-  {
-    BOOST_STATIC_ASSERT(N>=0&&N<mpl::size<index_type_list>::type::value);
-    return *this;
-  }
-
-  template<int N>
-  const typename nth_index<N>::type& get()const BOOST_NOEXCEPT
-  {
-    BOOST_STATIC_ASSERT(N>=0&&N<mpl::size<index_type_list>::type::value);
-    return *this;
-  }
-#endif
-
-  /* retrieval of indices by tag */
-
-#if !defined(BOOST_NO_MEMBER_TEMPLATES)
-  template<typename Tag>
-  struct index
-  {
-    typedef typename mpl::find_if<
-      index_type_list,
-      detail::has_tag<Tag>
-    >::type                                    iter;
-
-    BOOST_STATIC_CONSTANT(
-      bool,index_found=!(is_same<iter,typename mpl::end<index_type_list>::type >::value));
-    BOOST_STATIC_ASSERT(index_found);
-
-    typedef typename mpl::deref<iter>::type    type;
-  };
-
-  template<typename Tag>
-  typename index<Tag>::type& get()BOOST_NOEXCEPT
-  {
-    return *this;
-  }
-
-  template<typename Tag>
-  const typename index<Tag>::type& get()const BOOST_NOEXCEPT
-  {
-    return *this;
-  }
-#endif
-
-  /* projection of iterators by number */
-
-#if !defined(BOOST_NO_MEMBER_TEMPLATES)
-  template<int N>
-  struct nth_index_iterator
-  {
-    typedef typename nth_index<N>::type::iterator type;
-  };
-
-  template<int N>
-  struct nth_index_const_iterator
-  {
-    typedef typename nth_index<N>::type::const_iterator type;
-  };
-
-  template<int N,typename IteratorType>
-  typename nth_index_iterator<N>::type project(IteratorType it)
-  {
-    typedef typename nth_index<N>::type index_type;
-
-#if !defined(__SUNPRO_CC)||!(__SUNPRO_CC<0x580) /* fails in Sun C++ 5.7 */
-    BOOST_STATIC_ASSERT(
-      (mpl::contains<iterator_type_list,IteratorType>::value));
-#endif
-
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(it);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(
-      it,static_cast<typename IteratorType::container_type&>(*this));
-
-    return index_type::make_iterator(static_cast<node_type*>(it.get_node()));
-  }
-
-  template<int N,typename IteratorType>
-  typename nth_index_const_iterator<N>::type project(IteratorType it)const
-  {
-    typedef typename nth_index<N>::type index_type;
-
-#if !defined(__SUNPRO_CC)||!(__SUNPRO_CC<0x580) /* fails in Sun C++ 5.7 */
-    BOOST_STATIC_ASSERT((
-      mpl::contains<iterator_type_list,IteratorType>::value||
-      mpl::contains<const_iterator_type_list,IteratorType>::value));
-#endif
-
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(it);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(
-      it,static_cast<const typename IteratorType::container_type&>(*this));
-    return index_type::make_iterator(static_cast<node_type*>(it.get_node()));
-  }
-#endif
-
-  /* projection of iterators by tag */
-
-#if !defined(BOOST_NO_MEMBER_TEMPLATES)
-  template<typename Tag>
-  struct index_iterator
-  {
-    typedef typename index<Tag>::type::iterator type;
-  };
-
-  template<typename Tag>
-  struct index_const_iterator
-  {
-    typedef typename index<Tag>::type::const_iterator type;
-  };
-
-  template<typename Tag,typename IteratorType>
-  typename index_iterator<Tag>::type project(IteratorType it)
-  {
-    typedef typename index<Tag>::type index_type;
-
-#if !defined(__SUNPRO_CC)||!(__SUNPRO_CC<0x580) /* fails in Sun C++ 5.7 */
-    BOOST_STATIC_ASSERT(
-      (mpl::contains<iterator_type_list,IteratorType>::value));
-#endif
-
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(it);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(
-      it,static_cast<typename IteratorType::container_type&>(*this));
-    return index_type::make_iterator(static_cast<node_type*>(it.get_node()));
-  }
-
-  template<typename Tag,typename IteratorType>
-  typename index_const_iterator<Tag>::type project(IteratorType it)const
-  {
-    typedef typename index<Tag>::type index_type;
-
-#if !defined(__SUNPRO_CC)||!(__SUNPRO_CC<0x580) /* fails in Sun C++ 5.7 */
-    BOOST_STATIC_ASSERT((
-      mpl::contains<iterator_type_list,IteratorType>::value||
-      mpl::contains<const_iterator_type_list,IteratorType>::value));
-#endif
-
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(it);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(
-      it,static_cast<const typename IteratorType::container_type&>(*this));
-    return index_type::make_iterator(static_cast<node_type*>(it.get_node()));
-  }
-#endif
-
-BOOST_MULTI_INDEX_PROTECTED_IF_MEMBER_TEMPLATE_FRIENDS:
-  typedef typename super::copy_map_type copy_map_type;
-
-#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
-  multi_index_container(
-    const multi_index_container<Value,IndexSpecifierList,Allocator>& x,
-    detail::do_not_copy_elements_tag):
-    bfm_allocator(x.bfm_allocator::member),
-    bfm_header(),
-    super(x,detail::do_not_copy_elements_tag()),
-    node_count(0)
-  {
-    BOOST_MULTI_INDEX_CHECK_INVARIANT;
-  }
-#endif
-
-  node_type* header()const
-  {
-    return &*bfm_header::member;
-  }
-
-  node_type* allocate_node()
-  {
-    return &*bfm_allocator::member.allocate(1);
-  }
-
-  void deallocate_node(node_type* x)
-  {
-    typedef typename node_allocator::pointer node_pointer;
-    bfm_allocator::member.deallocate(static_cast<node_pointer>(x),1);
-  }
-
-  bool empty_()const
-  {
-    return node_count==0;
-  }
-
-  std::size_t size_()const
-  {
-    return node_count;
-  }
-
-  std::size_t max_size_()const
-  {
-    return static_cast<std::size_t >(-1);
-  }
-
-  template<typename Variant>
-  std::pair<node_type*,bool> insert_(const Value& v,Variant variant)
-  {
-    node_type* x=0;
-    node_type* res=super::insert_(v,x,variant);
-    if(res==x){
-      ++node_count;
-      return std::pair<node_type*,bool>(res,true);
-    }
-    else{
-      return std::pair<node_type*,bool>(res,false);
-    }
-  }
-
-  std::pair<node_type*,bool> insert_(const Value& v)
-  {
-    return insert_(v,detail::lvalue_tag());
-  }
-
-  std::pair<node_type*,bool> insert_rv_(const Value& v)
-  {
-    return insert_(v,detail::rvalue_tag());
-  }
-
-  template<typename T>
-  std::pair<node_type*,bool> insert_ref_(T& t)
-  {
-    node_type* x=allocate_node();
-    BOOST_TRY{
-      new(&x->value()) value_type(t);
-      BOOST_TRY{
-        node_type* res=super::insert_(x->value(),x,detail::emplaced_tag());
-        if(res==x){
-          ++node_count;
-          return std::pair<node_type*,bool>(res,true);
-        }
-        else{
-          boost::detail::allocator::destroy(&x->value());
-          deallocate_node(x);
-          return std::pair<node_type*,bool>(res,false);
-        }
-      }
-      BOOST_CATCH(...){
-        boost::detail::allocator::destroy(&x->value());
-        BOOST_RETHROW;
-      }
-      BOOST_CATCH_END
-    }
-    BOOST_CATCH(...){
-      deallocate_node(x);
-      BOOST_RETHROW;
-    }
-    BOOST_CATCH_END
-  }
-
-  std::pair<node_type*,bool> insert_ref_(const value_type& x)
-  {
-    return insert_(x);
-  }
-
-  std::pair<node_type*,bool> insert_ref_(value_type& x)
-  {
-    return insert_(x);
-  }
-
-  template<BOOST_MULTI_INDEX_TEMPLATE_PARAM_PACK>
-  std::pair<node_type*,bool> emplace_(
-    BOOST_MULTI_INDEX_FUNCTION_PARAM_PACK)
-  {
-    node_type* x=allocate_node();
-    BOOST_TRY{
-      detail::vartempl_placement_new(
-        &x->value(),BOOST_MULTI_INDEX_FORWARD_PARAM_PACK);
-      BOOST_TRY{
-        node_type* res=super::insert_(x->value(),x,detail::emplaced_tag());
-        if(res==x){
-          ++node_count;
-          return std::pair<node_type*,bool>(res,true);
-        }
-        else{
-          boost::detail::allocator::destroy(&x->value());
-          deallocate_node(x);
-          return std::pair<node_type*,bool>(res,false);
-        }
-      }
-      BOOST_CATCH(...){
-        boost::detail::allocator::destroy(&x->value());
-        BOOST_RETHROW;
-      }
-      BOOST_CATCH_END
-    }
-    BOOST_CATCH(...){
-      deallocate_node(x);
-      BOOST_RETHROW;
-    }
-    BOOST_CATCH_END
-  }
-
-  template<typename Variant>
-  std::pair<node_type*,bool> insert_(
-    const Value& v,node_type* position,Variant variant)
-  {
-    node_type* x=0;
-    node_type* res=super::insert_(v,position,x,variant);
-    if(res==x){
-      ++node_count;
-      return std::pair<node_type*,bool>(res,true);
-    }
-    else{
-      return std::pair<node_type*,bool>(res,false);
-    }
-  }
-
-  std::pair<node_type*,bool> insert_(const Value& v,node_type* position)
-  {
-    return insert_(v,position,detail::lvalue_tag());
-  }
-
-  std::pair<node_type*,bool> insert_rv_(const Value& v,node_type* position)
-  {
-    return insert_(v,position,detail::rvalue_tag());
-  }
-
-  template<typename T>
-  std::pair<node_type*,bool> insert_ref_(
-    T& t,node_type* position)
-  {
-    node_type* x=allocate_node();
-    BOOST_TRY{
-      new(&x->value()) value_type(t);
-      BOOST_TRY{
-        node_type* res=super::insert_(
-          x->value(),position,x,detail::emplaced_tag());
-        if(res==x){
-          ++node_count;
-          return std::pair<node_type*,bool>(res,true);
-        }
-        else{
-          boost::detail::allocator::destroy(&x->value());
-          deallocate_node(x);
-          return std::pair<node_type*,bool>(res,false);
-        }
-      }
-      BOOST_CATCH(...){
-        boost::detail::allocator::destroy(&x->value());
-        BOOST_RETHROW;
-      }
-      BOOST_CATCH_END
-    }
-    BOOST_CATCH(...){
-      deallocate_node(x);
-      BOOST_RETHROW;
-    }
-    BOOST_CATCH_END
-  }
-
-  std::pair<node_type*,bool> insert_ref_(
-    const value_type& x,node_type* position)
-  {
-    return insert_(x,position);
-  }
-
-  std::pair<node_type*,bool> insert_ref_(
-    value_type& x,node_type* position)
-  {
-    return insert_(x,position);
-  }
-
-  template<BOOST_MULTI_INDEX_TEMPLATE_PARAM_PACK>
-  std::pair<node_type*,bool> emplace_hint_(
-    node_type* position,
-    BOOST_MULTI_INDEX_FUNCTION_PARAM_PACK)
-  {
-    node_type* x=allocate_node();
-    BOOST_TRY{
-      detail::vartempl_placement_new(
-        &x->value(),BOOST_MULTI_INDEX_FORWARD_PARAM_PACK);
-      BOOST_TRY{
-        node_type* res=super::insert_(
-          x->value(),position,x,detail::emplaced_tag());
-        if(res==x){
-          ++node_count;
-          return std::pair<node_type*,bool>(res,true);
-        }
-        else{
-          boost::detail::allocator::destroy(&x->value());
-          deallocate_node(x);
-          return std::pair<node_type*,bool>(res,false);
-        }
-      }
-      BOOST_CATCH(...){
-        boost::detail::allocator::destroy(&x->value());
-        BOOST_RETHROW;
-      }
-      BOOST_CATCH_END
-    }
-    BOOST_CATCH(...){
-      deallocate_node(x);
-      BOOST_RETHROW;
-    }
-    BOOST_CATCH_END
-  }
-
-  void erase_(node_type* x)
-  {
-    --node_count;
-    super::erase_(x);
-    deallocate_node(x);
-  }
-
-  void delete_node_(node_type* x)
-  {
-    super::delete_node_(x);
-    deallocate_node(x);
-  }
-
-  void delete_all_nodes_()
-  {
-    super::delete_all_nodes_();
-  }
-
-  void clear_()
-  {
-    delete_all_nodes_();
-    super::clear_();
-    node_count=0;
-  }
-
-  void swap_(multi_index_container<Value,IndexSpecifierList,Allocator>& x)
-  {
-    if(bfm_allocator::member!=x.bfm_allocator::member){
-      detail::adl_swap(bfm_allocator::member,x.bfm_allocator::member);
-    }
-    std::swap(bfm_header::member,x.bfm_header::member);
-    super::swap_(x);
-    std::swap(node_count,x.node_count);
-  }
-
-  void swap_elements_(
-    multi_index_container<Value,IndexSpecifierList,Allocator>& x)
-  {
-    std::swap(bfm_header::member,x.bfm_header::member);
-    super::swap_elements_(x);
-    std::swap(node_count,x.node_count);
-  }
-
-  bool replace_(const Value& k,node_type* x)
-  {
-    return super::replace_(k,x,detail::lvalue_tag());
-  }
-
-  bool replace_rv_(const Value& k,node_type* x)
-  {
-    return super::replace_(k,x,detail::rvalue_tag());
-  }
-
-  template<typename Modifier>
-  bool modify_(Modifier& mod,node_type* x)
-  {
-    mod(const_cast<value_type&>(x->value()));
-
-    BOOST_TRY{
-      if(!super::modify_(x)){
-        deallocate_node(x);
-        --node_count;
-        return false;
-      }
-      else return true;
-    }
-    BOOST_CATCH(...){
-      deallocate_node(x);
-      --node_count;
-      BOOST_RETHROW;
-    }
-    BOOST_CATCH_END
-  }
-
-  template<typename Modifier,typename Rollback>
-  bool modify_(Modifier& mod,Rollback& back_,node_type* x)
-  {
-    mod(const_cast<value_type&>(x->value()));
-
-    bool b;
-    BOOST_TRY{
-      b=super::modify_rollback_(x);
-    }
-    BOOST_CATCH(...){
-      BOOST_TRY{
-        back_(const_cast<value_type&>(x->value()));
-        BOOST_RETHROW;
-      }
-      BOOST_CATCH(...){
-        this->erase_(x);
-        BOOST_RETHROW;
-      }
-      BOOST_CATCH_END
-    }
-    BOOST_CATCH_END
-
-    BOOST_TRY{
-      if(!b){
-        back_(const_cast<value_type&>(x->value()));
-        return false;
-      }
-      else return true;
-    }
-    BOOST_CATCH(...){
-      this->erase_(x);
-      BOOST_RETHROW;
-    }
-    BOOST_CATCH_END
-  }
-
-#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
-  /* serialization */
-
-  friend class boost::serialization::access;
-
-  BOOST_SERIALIZATION_SPLIT_MEMBER()
-
-  typedef typename super::index_saver_type        index_saver_type;
-  typedef typename super::index_loader_type       index_loader_type;
-
-  template<class Archive>
-  void save(Archive& ar,const unsigned int version)const
-  {
-    const serialization::collection_size_type       s(size_());
-    const detail::serialization_version<value_type> value_version;
-    ar<<serialization::make_nvp("count",s);
-    ar<<serialization::make_nvp("value_version",value_version);
-
-    index_saver_type sm(bfm_allocator::member,s);
-
-    for(iterator it=super::begin(),it_end=super::end();it!=it_end;++it){
-      serialization::save_construct_data_adl(ar,&*it,value_version);
-      ar<<serialization::make_nvp("item",*it);
-      sm.add(it.get_node(),ar,version);
-    }
-    sm.add_track(header(),ar,version);
-
-    super::save_(ar,version,sm);
-  }
-
-  template<class Archive>
-  void load(Archive& ar,const unsigned int version)
-  {
-    BOOST_MULTI_INDEX_CHECK_INVARIANT;
-
-    clear_(); 
-    serialization::collection_size_type       s;
-    detail::serialization_version<value_type> value_version;
-    if(version<1){
-      std::size_t sz;
-      ar>>serialization::make_nvp("count",sz);
-      s=static_cast<serialization::collection_size_type>(sz);
-    }
-    else{
-      ar>>serialization::make_nvp("count",s);
-    }
-    if(version<2){
-      value_version=0;
-    }
-    else{
-      ar>>serialization::make_nvp("value_version",value_version);
-    }
-
-    index_loader_type lm(bfm_allocator::member,s);
-
-    for(std::size_t n=0;n<s;++n){
-      detail::archive_constructed<Value> value("item",ar,value_version);
-      std::pair<node_type*,bool> p=insert_(
-        value.get(),super::end().get_node());
-      if(!p.second)throw_exception(
-        archive::archive_exception(
-          archive::archive_exception::other_exception));
-      ar.reset_object_address(&p.first->value(),&value.get());
-      lm.add(p.first,ar,version);
-    }
-    lm.add_track(header(),ar,version);
-
-    super::load_(ar,version,lm);
-  }
-#endif
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING)
-  /* invariant stuff */
-
-  bool invariant_()const
-  {
-    return super::invariant_();
-  }
-
-  void check_invariant_()const
-  {
-    BOOST_MULTI_INDEX_INVARIANT_ASSERT(invariant_());
-  }
-#endif
-
-private:
-  std::size_t node_count;
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING)&&\
-    BOOST_WORKAROUND(__MWERKS__,<=0x3003)
-#pragma parse_mfunc_templ reset
-#endif
-};
-
-#if BOOST_WORKAROUND(BOOST_MSVC,BOOST_TESTED_AT(1500))
-#pragma warning(pop) /* C4522 */
-#endif
-
-/* retrieval of indices by number */
-
-template<typename MultiIndexContainer,int N>
-struct nth_index
-{
-  BOOST_STATIC_CONSTANT(
-    int,
-    M=mpl::size<typename MultiIndexContainer::index_type_list>::type::value);
-  BOOST_STATIC_ASSERT(N>=0&&N<M);
-  typedef typename mpl::at_c<
-    typename MultiIndexContainer::index_type_list,N>::type type;
-};
-
-template<int N,typename Value,typename IndexSpecifierList,typename Allocator>
-typename nth_index<
-  multi_index_container<Value,IndexSpecifierList,Allocator>,N>::type&
-get(
-  multi_index_container<Value,IndexSpecifierList,Allocator>& m)BOOST_NOEXCEPT
-{
-  typedef multi_index_container<
-    Value,IndexSpecifierList,Allocator>    multi_index_type;
-  typedef typename nth_index<
-    multi_index_container<
-      Value,IndexSpecifierList,Allocator>,
-    N
-  >::type                                  index_type;
-
-  BOOST_STATIC_ASSERT(N>=0&&
-    N<
-    mpl::size<
-      BOOST_DEDUCED_TYPENAME multi_index_type::index_type_list
-    >::type::value);
-
-  return detail::converter<multi_index_type,index_type>::index(m);
-}
-
-template<int N,typename Value,typename IndexSpecifierList,typename Allocator>
-const typename nth_index<
-  multi_index_container<Value,IndexSpecifierList,Allocator>,N>::type&
-get(
-  const multi_index_container<Value,IndexSpecifierList,Allocator>& m
-)BOOST_NOEXCEPT
-{
-  typedef multi_index_container<
-    Value,IndexSpecifierList,Allocator>    multi_index_type;
-  typedef typename nth_index<
-    multi_index_container<
-      Value,IndexSpecifierList,Allocator>,
-    N
-  >::type                                  index_type;
-
-  BOOST_STATIC_ASSERT(N>=0&&
-    N<
-    mpl::size<
-      BOOST_DEDUCED_TYPENAME multi_index_type::index_type_list
-    >::type::value);
-
-  return detail::converter<multi_index_type,index_type>::index(m);
-}
-
-/* retrieval of indices by tag */
-
-template<typename MultiIndexContainer,typename Tag>
-struct index
-{
-  typedef typename MultiIndexContainer::index_type_list index_type_list;
-
-  typedef typename mpl::find_if<
-    index_type_list,
-    detail::has_tag<Tag>
-  >::type                                      iter;
-
-  BOOST_STATIC_CONSTANT(
-    bool,index_found=!(is_same<iter,typename mpl::end<index_type_list>::type >::value));
-  BOOST_STATIC_ASSERT(index_found);
-
-  typedef typename mpl::deref<iter>::type       type;
-};
-
-template<
-  typename Tag,typename Value,typename IndexSpecifierList,typename Allocator
->
-typename ::boost::multi_index::index<
-  multi_index_container<Value,IndexSpecifierList,Allocator>,Tag>::type&
-get(
-  multi_index_container<Value,IndexSpecifierList,Allocator>& m)BOOST_NOEXCEPT
-{
-  typedef multi_index_container<
-    Value,IndexSpecifierList,Allocator>         multi_index_type;
-  typedef typename ::boost::multi_index::index<
-    multi_index_container<
-      Value,IndexSpecifierList,Allocator>,
-    Tag
-  >::type                                       index_type;
-
-  return detail::converter<multi_index_type,index_type>::index(m);
-}
-
-template<
-  typename Tag,typename Value,typename IndexSpecifierList,typename Allocator
->
-const typename ::boost::multi_index::index<
-  multi_index_container<Value,IndexSpecifierList,Allocator>,Tag>::type&
-get(
-  const multi_index_container<Value,IndexSpecifierList,Allocator>& m
-)BOOST_NOEXCEPT
-{
-  typedef multi_index_container<
-    Value,IndexSpecifierList,Allocator>         multi_index_type;
-  typedef typename ::boost::multi_index::index<
-    multi_index_container<
-      Value,IndexSpecifierList,Allocator>,
-    Tag
-  >::type                                       index_type;
-
-  return detail::converter<multi_index_type,index_type>::index(m);
-}
-
-/* projection of iterators by number */
-
-template<typename MultiIndexContainer,int N>
-struct nth_index_iterator
-{
-  typedef typename nth_index<MultiIndexContainer,N>::type::iterator type;
-};
-
-template<typename MultiIndexContainer,int N>
-struct nth_index_const_iterator
-{
-  typedef typename nth_index<MultiIndexContainer,N>::type::const_iterator type;
-};
-
-template<
-  int N,typename IteratorType,
-  typename Value,typename IndexSpecifierList,typename Allocator>
-typename nth_index_iterator<
-  multi_index_container<Value,IndexSpecifierList,Allocator>,N>::type
-project(
-  multi_index_container<Value,IndexSpecifierList,Allocator>& m,
-  IteratorType it)
-{
-  typedef multi_index_container<
-    Value,IndexSpecifierList,Allocator>                multi_index_type;
-  typedef typename nth_index<multi_index_type,N>::type index_type;
-
-#if !defined(__SUNPRO_CC)||!(__SUNPRO_CC<0x580) /* Sun C++ 5.7 fails */
-  BOOST_STATIC_ASSERT((
-    mpl::contains<
-      BOOST_DEDUCED_TYPENAME multi_index_type::iterator_type_list,
-      IteratorType>::value));
-#endif
-
-  BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(it);
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-  typedef detail::converter<
-    multi_index_type,
-    BOOST_DEDUCED_TYPENAME IteratorType::container_type> converter;
-  BOOST_MULTI_INDEX_CHECK_IS_OWNER(it,converter::index(m));
-#endif
-
-  return detail::converter<multi_index_type,index_type>::iterator(
-    m,static_cast<typename multi_index_type::node_type*>(it.get_node()));
-}
-
-template<
-  int N,typename IteratorType,
-  typename Value,typename IndexSpecifierList,typename Allocator>
-typename nth_index_const_iterator<
-  multi_index_container<Value,IndexSpecifierList,Allocator>,N>::type
-project(
-  const multi_index_container<Value,IndexSpecifierList,Allocator>& m,
-  IteratorType it)
-{
-  typedef multi_index_container<
-    Value,IndexSpecifierList,Allocator>                multi_index_type;
-  typedef typename nth_index<multi_index_type,N>::type index_type;
-
-#if !defined(__SUNPRO_CC)||!(__SUNPRO_CC<0x580) /* Sun C++ 5.7 fails */
-  BOOST_STATIC_ASSERT((
-    mpl::contains<
-      BOOST_DEDUCED_TYPENAME multi_index_type::iterator_type_list,
-      IteratorType>::value||
-    mpl::contains<
-      BOOST_DEDUCED_TYPENAME multi_index_type::const_iterator_type_list,
-      IteratorType>::value));
-#endif
-
-  BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(it);
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-  typedef detail::converter<
-    multi_index_type,
-    BOOST_DEDUCED_TYPENAME IteratorType::container_type> converter;
-  BOOST_MULTI_INDEX_CHECK_IS_OWNER(it,converter::index(m));
-#endif
-
-  return detail::converter<multi_index_type,index_type>::const_iterator(
-    m,static_cast<typename multi_index_type::node_type*>(it.get_node()));
-}
-
-/* projection of iterators by tag */
-
-template<typename MultiIndexContainer,typename Tag>
-struct index_iterator
-{
-  typedef typename ::boost::multi_index::index<
-    MultiIndexContainer,Tag>::type::iterator    type;
-};
-
-template<typename MultiIndexContainer,typename Tag>
-struct index_const_iterator
-{
-  typedef typename ::boost::multi_index::index<
-    MultiIndexContainer,Tag>::type::const_iterator type;
-};
-
-template<
-  typename Tag,typename IteratorType,
-  typename Value,typename IndexSpecifierList,typename Allocator>
-typename index_iterator<
-  multi_index_container<Value,IndexSpecifierList,Allocator>,Tag>::type
-project(
-  multi_index_container<Value,IndexSpecifierList,Allocator>& m,
-  IteratorType it)
-{
-  typedef multi_index_container<
-    Value,IndexSpecifierList,Allocator>         multi_index_type;
-  typedef typename ::boost::multi_index::index<
-    multi_index_type,Tag>::type                 index_type;
-
-#if !defined(__SUNPRO_CC)||!(__SUNPRO_CC<0x580) /* Sun C++ 5.7 fails */
-  BOOST_STATIC_ASSERT((
-    mpl::contains<
-      BOOST_DEDUCED_TYPENAME multi_index_type::iterator_type_list,
-      IteratorType>::value));
-#endif
-
-  BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(it);
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-  typedef detail::converter<
-    multi_index_type,
-    BOOST_DEDUCED_TYPENAME IteratorType::container_type> converter;
-  BOOST_MULTI_INDEX_CHECK_IS_OWNER(it,converter::index(m));
-#endif
-
-  return detail::converter<multi_index_type,index_type>::iterator(
-    m,static_cast<typename multi_index_type::node_type*>(it.get_node()));
-}
-
-template<
-  typename Tag,typename IteratorType,
-  typename Value,typename IndexSpecifierList,typename Allocator>
-typename index_const_iterator<
-  multi_index_container<Value,IndexSpecifierList,Allocator>,Tag>::type
-project(
-  const multi_index_container<Value,IndexSpecifierList,Allocator>& m,
-  IteratorType it)
-{
-  typedef multi_index_container<
-    Value,IndexSpecifierList,Allocator>         multi_index_type;
-  typedef typename ::boost::multi_index::index<
-    multi_index_type,Tag>::type                 index_type;
-
-#if !defined(__SUNPRO_CC)||!(__SUNPRO_CC<0x580) /* Sun C++ 5.7 fails */
-  BOOST_STATIC_ASSERT((
-    mpl::contains<
-      BOOST_DEDUCED_TYPENAME multi_index_type::iterator_type_list,
-      IteratorType>::value||
-    mpl::contains<
-      BOOST_DEDUCED_TYPENAME multi_index_type::const_iterator_type_list,
-      IteratorType>::value));
-#endif
-
-  BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(it);
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-  typedef detail::converter<
-    multi_index_type,
-    BOOST_DEDUCED_TYPENAME IteratorType::container_type> converter;
-  BOOST_MULTI_INDEX_CHECK_IS_OWNER(it,converter::index(m));
-#endif
-
-  return detail::converter<multi_index_type,index_type>::const_iterator(
-    m,static_cast<typename multi_index_type::node_type*>(it.get_node()));
-}
-
-/* Comparison. Simple forward to first index. */
-
-template<
-  typename Value1,typename IndexSpecifierList1,typename Allocator1,
-  typename Value2,typename IndexSpecifierList2,typename Allocator2
->
-bool operator==(
-  const multi_index_container<Value1,IndexSpecifierList1,Allocator1>& x,
-  const multi_index_container<Value2,IndexSpecifierList2,Allocator2>& y)
-{
-  return get<0>(x)==get<0>(y);
-}
-
-template<
-  typename Value1,typename IndexSpecifierList1,typename Allocator1,
-  typename Value2,typename IndexSpecifierList2,typename Allocator2
->
-bool operator<(
-  const multi_index_container<Value1,IndexSpecifierList1,Allocator1>& x,
-  const multi_index_container<Value2,IndexSpecifierList2,Allocator2>& y)
-{
-  return get<0>(x)<get<0>(y);
-}
-
-template<
-  typename Value1,typename IndexSpecifierList1,typename Allocator1,
-  typename Value2,typename IndexSpecifierList2,typename Allocator2
->
-bool operator!=(
-  const multi_index_container<Value1,IndexSpecifierList1,Allocator1>& x,
-  const multi_index_container<Value2,IndexSpecifierList2,Allocator2>& y)
-{
-  return get<0>(x)!=get<0>(y);
-}
-
-template<
-  typename Value1,typename IndexSpecifierList1,typename Allocator1,
-  typename Value2,typename IndexSpecifierList2,typename Allocator2
->
-bool operator>(
-  const multi_index_container<Value1,IndexSpecifierList1,Allocator1>& x,
-  const multi_index_container<Value2,IndexSpecifierList2,Allocator2>& y)
-{
-  return get<0>(x)>get<0>(y);
-}
-
-template<
-  typename Value1,typename IndexSpecifierList1,typename Allocator1,
-  typename Value2,typename IndexSpecifierList2,typename Allocator2
->
-bool operator>=(
-  const multi_index_container<Value1,IndexSpecifierList1,Allocator1>& x,
-  const multi_index_container<Value2,IndexSpecifierList2,Allocator2>& y)
-{
-  return get<0>(x)>=get<0>(y);
-}
-
-template<
-  typename Value1,typename IndexSpecifierList1,typename Allocator1,
-  typename Value2,typename IndexSpecifierList2,typename Allocator2
->
-bool operator<=(
-  const multi_index_container<Value1,IndexSpecifierList1,Allocator1>& x,
-  const multi_index_container<Value2,IndexSpecifierList2,Allocator2>& y)
-{
-  return get<0>(x)<=get<0>(y);
-}
-
-/*  specialized algorithms */
-
-template<typename Value,typename IndexSpecifierList,typename Allocator>
-void swap(
-  multi_index_container<Value,IndexSpecifierList,Allocator>& x,
-  multi_index_container<Value,IndexSpecifierList,Allocator>& y)
-{
-  x.swap(y);
-}
-
-} /* namespace multi_index */
-
-#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
-/* class version = 1 : we now serialize the size through
- * boost::serialization::collection_size_type.
- * class version = 2 : proper use of {save|load}_construct_data.
- */
-
-namespace serialization {
-template<typename Value,typename IndexSpecifierList,typename Allocator>
-struct version<
-  boost::multi_index_container<Value,IndexSpecifierList,Allocator>
->
-{
-  BOOST_STATIC_CONSTANT(int,value=2);
-};
-} /* namespace serialization */
-#endif
-
-/* Associated global functions are promoted to namespace boost, except
- * comparison operators and swap, which are meant to be Koenig looked-up.
- */
-
-using multi_index::get;
-using multi_index::project;
-
-} /* namespace boost */
-
-#undef BOOST_MULTI_INDEX_CHECK_INVARIANT
-#undef BOOST_MULTI_INDEX_CHECK_INVARIANT_OF
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index_container_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index_container_fwd.hpp
deleted file mode 100644
index b35acad407a..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index_container_fwd.hpp
+++ /dev/null
@@ -1,121 +0,0 @@
-/* Copyright 2003-2013 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_FWD_HPP
-#define BOOST_MULTI_INDEX_FWD_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <boost/multi_index/identity.hpp>
-#include <boost/multi_index/indexed_by.hpp>
-#include <boost/multi_index/ordered_index_fwd.hpp>
-#include <memory>
-
-namespace boost{
-
-namespace multi_index{
-
-/* Default value for IndexSpecifierList specifies a container
- * equivalent to std::set<Value>.
- */
-
-template<
-  typename Value,
-  typename IndexSpecifierList=indexed_by<ordered_unique<identity<Value> > >,
-  typename Allocator=std::allocator<Value> >
-class multi_index_container;
-
-template<typename MultiIndexContainer,int N>
-struct nth_index;
-
-template<typename MultiIndexContainer,typename Tag>
-struct index;
-
-template<typename MultiIndexContainer,int N>
-struct nth_index_iterator;
-
-template<typename MultiIndexContainer,int N>
-struct nth_index_const_iterator;
-
-template<typename MultiIndexContainer,typename Tag>
-struct index_iterator;
-
-template<typename MultiIndexContainer,typename Tag>
-struct index_const_iterator;
-
-/* get and project functions not fwd declared due to problems
- * with dependent typenames
- */
-
-template<
-  typename Value1,typename IndexSpecifierList1,typename Allocator1,
-  typename Value2,typename IndexSpecifierList2,typename Allocator2
->
-bool operator==(
-  const multi_index_container<Value1,IndexSpecifierList1,Allocator1>& x,
-  const multi_index_container<Value2,IndexSpecifierList2,Allocator2>& y);
-
-template<
-  typename Value1,typename IndexSpecifierList1,typename Allocator1,
-  typename Value2,typename IndexSpecifierList2,typename Allocator2
->
-bool operator<(
-  const multi_index_container<Value1,IndexSpecifierList1,Allocator1>& x,
-  const multi_index_container<Value2,IndexSpecifierList2,Allocator2>& y);
-
-template<
-  typename Value1,typename IndexSpecifierList1,typename Allocator1,
-  typename Value2,typename IndexSpecifierList2,typename Allocator2
->
-bool operator!=(
-  const multi_index_container<Value1,IndexSpecifierList1,Allocator1>& x,
-  const multi_index_container<Value2,IndexSpecifierList2,Allocator2>& y);
-
-template<
-  typename Value1,typename IndexSpecifierList1,typename Allocator1,
-  typename Value2,typename IndexSpecifierList2,typename Allocator2
->
-bool operator>(
-  const multi_index_container<Value1,IndexSpecifierList1,Allocator1>& x,
-  const multi_index_container<Value2,IndexSpecifierList2,Allocator2>& y);
-
-template<
-  typename Value1,typename IndexSpecifierList1,typename Allocator1,
-  typename Value2,typename IndexSpecifierList2,typename Allocator2
->
-bool operator>=(
-  const multi_index_container<Value1,IndexSpecifierList1,Allocator1>& x,
-  const multi_index_container<Value2,IndexSpecifierList2,Allocator2>& y);
-
-template<
-  typename Value1,typename IndexSpecifierList1,typename Allocator1,
-  typename Value2,typename IndexSpecifierList2,typename Allocator2
->
-bool operator<=(
-  const multi_index_container<Value1,IndexSpecifierList1,Allocator1>& x,
-  const multi_index_container<Value2,IndexSpecifierList2,Allocator2>& y);
-
-template<typename Value,typename IndexSpecifierList,typename Allocator>
-void swap(
-  multi_index_container<Value,IndexSpecifierList,Allocator>& x,
-  multi_index_container<Value,IndexSpecifierList,Allocator>& y);
-
-} /* namespace multi_index */
-
-/* multi_index_container, being the main type of this library, is promoted to
- * namespace boost.
- */
-
-using multi_index::multi_index_container;
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/access.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/access.hpp
deleted file mode 100644
index f6581accc91..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/access.hpp
+++ /dev/null
@@ -1,145 +0,0 @@
-#ifndef BOOST_SERIALIZATION_ACCESS_HPP
-#define BOOST_SERIALIZATION_ACCESS_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// access.hpp: interface for serialization system.
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/config.hpp>
-
-namespace boost {
-
-namespace archive {
-namespace detail {
-    template<class Archive, class T>
-    class iserializer;
-    template<class Archive, class T>
-    class oserializer;
-} // namespace detail
-} // namespace archive
-
-namespace serialization {
-
-// forward declarations
-template<class Archive, class T>
-inline void serialize_adl(Archive &, T &, const unsigned int);
-namespace detail {
-    template<class Archive, class T>
-    struct member_saver;
-    template<class Archive, class T>
-    struct member_loader;
-} // namespace detail
-
-// use an "accessor class so that we can use: 
-// "friend class boost::serialization::access;" 
-// in any serialized class to permit clean, safe access to private class members
-// by the serialization system
-
-class access {
-public:
-    // grant access to "real" serialization defaults
-#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
-public:
-#else
-    template<class Archive, class T>
-    friend struct detail::member_saver;
-    template<class Archive, class T>
-    friend struct detail::member_loader;
-    template<class Archive, class T>
-    friend class archive::detail::iserializer;
-    template<class Archive, class T>
-    friend class archive::detail::oserializer;
-    template<class Archive, class T>
-    friend inline void serialize(
-        Archive & ar, 
-        T & t, 
-        const unsigned int file_version
-    );
-    template<class Archive, class T>
-    friend inline void save_construct_data(
-        Archive & ar, 
-        const T * t, 
-        const unsigned int file_version
-    );
-    template<class Archive, class T>
-    friend inline void load_construct_data(
-        Archive & ar, 
-        T * t, 
-        const unsigned int file_version
-    );
-#endif
-
-    // pass calls to users's class implementation
-    template<class Archive, class T>
-    static void member_save(
-        Archive & ar, 
-        //const T & t,
-        T & t,
-        const unsigned int file_version
-    ){
-        t.save(ar, file_version);
-    }
-    template<class Archive, class T>
-    static void member_load(
-        Archive & ar, 
-        T & t,
-        const unsigned int file_version
-    ){
-        t.load(ar, file_version);
-    }
-    template<class Archive, class T>
-    static void serialize(
-        Archive & ar, 
-        T & t, 
-        const unsigned int file_version
-    ){
-        // note: if you get a compile time error here with a
-        // message something like:
-        // cannot convert parameter 1 from <file type 1> to <file type 2 &>
-        // a likely possible cause is that the class T contains a 
-        // serialize function - but that serialize function isn't 
-        // a template and corresponds to a file type different than
-        // the class Archive.  To resolve this, don't include an
-        // archive type other than that for which the serialization
-        // function is defined!!!
-        t.serialize(ar, file_version);
-    }
-    template<class T>
-    static void destroy( const T * t) // const appropriate here?
-    {
-        // the const business is an MSVC 6.0 hack that should be
-        // benign on everything else
-        delete const_cast<T *>(t);
-    }
-    template<class T>
-    static void construct(T * t){
-        // default is inplace invocation of default constructor
-        // Note the :: before the placement new. Required if the
-        // class doesn't have a class-specific placement new defined.
-        ::new(t)T;
-    }
-    template<class T, class U>
-    static T & cast_reference(U & u){
-        return static_cast<T &>(u);
-    }
-    template<class T, class U>
-    static T * cast_pointer(U * u){
-        return static_cast<T *>(u);
-    }
-};
-
-} // namespace serialization
-} // namespace boost
-
-#endif // BOOST_SERIALIZATION_ACCESS_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/archive_input_unordered_map.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/archive_input_unordered_map.hpp
deleted file mode 100644
index ccf806b1813..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/archive_input_unordered_map.hpp
+++ /dev/null
@@ -1,85 +0,0 @@
-#ifndef  BOOST_SERIALIZATION_ARCHIVE_INPUT_UNORDERED_MAP_HPP
-#define BOOST_SERIALIZATION_ARCHIVE_INPUT_UNORDERED_MAP_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// serialization/unordered_map.hpp:
-// serialization for stl unordered_map templates
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// (C) Copyright 2014 Jim Bell
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/config.hpp>
-#include <boost/serialization/nvp.hpp>
-#include <boost/serialization/detail/stack_constructor.hpp>
-#include <boost/serialization/utility.hpp>
-#include <boost/move/utility_core.hpp>
-
-namespace boost { 
-namespace serialization {
-namespace stl {
-
-// map input
-template<class Archive, class Container>
-struct archive_input_unordered_map
-{
-    inline void operator()(
-        Archive &ar, 
-        Container &s, 
-        const unsigned int v
-    ){
-        typedef typename Container::value_type type;
-        detail::stack_construct<Archive, type> t(ar, v);
-        ar >> boost::serialization::make_nvp("item", t.reference());
-        std::pair<typename Container::const_iterator, bool> result = 
-            s.insert(boost::move(t.reference()));
-        // note: the following presumes that the map::value_type was NOT tracked
-        // in the archive.  This is the usual case, but here there is no way
-        // to determine that.  
-        if(result.second){
-            ar.reset_object_address(
-                & (result.first->second),
-                & t.reference().second
-            );
-        }
-    }
-};
-
-// multimap input
-template<class Archive, class Container>
-struct archive_input_unordered_multimap
-{
-    inline void operator()(
-        Archive &ar, 
-        Container &s, 
-        const unsigned int v
-    ){
-        typedef typename Container::value_type type;
-        detail::stack_construct<Archive, type> t(ar, v);
-        ar >> boost::serialization::make_nvp("item", t.reference());
-        typename Container::const_iterator result =
-            s.insert(t.reference());
-        // note: the following presumes that the map::value_type was NOT tracked
-        // in the archive.  This is the usual case, but here there is no way
-        // to determine that.  
-        ar.reset_object_address(
-            & result->second,
-            & t.reference()
-        );
-    }
-};
-
-} // stl
-} // namespace serialization
-} // namespace boost
-
-#endif // BOOST_SERIALIZATION_ARCHIVE_INPUT_UNORDERED_MAP_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/archive_input_unordered_set.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/archive_input_unordered_set.hpp
deleted file mode 100644
index 7f0003cc6a4..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/archive_input_unordered_set.hpp
+++ /dev/null
@@ -1,72 +0,0 @@
-#ifndef  BOOST_SERIALIZATION_ARCHIVE_INPUT_UNORDERED_SET_HPP
-#define BOOST_SERIALIZATION_ARCHIVE_INPUT_UNORDERED_SET_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// archive_input_unordered_set.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// (C) Copyright 2014 Jim Bell
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <utility>
-#include <boost/serialization/nvp.hpp>
-#include <boost/serialization/detail/stack_constructor.hpp>
-#include <boost/move/utility_core.hpp>
-
-namespace boost {
-namespace serialization {
-
-namespace stl {
-
-// unordered_set input
-template<class Archive, class Container>
-struct archive_input_unordered_set
-{
-    inline void operator()(
-        Archive &ar, 
-        Container &s, 
-        const unsigned int v
-    ){
-        typedef typename Container::value_type type;
-        detail::stack_construct<Archive, type> t(ar, v);
-        // borland fails silently w/o full namespace
-        ar >> boost::serialization::make_nvp("item", t.reference());
-        std::pair<typename Container::const_iterator, bool> result = 
-            s.insert(boost::move(t.reference()));
-        if(result.second)
-            ar.reset_object_address(& (* result.first), & t.reference());
-    }
-};
-
-// unordered_multiset input
-template<class Archive, class Container>
-struct archive_input_unordered_multiset
-{
-    inline void operator()(
-        Archive &ar, 
-        Container &s, 
-        const unsigned int v
-    ){
-        typedef typename Container::value_type type;
-        detail::stack_construct<Archive, type> t(ar, v);
-        ar >> boost::serialization::make_nvp("item", t.reference());
-        typename Container::const_iterator result =
-            s.insert(boost::move(t.reference()));
-        ar.reset_object_address(& (* result), & t.reference());
-    }
-};
-
-} // stl
-} // serialization
-} // boost
-
-#endif // BOOST_SERIALIZATION_ARCHIVE_INPUT_UNORDERED_SET_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/array.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/array.hpp
deleted file mode 100644
index 612d1a61985..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/array.hpp
+++ /dev/null
@@ -1,48 +0,0 @@
-#ifndef BOOST_SERIALIZATION_ARRAY_HPP
-#define BOOST_SERIALIZATION_ARRAY_HPP
-
-// (C) Copyright 2005 Matthias Troyer and Dave Abrahams
-// Use, modification and distribution is subject to the 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 serialization of <array>. If <array> not supported by the standard
-// library - this file becomes empty.  This is to avoid breaking backward
-// compatibiliy for applications which used this header to support
-// serialization of native arrays.  Code to serialize native arrays is
-// now always include by default.  RR
-
-#include <boost/config.hpp> // msvc 6.0 needs this for warning suppression
-
-#if defined(BOOST_NO_STDC_NAMESPACE)
-
-#include <iostream>
-#include <cstddef> // std::size_t
-namespace std{ 
-    using ::size_t; 
-} // namespace std
-#endif
-
-#include <boost/serialization/array_wrapper.hpp>
-
-#ifndef BOOST_NO_CXX11_HDR_ARRAY
-
-#include <array>
-#include <boost/serialization/nvp.hpp>
-
-namespace boost { namespace serialization {
-
-template <class Archive, class T, std::size_t N>
-void serialize(Archive& ar, std::array<T,N>& a, const unsigned int /* version */)
-{
-    ar & boost::serialization::make_nvp(
-        "elems",
-        *static_cast<T (*)[N]>(static_cast<void *>(a.data()))
-    );
-    
-}
-} } // end namespace boost::serialization
-
-#endif // BOOST_NO_CXX11_HDR_ARRAY
-
-#endif //BOOST_SERIALIZATION_ARRAY_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/array_optimization.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/array_optimization.hpp
deleted file mode 100644
index 40dffba871a..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/array_optimization.hpp
+++ /dev/null
@@ -1,37 +0,0 @@
-#ifndef BOOST_SERIALIZATION_ARRAY_OPTIMIZATON_HPP
-#define BOOST_SERIALIZATION_ARRAY_OPTIMIZATON_HPP
-
-// (C) Copyright 2005 Matthias Troyer and Dave Abrahams
-// Use, modification and distribution is subject to the 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> // msvc 6.0 needs this for warning suppression
-
-#if defined(BOOST_NO_STDC_NAMESPACE)
-namespace std{ 
-    using ::size_t; 
-} // namespace std
-#endif
-
-#include <boost/mpl/always.hpp>
-#include <boost/mpl/apply.hpp>
-#include <boost/type_traits/remove_const.hpp>
-
-namespace boost { namespace serialization {
-
-template <class Archive>
-struct use_array_optimization : boost::mpl::always<boost::mpl::false_> {};
-
-} } // end namespace boost::serialization
-
-#define BOOST_SERIALIZATION_USE_ARRAY_OPTIMIZATION(Archive)           \
-namespace boost { namespace serialization {                           \
-template <> struct use_array_optimization<Archive> {                  \
-  template <class ValueType>                                          \
-  struct apply : boost::mpl::apply1<Archive::use_array_optimization   \
-      , typename boost::remove_const<ValueType>::type                 \
-    >::type {};                                                       \
-}; }}
-
-#endif //BOOST_SERIALIZATION_ARRAY_OPTIMIZATON_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/array_wrapper.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/array_wrapper.hpp
deleted file mode 100644
index adf436e15b4..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/array_wrapper.hpp
+++ /dev/null
@@ -1,121 +0,0 @@
-#ifndef BOOST_SERIALIZATION_ARRAY_WRAPPER_HPP
-#define BOOST_SERIALIZATION_ARRAY_WRAPPER_HPP
-
-// (C) Copyright 2005 Matthias Troyer and Dave Abrahams
-// Use, modification and distribution is subject to the 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 <iostream>
-
-#include <boost/config.hpp> // msvc 6.0 needs this for warning suppression
-
-#if defined(BOOST_NO_STDC_NAMESPACE)
-namespace std{ 
-    using ::size_t; 
-} // namespace std
-#endif
-
-#include <boost/serialization/nvp.hpp>
-#include <boost/serialization/split_member.hpp>
-#include <boost/serialization/wrapper.hpp>
-#include <boost/serialization/collection_size_type.hpp>
-#include <boost/serialization/array_optimization.hpp>
-#include <boost/mpl/always.hpp>
-#include <boost/mpl/apply.hpp>
-#include <boost/mpl/bool_fwd.hpp>
-#include <boost/type_traits/remove_const.hpp>
-
-namespace boost { namespace serialization {
-
-template<class T>
-class array_wrapper :
-    public wrapper_traits<const array_wrapper< T > >
-{
-private:
-    array_wrapper & operator=(const array_wrapper & rhs);
-    // note: I would like to make the copy constructor private but this breaks
-    // make_array.  So I make make_array a friend
-    template<class Tx, class S>
-    friend const boost::serialization::array_wrapper<Tx> make_array(Tx * t, S s);
-public:
-
-    array_wrapper(const array_wrapper & rhs) :
-        m_t(rhs.m_t),
-        m_element_count(rhs.m_element_count)
-    {}
-public:
-    array_wrapper(T * t, std::size_t s) :
-        m_t(t),
-        m_element_count(s)
-    {}
-
-    // default implementation
-    template<class Archive>
-    void serialize_optimized(Archive &ar, const unsigned int, mpl::false_ ) const
-    {
-      // default implemention does the loop
-      std::size_t c = count();
-      T * t = address();
-      while(0 < c--)
-            ar & boost::serialization::make_nvp("item", *t++);
-    }
-
-    // optimized implementation
-    template<class Archive>
-    void serialize_optimized(Archive &ar, const unsigned int version, mpl::true_ )
-    {
-      boost::serialization::split_member(ar, *this, version);
-    }
-
-    // default implementation
-    template<class Archive>
-    void save(Archive &ar, const unsigned int version) const
-    {
-      ar.save_array(*this,version);
-    }
-
-    // default implementation
-    template<class Archive>
-    void load(Archive &ar, const unsigned int version)
-    {
-      ar.load_array(*this,version);
-    }
-    
-    // default implementation
-    template<class Archive>
-    void serialize(Archive &ar, const unsigned int version)
-    {
-      typedef typename 
-          boost::serialization::use_array_optimization<Archive>::template apply<
-                    typename remove_const< T >::type 
-                >::type use_optimized;
-      serialize_optimized(ar,version,use_optimized());
-    }
-    
-    T * address() const
-    {
-      return m_t;
-    }
-
-    std::size_t count() const
-    {
-      return m_element_count;
-    }
-
-private:
-    T * const m_t;
-    const std::size_t m_element_count;
-};
-
-template<class T, class S>
-inline
-const array_wrapper< T > make_array(T* t, S s){
-    const array_wrapper< T > a(t, s);
-    return a;
-}
-
-} } // end namespace boost::serialization
-
-
-#endif //BOOST_SERIALIZATION_ARRAY_WRAPPER_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/assume_abstract.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/assume_abstract.hpp
deleted file mode 100644
index 632f9312f5f..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/assume_abstract.hpp
+++ /dev/null
@@ -1,60 +0,0 @@
-#ifndef BOOST_SERIALIZATION_ASSUME_ABSTRACT_HPP
-#define BOOST_SERIALIZATION_ASSUME_ABSTRACT_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// assume_abstract_class.hpp:
-
-// (C) Copyright 2008 Robert Ramey
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-// this is useful for compilers which don't support the boost::is_abstract
-
-#include <boost/type_traits/is_abstract.hpp>
-#include <boost/mpl/bool_fwd.hpp>
-
-#ifndef BOOST_NO_IS_ABSTRACT
-
-// if there is an intrinsic is_abstract defined, we don't have to do anything
-#define BOOST_SERIALIZATION_ASSUME_ABSTRACT(T)
-
-// but forward to the "official" is_abstract
-namespace boost {
-namespace serialization {
-    template<class T>
-    struct is_abstract : boost::is_abstract< T > {} ;
-} // namespace serialization
-} // namespace boost
-
-#else
-// we have to "make" one
-
-namespace boost {
-namespace serialization {
-    template<class T>
-    struct is_abstract : boost::false_type {};
-} // namespace serialization
-} // namespace boost
-
-// define a macro to make explicit designation of this more transparent
-#define BOOST_SERIALIZATION_ASSUME_ABSTRACT(T)        \
-namespace boost {                                     \
-namespace serialization {                             \
-template<>                                            \
-struct is_abstract< T > : boost::true_type {};        \
-template<>                                            \
-struct is_abstract< const T > : boost::true_type {};  \
-}}                                                    \
-/**/
-
-#endif // BOOST_NO_IS_ABSTRACT
-
-#endif //BOOST_SERIALIZATION_ASSUME_ABSTRACT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/base_object.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/base_object.hpp
deleted file mode 100644
index 1a82cecd4b5..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/base_object.hpp
+++ /dev/null
@@ -1,100 +0,0 @@
-#ifndef BOOST_SERIALIZATION_BASE_OBJECT_HPP
-#define BOOST_SERIALIZATION_BASE_OBJECT_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// base_object.hpp:
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-// if no archive headers have been included this is a no op
-// this is to permit BOOST_EXPORT etc to be included in a 
-// file declaration header
-
-#include <boost/config.hpp>
-#include <boost/detail/workaround.hpp>
-
-#include <boost/mpl/eval_if.hpp>
-#include <boost/mpl/int.hpp>
-#include <boost/mpl/identity.hpp>
-
-#include <boost/type_traits/is_base_and_derived.hpp>
-#include <boost/type_traits/is_pointer.hpp>
-#include <boost/type_traits/is_const.hpp>
-#include <boost/type_traits/is_polymorphic.hpp>
-
-#include <boost/static_assert.hpp>
-#include <boost/serialization/access.hpp>
-#include <boost/serialization/force_include.hpp>
-#include <boost/serialization/void_cast_fwd.hpp>
-
-namespace boost {
-namespace serialization {
-
-namespace detail
-{
-    // get the base type for a given derived type
-    // preserving the const-ness
-    template<class B, class D>
-    struct base_cast
-    {
-        typedef typename
-        mpl::if_<
-            is_const<D>,
-            const B,
-            B
-        >::type type;
-        BOOST_STATIC_ASSERT(is_const<type>::value == is_const<D>::value);
-    };
-
-    // only register void casts if the types are polymorphic
-    template<class Base, class Derived>
-    struct base_register
-    {
-        struct polymorphic {
-            static void const * invoke(){
-                Base const * const b = 0;
-                Derived const * const d = 0;
-                return & void_cast_register(d, b);
-            }
-        };
-        struct non_polymorphic {
-            static void const * invoke(){
-                return 0;
-            }
-        };
-        static void const * invoke(){
-            typedef typename mpl::eval_if<
-                is_polymorphic<Base>,
-                mpl::identity<polymorphic>,
-                mpl::identity<non_polymorphic>
-            >::type type;
-            return type::invoke();
-        }
-    };
-
-} // namespace detail
-template<class Base, class Derived>
-typename detail::base_cast<Base, Derived>::type & 
-base_object(Derived &d)
-{
-    BOOST_STATIC_ASSERT(( is_base_and_derived<Base,Derived>::value));
-    BOOST_STATIC_ASSERT(! is_pointer<Derived>::value);
-    typedef typename detail::base_cast<Base, Derived>::type type;
-    detail::base_register<type, Derived>::invoke();
-    return access::cast_reference<type, Derived>(d);
-}
-
-} // namespace serialization
-} // namespace boost
-
-#endif // BOOST_SERIALIZATION_BASE_OBJECT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/binary_object.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/binary_object.hpp
deleted file mode 100644
index 5c9038e5a9f..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/binary_object.hpp
+++ /dev/null
@@ -1,79 +0,0 @@
-#ifndef BOOST_SERIALIZATION_BINARY_OBJECT_HPP
-#define BOOST_SERIALIZATION_BINARY_OBJECT_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// nvp.hpp: interface for serialization system.
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/assert.hpp>
-
-#include <cstddef> // std::size_t
-#include <boost/config.hpp>
-#if defined(BOOST_NO_STDC_NAMESPACE)
-namespace std{ 
-    using ::size_t; 
-} // namespace std
-#endif
-
-#include <boost/preprocessor/stringize.hpp>
-#include <boost/serialization/tracking.hpp>
-#include <boost/serialization/level.hpp>
-#include <boost/serialization/split_member.hpp>
-#include <boost/serialization/nvp.hpp>
-#include <boost/serialization/wrapper.hpp>
-
-namespace boost {
-namespace serialization {
-
-struct binary_object :
-    public wrapper_traits<nvp<const binary_object> >
-{
-    void const * m_t;
-    std::size_t m_size;
-    template<class Archive>
-    void save(Archive & ar, const unsigned int /* file_version */) const {
-        ar.save_binary(m_t, m_size);
-    }
-    template<class Archive>
-    void load(Archive & ar, const unsigned int /* file_version */) const {
-        ar.load_binary(const_cast<void *>(m_t), m_size);
-    }
-    BOOST_SERIALIZATION_SPLIT_MEMBER()
-    binary_object & operator=(const binary_object & rhs) {
-        m_t = rhs.m_t;
-        m_size = rhs.m_size;
-        return *this;
-    }
-    binary_object(const void * const t, std::size_t size) :
-        m_t(t),
-        m_size(size)
-    {}
-    binary_object(const binary_object & rhs) :
-        m_t(rhs.m_t),
-        m_size(rhs.m_size)
-    {}
-};
-
-// just a little helper to support the convention that all serialization
-// wrappers follow the naming convention make_xxxxx
-inline 
-const binary_object
-make_binary_object(const void * t, std::size_t size){
-    return binary_object(t, size);
-}
-
-} // namespace serialization
-} // boost
-
-#endif // BOOST_SERIALIZATION_BINARY_OBJECT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/bitset.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/bitset.hpp
deleted file mode 100644
index 78f9bd74336..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/bitset.hpp
+++ /dev/null
@@ -1,75 +0,0 @@
-/*!
- * \file      bitset.hpp
- * \brief     Provides Boost.Serialization support for std::bitset
- * \author    Brian Ravnsgaard Riis
- * \author    Kenneth Riddile
- * \date      16.09.2004, updated 04.03.2009
- * \copyright 2004 Brian Ravnsgaard Riis
- * \license   Boost Software License 1.0
- */
-#ifndef BOOST_SERIALIZATION_BITSET_HPP
-#define BOOST_SERIALIZATION_BITSET_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-#include <bitset>
-#include <cstddef> // size_t
-
-#include <boost/config.hpp>
-#include <boost/serialization/split_free.hpp>
-#include <boost/serialization/string.hpp>
-#include <boost/serialization/nvp.hpp>
-
-namespace boost{
-namespace serialization{
-
-template <class Archive, std::size_t size>
-inline void save(
-    Archive & ar,
-    std::bitset<size> const & t,
-    const unsigned int /* version */
-){
-    const std::string bits = t.template to_string<
-        std::string::value_type,
-        std::string::traits_type,
-        std::string::allocator_type
-    >();
-    ar << BOOST_SERIALIZATION_NVP( bits );
-}
-
-template <class Archive, std::size_t size>
-inline void load(
-    Archive & ar,
-    std::bitset<size> & t,
-    const unsigned int /* version */
-){
-    std::string bits;
-    ar >> BOOST_SERIALIZATION_NVP( bits );
-    t = std::bitset<size>(bits);
-}
-
-template <class Archive, std::size_t size>
-inline void serialize(
-    Archive & ar,
-    std::bitset<size> & t,
-    const unsigned int version
-){
-    boost::serialization::split_free( ar, t, version );
-}
-
-// don't track bitsets since that would trigger tracking
-// all over the program - which probably would be a surprise.
-// also, tracking would be hard to implement since, we're
-// serialization a representation of the data rather than
-// the data itself.
-template <std::size_t size>
-struct tracking_level<std::bitset<size> >
-    : mpl::int_<track_never> {} ;
-
-} //serialization
-} //boost
-
-#endif // BOOST_SERIALIZATION_BITSET_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/boost_array.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/boost_array.hpp
deleted file mode 100644
index d564ff15de0..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/boost_array.hpp
+++ /dev/null
@@ -1,33 +0,0 @@
-#ifndef BOOST_SERIALIZATION_ARRAY_HPP
-#define BOOST_SERIALIZATION_ARRAY_HPP
-
-// (C) Copyright 2005 Matthias Troyer and Dave Abrahams
-// Use, modification and distribution is subject to the 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 <iostream>
-
-#include <boost/config.hpp> // msvc 6.0 needs this for warning suppression
-
-#if defined(BOOST_NO_STDC_NAMESPACE)
-namespace std{ 
-    using ::size_t; 
-} // namespace std
-#endif
-
-#include <boost/serialization/nvp.hpp>
-#include <boost/array.hpp>
-
-namespace boost { namespace serialization {
-// implement serialization for boost::array
-template <class Archive, class T, std::size_t N>
-void serialize(Archive& ar, boost::array<T,N>& a, const unsigned int /* version */)
-{
-    ar & boost::serialization::make_nvp("elems", a.elems);
-}
-
-} } // end namespace boost::serialization
-
-
-#endif //BOOST_SERIALIZATION_ARRAY_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/boost_unordered_map.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/boost_unordered_map.hpp
deleted file mode 100644
index 8913b31f9e6..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/boost_unordered_map.hpp
+++ /dev/null
@@ -1,154 +0,0 @@
-#ifndef  BOOST_SERIALIZATION_UNORDERED_MAP_HPP
-#define BOOST_SERIALIZATION_UNORDERED_MAP_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// serialization/unordered_map.hpp:
-// serialization for stl unordered_map templates
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// (C) Copyright 2014 Jim Bell
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/config.hpp>
-
-#include <boost/unordered_map.hpp>
-
-#include <boost/serialization/utility.hpp>
-#include <boost/serialization/unordered_collections_save_imp.hpp>
-#include <boost/serialization/unordered_collections_load_imp.hpp>
-#include <boost/serialization/archive_input_unordered_map.hpp>
-#include <boost/serialization/split_free.hpp>
-
-namespace boost { 
-namespace serialization {
-
-template<
-    class Archive, 
-    class Key, 
-    class HashFcn, 
-    class EqualKey,
-    class Allocator
->
-inline void save(
-    Archive & ar,
-    const boost::unordered_map<Key, HashFcn, EqualKey, Allocator> &t,
-    const unsigned int /*file_version*/
-){
-    boost::serialization::stl::save_unordered_collection<
-        Archive, 
-        boost::unordered_map<Key, HashFcn, EqualKey, Allocator>
-    >(ar, t);
-}
-
-template<
-    class Archive, 
-    class Key, 
-    class HashFcn, 
-    class EqualKey,
-    class Allocator
->
-inline void load(
-    Archive & ar,
-    boost::unordered_map<Key, HashFcn, EqualKey, Allocator> &t,
-    const unsigned int /*file_version*/
-){
-    boost::serialization::stl::load_unordered_collection<
-        Archive,
-        boost::unordered_map<Key, HashFcn, EqualKey, Allocator>,
-        boost::serialization::stl::archive_input_unordered_map<
-            Archive, 
-            boost::unordered_map<Key, HashFcn, EqualKey, Allocator>
-        >
-    >(ar, t);
-}
-
-// split non-intrusive serialization function member into separate
-// non intrusive save/load member functions
-template<
-    class Archive, 
-    class Key, 
-    class HashFcn, 
-    class EqualKey,
-    class Allocator
->
-inline void serialize(
-    Archive & ar,
-    boost::unordered_map<Key, HashFcn, EqualKey, Allocator> &t,
-    const unsigned int file_version
-){
-    boost::serialization::split_free(ar, t, file_version);
-}
-
-// unordered_multimap
-template<
-    class Archive, 
-    class Key, 
-    class HashFcn, 
-    class EqualKey,
-    class Allocator
->
-inline void save(
-    Archive & ar,
-    const boost::unordered_multimap<Key, HashFcn, EqualKey, Allocator> &t,
-    const unsigned int /*file_version*/
-){
-    boost::serialization::stl::save_unordered_collection<
-        Archive, 
-        boost::unordered_multimap<Key, HashFcn, EqualKey, Allocator>
-    >(ar, t);
-}
-
-template<
-    class Archive, 
-    class Key, 
-    class HashFcn, 
-    class EqualKey,
-    class Allocator
->
-inline void load(
-    Archive & ar,
-    boost::unordered_multimap<
-        Key, HashFcn, EqualKey, Allocator
-    > &t,
-    const unsigned int /*file_version*/
-){
-    boost::serialization::stl::load_unordered_collection<
-        Archive,
-        boost::unordered_multimap<Key, HashFcn, EqualKey, Allocator>,
-        boost::serialization::stl::archive_input_unordered_multimap<
-            Archive, 
-            boost::unordered_multimap<Key, HashFcn, EqualKey, Allocator>
-        >
-    >(ar, t);
-}
-
-// split non-intrusive serialization function member into separate
-// non intrusive save/load member functions
-template<
-    class Archive, 
-    class Key, 
-    class HashFcn, 
-    class EqualKey,
-    class Allocator
->
-inline void serialize(
-    Archive & ar,
-    boost::unordered_multimap<Key, HashFcn, EqualKey, Allocator> &t,
-    const unsigned int file_version
-){
-    boost::serialization::split_free(ar, t, file_version);
-}
-
-} // namespace serialization
-} // namespace boost
-
-#endif // BOOST_SERIALIZATION_UNORDERED_MAP_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/boost_unordered_set.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/boost_unordered_set.hpp
deleted file mode 100644
index 307c7819cbd..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/boost_unordered_set.hpp
+++ /dev/null
@@ -1,150 +0,0 @@
-#ifndef  BOOST_SERIALIZATION_BOOST_UNORDERED_SET_HPP
-#define BOOST_SERIALIZATION_BOOST_UNORDERED_SET_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// unordered_set.hpp: serialization for boost unordered_set templates
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// (C) Copyright 2014 Jim Bell
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/config.hpp>
-
-#include <boost/unordered_set.hpp>
-
-#include <boost/serialization/unordered_collections_save_imp.hpp>
-#include <boost/serialization/unordered_collections_load_imp.hpp>
-#include <boost/serialization/archive_input_unordered_set.hpp>
-#include <boost/serialization/split_free.hpp>
-
-namespace boost { 
-namespace serialization {
-
-template<
-    class Archive, 
-    class Key, 
-    class HashFcn, 
-    class EqualKey,
-    class Allocator
->
-inline void save(
-    Archive & ar,
-    const boost::unordered_set<Key, HashFcn, EqualKey, Allocator> &t,
-    const unsigned int /*file_version*/
-){
-    boost::serialization::stl::save_unordered_collection<
-        Archive, 
-        boost::unordered_set<Key, HashFcn, EqualKey, Allocator>
-    >(ar, t);
-}
-
-template<
-    class Archive, 
-    class Key, 
-    class HashFcn, 
-    class EqualKey,
-    class Allocator
->
-inline void load(
-    Archive & ar,
-    boost::unordered_set<Key, HashFcn, EqualKey, Allocator> &t,
-    const unsigned int /*file_version*/
-){
-    boost::serialization::stl::load_unordered_collection<
-        Archive,
-        boost::unordered_set<Key, HashFcn, EqualKey, Allocator>,
-        boost::serialization::stl::archive_input_unordered_set<
-            Archive, 
-            boost::unordered_set<Key, HashFcn, EqualKey, Allocator>
-        >
-    >(ar, t);
-}
-
-// split non-intrusive serialization function member into separate
-// non intrusive save/load member functions
-template<
-    class Archive, 
-    class Key, 
-    class HashFcn, 
-    class EqualKey,
-    class Allocator
->
-inline void serialize(
-    Archive & ar,
-    boost::unordered_set<Key, HashFcn, EqualKey, Allocator> &t,
-    const unsigned int file_version
-){
-    boost::serialization::split_free(ar, t, file_version);
-}
-
-// unordered_multiset
-template<
-    class Archive, 
-    class Key, 
-    class HashFcn, 
-    class EqualKey,
-    class Allocator
->
-inline void save(
-    Archive & ar,
-    const boost::unordered_multiset<Key, HashFcn, EqualKey, Allocator> &t,
-    const unsigned int /*file_version*/
-){
-    boost::serialization::stl::save_unordered_collection<
-        Archive, 
-        boost::unordered_multiset<Key, HashFcn, EqualKey, Allocator>
-    >(ar, t);
-}
-
-template<
-    class Archive, 
-    class Key, 
-    class HashFcn, 
-    class EqualKey,
-    class Allocator
->
-inline void load(
-    Archive & ar,
-    boost::unordered_multiset<Key, HashFcn, EqualKey, Allocator> &t,
-    const unsigned int /*file_version*/
-){
-    boost::serialization::stl::load_unordered_collection<
-        Archive,
-        boost::unordered_multiset<Key, HashFcn, EqualKey, Allocator>,
-        boost::serialization::stl::archive_input_unordered_multiset<
-            Archive,
-            boost::unordered_multiset<Key, HashFcn, EqualKey, Allocator>
-        >
-    >(ar, t);
-}
-
-// split non-intrusive serialization function member into separate
-// non intrusive save/load member functions
-template<
-    class Archive, 
-    class Key, 
-    class HashFcn, 
-    class EqualKey,
-    class Allocator
->
-inline void serialize(
-    Archive & ar,
-    boost::unordered_multiset<Key, HashFcn, EqualKey, Allocator> &t,
-    const unsigned int file_version
-){
-    boost::serialization::split_free(ar, t, file_version);
-}
-
-} // namespace serialization
-} // namespace boost
-
-#endif // BOOST_SERIALIZATION_BOOST_UNORDERED_SET_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/collection_size_type.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/collection_size_type.hpp
deleted file mode 100644
index 2dd8fa72584..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/collection_size_type.hpp
+++ /dev/null
@@ -1,62 +0,0 @@
-#ifndef BOOST_SERIALIZATION_COLLECTION_SIZE_TYPE_HPP
-#define BOOST_SERIALIZATION_COLLECTION_SIZE_TYPE_HPP
-
-// (C) Copyright 2005 Matthias Troyer
-// Use, modification and distribution is subject to the 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 <cstddef> // size_t
-#include <boost/serialization/strong_typedef.hpp>
-#include <boost/serialization/level.hpp>
-#include <boost/serialization/split_free.hpp>
-#include <boost/serialization/is_bitwise_serializable.hpp>
-
-namespace boost { 
-namespace serialization {
-
-//BOOST_STRONG_TYPEDEF(std::size_t, collection_size_type)
-
-class collection_size_type {
-private:
-    typedef std::size_t base_type;
-    base_type t;
-public:
-    collection_size_type(): t(0) {};
-    explicit collection_size_type(const std::size_t & t_) : 
-        t(t_)
-    {}
-    collection_size_type(const collection_size_type & t_) : 
-        t(t_.t)
-    {}
-    collection_size_type & operator=(const collection_size_type & rhs){
-        t = rhs.t; 
-        return *this;
-    }
-    collection_size_type & operator=(const unsigned int & rhs){
-        t = rhs; 
-        return *this;
-    }
-    // used for text output
-    operator base_type () const {
-        return t;
-    }                
-    // used for text input
-    operator base_type & () {
-        return t;
-    }                
-    bool operator==(const collection_size_type & rhs) const {
-        return t == rhs.t;
-    } 
-    bool operator<(const collection_size_type & rhs) const {
-        return t < rhs.t;
-    }   
-};
-
-
-} } // end namespace boost::serialization
-
-BOOST_CLASS_IMPLEMENTATION(collection_size_type, primitive_type)
-BOOST_IS_BITWISE_SERIALIZABLE(collection_size_type)
-
-#endif //BOOST_SERIALIZATION_COLLECTION_SIZE_TYPE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/collection_traits.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/collection_traits.hpp
deleted file mode 100644
index 3ec9401eff0..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/collection_traits.hpp
+++ /dev/null
@@ -1,79 +0,0 @@
-#ifndef BOOST_SERIALIZATION_COLLECTION_TRAITS_HPP
-#define BOOST_SERIALIZATION_COLLECTION_TRAITS_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// collection_traits.hpp:
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-// This header assigns a level implemenation trait to a collection type
-// for all primitives.  It is needed so that archives which are meant to be
-// portable don't write class information in the archive.  Since, not all
-// compiles recognize the same set of primitive types, the possibility
-// exists for archives to be non-portable if class information for primitive
-// types is included.  This is addressed by the following macros.
-#include <boost/config.hpp>
-//#include <boost/mpl/integral_c.hpp>
-#include <boost/mpl/integral_c_tag.hpp>
-
-#include <boost/cstdint.hpp>
-#include <boost/integer_traits.hpp>
-#include <climits> // ULONG_MAX
-#include <boost/serialization/level.hpp>
-
-#define BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(T, C)          \
-template<>                                                          \
-struct implementation_level< C < T > > {                            \
-    typedef mpl::integral_c_tag tag;                                \
-    typedef mpl::int_<object_serializable> type;                    \
-    BOOST_STATIC_CONSTANT(int, value = object_serializable);        \
-};                                                                  \
-/**/
-
-#if defined(BOOST_NO_CWCHAR) || defined(BOOST_NO_INTRINSIC_WCHAR_T)
-    #define BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER_WCHAR(C)
-#else
-    #define BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER_WCHAR(C)   \
-    BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(wchar_t, C)        \
-    /**/
-#endif
-
-#if defined(BOOST_HAS_LONG_LONG)
-    #define BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER_INT64(C)    \
-    BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(boost::long_long_type, C)  \
-    BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(boost::ulong_long_type, C) \
-    /**/
-#else
-    #define BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER_INT64(C)
-#endif
-
-#define BOOST_SERIALIZATION_COLLECTION_TRAITS(C)                     \
-    namespace boost { namespace serialization {                      \
-    BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(bool, C)            \
-    BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(char, C)            \
-    BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(signed char, C)     \
-    BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(unsigned char, C)   \
-    BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(signed int, C)      \
-    BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(unsigned int, C)    \
-    BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(signed long, C)     \
-    BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(unsigned long, C)   \
-    BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(float, C)           \
-    BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(double, C)          \
-    BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(unsigned short, C)  \
-    BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(signed short, C)    \
-    BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER_INT64(C)            \
-    BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER_WCHAR(C)            \
-    } }                                                              \
-    /**/
-
-#endif // BOOST_SERIALIZATION_COLLECTION_TRAITS
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/collections_load_imp.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/collections_load_imp.hpp
deleted file mode 100644
index e042c0c130d..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/collections_load_imp.hpp
+++ /dev/null
@@ -1,106 +0,0 @@
-#ifndef  BOOST_SERIALIZATION_COLLECTIONS_LOAD_IMP_HPP
-#define BOOST_SERIALIZATION_COLLECTIONS_LOAD_IMP_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-#if defined(_MSC_VER) && (_MSC_VER <= 1020)
-#  pragma warning (disable : 4786) // too long name, harmless warning
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// collections_load_imp.hpp: serialization for loading stl collections
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-// helper function templates for serialization of collections
-
-#include <boost/assert.hpp>
-#include <cstddef> // size_t
-#include <boost/config.hpp> // msvc 6.0 needs this for warning suppression
-#if defined(BOOST_NO_STDC_NAMESPACE)
-namespace std{ 
-    using ::size_t; 
-} // namespace std
-#endif
-#include <boost/detail/workaround.hpp>
-
-#include <boost/archive/detail/basic_iarchive.hpp>
-#include <boost/serialization/access.hpp>
-#include <boost/serialization/nvp.hpp>
-#include <boost/serialization/detail/stack_constructor.hpp>
-#include <boost/serialization/collection_size_type.hpp>
-#include <boost/serialization/item_version_type.hpp>
-#include <boost/serialization/detail/is_default_constructible.hpp>
-#include <boost/utility/enable_if.hpp>
-#include <boost/move/utility_core.hpp>
-
-namespace boost{
-namespace serialization {
-namespace stl {
-
-//////////////////////////////////////////////////////////////////////
-// implementation of serialization for STL containers
-//
-
-template<
-    class Archive,
-    class T
->
-typename boost::enable_if<
-    typename detail::is_default_constructible<
-        typename T::value_type
-    >,
-    void
->::type
-collection_load_impl(
-    Archive & ar,
-    T & t,
-    collection_size_type count,
-    item_version_type /*item_version*/
-){
-    t.resize(count);
-    typename T::iterator hint;
-    hint = t.begin();
-    while(count-- > 0){
-        ar >> boost::serialization::make_nvp("item", *hint++);
-    }
-}
-
-template<
-    class Archive,
-    class T
->
-typename boost::disable_if<
-    typename detail::is_default_constructible<
-        typename T::value_type
-    >,
-    void
->::type
-collection_load_impl(
-    Archive & ar,
-    T & t,
-    collection_size_type count,
-    item_version_type item_version
-){
-    t.clear();
-    while(count-- > 0){
-        detail::stack_construct<Archive, typename T::value_type> u(ar, item_version);
-        ar >> boost::serialization::make_nvp("item", u.reference());
-        t.push_back(boost::move(u.reference()));
-        ar.reset_object_address(& t.back() , & u.reference());
-     }
-}
-
-} // namespace stl 
-} // namespace serialization
-} // namespace boost
-
-#endif //BOOST_SERIALIZATION_COLLECTIONS_LOAD_IMP_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/collections_save_imp.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/collections_save_imp.hpp
deleted file mode 100644
index f3cabfcf3f5..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/collections_save_imp.hpp
+++ /dev/null
@@ -1,82 +0,0 @@
-#ifndef BOOST_SERIALIZATION_COLLECTIONS_SAVE_IMP_HPP
-#define BOOST_SERIALIZATION_COLLECTIONS_SAVE_IMP_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// collections_save_imp.hpp: serialization for stl collections
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-// helper function templates for serialization of collections
-
-#include <boost/config.hpp>
-#include <boost/serialization/nvp.hpp>
-#include <boost/serialization/serialization.hpp>
-#include <boost/serialization/version.hpp>
-#include <boost/serialization/collection_size_type.hpp>
-#include <boost/serialization/item_version_type.hpp>
-
-namespace boost{
-namespace serialization {
-namespace stl {
-
-//////////////////////////////////////////////////////////////////////
-// implementation of serialization for STL containers
-//
-
-template<class Archive, class Container>
-inline void save_collection(
-    Archive & ar,
-    const Container &s,
-    collection_size_type count)
-{
-    ar << BOOST_SERIALIZATION_NVP(count);
-    // record number of elements
-    const item_version_type item_version(
-        version<typename Container::value_type>::value
-    );
-    #if 0
-        boost::archive::library_version_type library_version(
-            ar.get_library_version()
-        );
-        if(boost::archive::library_version_type(3) < library_version){
-            ar << BOOST_SERIALIZATION_NVP(item_version);
-        }
-    #else
-        ar << BOOST_SERIALIZATION_NVP(item_version);
-    #endif
-
-    typename Container::const_iterator it = s.begin();
-    while(count-- > 0){
-        // note borland emits a no-op without the explicit namespace
-        boost::serialization::save_construct_data_adl(
-            ar, 
-            &(*it), 
-            item_version
-        );
-        ar << boost::serialization::make_nvp("item", *it++);
-    }
-}
-
-template<class Archive, class Container>
-inline void save_collection(Archive & ar, const Container &s)
-{
-    // record number of elements
-    collection_size_type count(s.size());
-    save_collection(ar, s, count);
-}
-
-} // namespace stl 
-} // namespace serialization
-} // namespace boost
-
-#endif //BOOST_SERIALIZATION_COLLECTIONS_SAVE_IMP_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/complex.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/complex.hpp
deleted file mode 100644
index b4ef44cf973..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/complex.hpp
+++ /dev/null
@@ -1,81 +0,0 @@
-#ifndef  BOOST_SERIALIZATION_COMPLEX_HPP
-#define BOOST_SERIALIZATION_COMPLEX_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// serialization/utility.hpp:
-// serialization for stl utility templates
-
-// (C) Copyright 2007 Matthias Troyer . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <complex>
-#include <boost/config.hpp>
-
-#include <boost/serialization/nvp.hpp>
-#include <boost/serialization/is_bitwise_serializable.hpp>
-#include <boost/serialization/split_free.hpp>
-
-namespace boost { 
-namespace serialization {
-
-template<class Archive, class T>
-inline void serialize(
-    Archive & ar,
-    std::complex< T > & t,
-    const unsigned int file_version 
-){
-    boost::serialization::split_free(ar, t, file_version);
-}
-
-template<class Archive, class T>
-inline void save(
-    Archive & ar,
-    std::complex< T > const & t,
-    const unsigned int /* file_version */
-){
-    const T re = t.real();
-    const T im = t.imag();
-    ar << boost::serialization::make_nvp("real", re);
-    ar << boost::serialization::make_nvp("imag", im);
-}
-
-template<class Archive, class T>
-inline void load(
-    Archive & ar,
-    std::complex< T >& t,
-    const unsigned int /* file_version */ 
-){
-    T re;
-    T im;
-    ar >> boost::serialization::make_nvp("real", re);
-    ar >> boost::serialization::make_nvp("imag", im);
-    t = std::complex< T >(re,im);
-}
-
-// specialization of serialization traits for complex
-template <class T>
-struct is_bitwise_serializable<std::complex< T > >
-    : public is_bitwise_serializable< T > {};
-
-template <class T>
-struct implementation_level<std::complex< T > >
-    : mpl::int_<object_serializable> {} ;
-
-// treat complex just like builtin arithmetic types for tracking
-template <class T>
-struct tracking_level<std::complex< T > >
-    : mpl::int_<track_never> {} ;
-
-} // serialization
-} // namespace boost
-
-#endif // BOOST_SERIALIZATION_COMPLEX_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/config.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/config.hpp
deleted file mode 100644
index ea8cb9239ed..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/config.hpp
+++ /dev/null
@@ -1,74 +0,0 @@
-#ifndef BOOST_SERIALIZATION_CONFIG_HPP
-#define BOOST_SERIALIZATION_CONFIG_HPP
-
-//  config.hpp  ---------------------------------------------//
-
-//  (c) Copyright Robert Ramey 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)
-
-//  See library home page at http://www.boost.org/libs/serialization
-
-//----------------------------------------------------------------------------// 
-
-// This header implements separate compilation features as described in
-// http://www.boost.org/more/separate_compilation.html
-
-#include <boost/config.hpp>
-#include <boost/detail/workaround.hpp>
-
-// note: this version incorporates the related code into the the 
-// the same library as BOOST_ARCHIVE.  This could change some day in the
-// future
-
-// if BOOST_SERIALIZATION_DECL is defined undefine it now:
-#ifdef BOOST_SERIALIZATION_DECL
-    #undef BOOST_SERIALIZATION_DECL
-#endif
-
-// we need to import/export our code only if the user has specifically
-// asked for it by defining either BOOST_ALL_DYN_LINK if they want all boost
-// libraries to be dynamically linked, or BOOST_SERIALIZATION_DYN_LINK
-// if they want just this one to be dynamically liked:
-#if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_SERIALIZATION_DYN_LINK)
-    #if !defined(BOOST_DYN_LINK)
-        #define BOOST_DYN_LINK
-    #endif
-    // export if this is our own source, otherwise import:
-    #if defined(BOOST_SERIALIZATION_SOURCE)
-        #define BOOST_SERIALIZATION_DECL BOOST_SYMBOL_EXPORT
-    #else
-        #define BOOST_SERIALIZATION_DECL BOOST_SYMBOL_IMPORT
-    #endif // defined(BOOST_SERIALIZATION_SOURCE)
-#endif // defined(BOOST_ALL_DYN_LINK) || defined(BOOST_SERIALIZATION_DYN_LINK)
-
-// if BOOST_SERIALIZATION_DECL isn't defined yet define it now:
-#ifndef BOOST_SERIALIZATION_DECL
-    #define BOOST_SERIALIZATION_DECL
-#endif
-
-//  enable automatic library variant selection  ------------------------------// 
-
-#if !defined(BOOST_ALL_NO_LIB) && !defined(BOOST_SERIALIZATION_NO_LIB) \
-&&  !defined(BOOST_ARCHIVE_SOURCE) && !defined(BOOST_WARCHIVE_SOURCE)  \
-&&  !defined(BOOST_SERIALIZATION_SOURCE)
-    //
-    // Set the name of our library, this will get undef'ed by auto_link.hpp
-    // once it's done with it:
-    //
-    #define BOOST_LIB_NAME boost_serialization
-    //
-    // If we're importing code from a dll, then tell auto_link.hpp about it:
-    //
-    #if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_SERIALIZATION_DYN_LINK)
-    #  define BOOST_DYN_LINK
-    #endif
-    //
-    // And include the header that does the work:
-    //
-    #include <boost/config/auto_link.hpp>
-
-#endif  
-
-#endif // BOOST_SERIALIZATION_CONFIG_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/deque.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/deque.hpp
deleted file mode 100644
index bba81364ce2..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/deque.hpp
+++ /dev/null
@@ -1,80 +0,0 @@
-#ifndef  BOOST_SERIALIZATION_DEQUE_HPP
-#define BOOST_SERIALIZATION_DEQUE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// deque.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <deque>
-
-#include <boost/config.hpp>
-
-#include <boost/archive/basic_archive.hpp>
-
-#include <boost/serialization/collections_save_imp.hpp>
-#include <boost/serialization/collections_load_imp.hpp>
-#include <boost/serialization/split_free.hpp>
-
-namespace boost { 
-namespace serialization {
-
-template<class Archive, class U, class Allocator>
-inline void save(
-    Archive & ar,
-    const std::deque<U, Allocator> &t,
-    const unsigned int /* file_version */
-){
-    boost::serialization::stl::save_collection<
-        Archive, std::deque<U, Allocator> 
-    >(ar, t);
-}
-
-template<class Archive, class U, class Allocator>
-inline void load(
-    Archive & ar,
-    std::deque<U, Allocator> &t,
-    const unsigned int /* file_version */
-){
-    const boost::archive::library_version_type library_version(
-        ar.get_library_version()
-    );
-    // retrieve number of elements
-    item_version_type item_version(0);
-    collection_size_type count;
-    ar >> BOOST_SERIALIZATION_NVP(count);
-    if(boost::archive::library_version_type(3) < library_version){
-        ar >> BOOST_SERIALIZATION_NVP(item_version);
-    }
-    stl::collection_load_impl(ar, t, count, item_version);
-}
-
-// split non-intrusive serialization function member into separate
-// non intrusive save/load member functions
-template<class Archive, class U, class Allocator>
-inline void serialize(
-    Archive & ar,
-    std::deque<U, Allocator> &t,
-    const unsigned int file_version
-){
-    boost::serialization::split_free(ar, t, file_version);
-}
-
-} // namespace serialization
-} // namespace boost
-
-#include <boost/serialization/collection_traits.hpp>
-
-BOOST_SERIALIZATION_COLLECTION_TRAITS(std::deque)
-
-#endif // BOOST_SERIALIZATION_DEQUE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/detail/is_default_constructible.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/detail/is_default_constructible.hpp
deleted file mode 100644
index 4d20b13bf3e..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/detail/is_default_constructible.hpp
+++ /dev/null
@@ -1,54 +0,0 @@
-#ifndef  BOOST_SERIALIZATION_DETAIL_IS_DEFAULT_CONSTRUCTIBLE_HPP
-#define BOOST_SERIALIZATION_DETAIL_IS_DEFAULT_CONSTRUCTIBLE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// is_default_constructible.hpp: serialization for loading stl collections
-//
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/config.hpp>
-
-#if ! defined(BOOST_NO_CXX11_HDR_TYPE_TRAITS)
-    #include <type_traits>
-    namespace boost{
-    namespace serialization {
-    namespace detail {
-
-    template<typename T>
-    struct is_default_constructible : public std::is_default_constructible<T> {};
-
-    } // detail
-    } // serializaition
-    } // boost
-#else
-    // we don't have standard library support for is_default_constructible
-    // so we fake it by using boost::has_trivial_construtor.  But this is not
-    // actually correct because it's possible that a default constructor
-    // to be non trivial. So when using this, make sure you're not using your
-    // own definition of of T() but are using the actual default one!
-    #include <boost/type_traits/has_trivial_constructor.hpp>
-    namespace boost{
-    namespace serialization {
-    namespace detail {
-
-    template<typename T>
-    struct is_default_constructible : public boost::has_trivial_constructor<T> {};
-
-    } // detail
-    } // serializaition
-    } // boost
-
-#endif
-
-
-#endif //  BOOST_SERIALIZATION_DETAIL_IS_DEFAULT_CONSTRUCTIBLE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/detail/shared_count_132.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/detail/shared_count_132.hpp
deleted file mode 100644
index a5872557cf2..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/detail/shared_count_132.hpp
+++ /dev/null
@@ -1,551 +0,0 @@
-#ifndef BOOST_DETAIL_SHARED_COUNT_132_HPP_INCLUDED
-#define BOOST_DETAIL_SHARED_COUNT_132_HPP_INCLUDED
-
-// MS compatible compilers support #pragma once
-
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-//
-//  detail/shared_count.hpp
-//
-//  Copyright (c) 2001, 2002, 2003 Peter Dimov and Multi Media Ltd.
-//
-// Distributed under the 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_SP_USE_STD_ALLOCATOR) && defined(BOOST_SP_USE_QUICK_ALLOCATOR)
-# error BOOST_SP_USE_STD_ALLOCATOR and BOOST_SP_USE_QUICK_ALLOCATOR are incompatible.
-#endif
-
-#include <boost/checked_delete.hpp>
-#include <boost/serialization/throw_exception.hpp>
-#include <boost/detail/lightweight_mutex.hpp>
-
-#if defined(BOOST_SP_USE_QUICK_ALLOCATOR)
-#include <boost/detail/quick_allocator.hpp>
-#endif
-
-#include <memory>           // std::auto_ptr, std::allocator
-#include <functional>       // std::less
-#include <exception>        // std::exception
-#include <new>              // std::bad_alloc
-#include <typeinfo>         // std::type_info in get_deleter
-#include <cstddef>          // std::size_t
-
-#include <boost/config.hpp> // msvc 6.0 needs this for warning suppression
-#if defined(BOOST_NO_STDC_NAMESPACE)
-namespace std{ 
-    using ::size_t; 
-} // namespace std
-#endif
-
-namespace boost_132 {
-
-// Debug hooks
-
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
-
-void sp_scalar_constructor_hook(void * px, std::size_t size, void * pn);
-void sp_array_constructor_hook(void * px);
-void sp_scalar_destructor_hook(void * px, std::size_t size, void * pn);
-void sp_array_destructor_hook(void * px);
-
-#endif
-
-
-// The standard library that comes with Borland C++ 5.5.1
-// defines std::exception and its members as having C calling
-// convention (-pc). When the definition of bad_weak_ptr
-// is compiled with -ps, the compiler issues an error.
-// Hence, the temporary #pragma option -pc below. The version
-// check is deliberately conservative.
-
-class bad_weak_ptr: public std::exception
-{
-public:
-
-    virtual char const * what() const throw()
-    {
-        return "boost::bad_weak_ptr";
-    }
-};
-
-namespace detail{
-
-class sp_counted_base
-{
-//private:
-
-    typedef boost::detail::lightweight_mutex mutex_type;
-
-public:
-
-    sp_counted_base(): use_count_(1), weak_count_(1)
-    {
-    }
-
-    virtual ~sp_counted_base() // nothrow
-    {
-    }
-
-    // dispose() is called when use_count_ drops to zero, to release
-    // the resources managed by *this.
-
-    virtual void dispose() = 0; // nothrow
-
-    // destruct() is called when weak_count_ drops to zero.
-
-    virtual void destruct() // nothrow
-    {
-        delete this;
-    }
-
-    virtual void * get_deleter(std::type_info const & ti) = 0;
-
-    void add_ref_copy()
-    {
-#if defined(BOOST_HAS_THREADS)
-        mutex_type::scoped_lock lock(mtx_);
-#endif
-        ++use_count_;
-    }
-
-    void add_ref_lock()
-    {
-#if defined(BOOST_HAS_THREADS)
-        mutex_type::scoped_lock lock(mtx_);
-#endif
-        if(use_count_ == 0) boost::serialization::throw_exception(bad_weak_ptr());
-        ++use_count_;
-    }
-
-    void release() // nothrow
-    {
-        {
-#if defined(BOOST_HAS_THREADS)
-            mutex_type::scoped_lock lock(mtx_);
-#endif
-            long new_use_count = --use_count_;
-
-            if(new_use_count != 0) return;
-        }
-
-        dispose();
-        weak_release();
-    }
-
-    void weak_add_ref() // nothrow
-    {
-#if defined(BOOST_HAS_THREADS)
-        mutex_type::scoped_lock lock(mtx_);
-#endif
-        ++weak_count_;
-    }
-
-    void weak_release() // nothrow
-    {
-        long new_weak_count;
-
-        {
-#if defined(BOOST_HAS_THREADS)
-            mutex_type::scoped_lock lock(mtx_);
-#endif
-            new_weak_count = --weak_count_;
-        }
-
-        if(new_weak_count == 0)
-        {
-            destruct();
-        }
-    }
-
-    long use_count() const // nothrow
-    {
-#if defined(BOOST_HAS_THREADS)
-        mutex_type::scoped_lock lock(mtx_);
-#endif
-        return use_count_;
-    }
-
-//private:
-public:
-    sp_counted_base(sp_counted_base const &);
-    sp_counted_base & operator= (sp_counted_base const &);
-
-    long use_count_;        // #shared
-    long weak_count_;       // #weak + (#shared != 0)
-
-#if defined(BOOST_HAS_THREADS) || defined(BOOST_LWM_WIN32)
-    mutable mutex_type mtx_;
-#endif
-};
-
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
-
-template<class T> void cbi_call_constructor_hook(sp_counted_base * pn, T * px, boost::checked_deleter< T > const &)
-{
-    boost::sp_scalar_constructor_hook(px, sizeof(T), pn);
-}
-
-template<class T> void cbi_call_constructor_hook(sp_counted_base *, T * px, boost::checked_array_deleter< T > const &)
-{
-    boost::sp_array_constructor_hook(px);
-}
-
-template<class P, class D> void cbi_call_constructor_hook(sp_counted_base *, P const &, D const &, long)
-{
-}
-
-template<class T> void cbi_call_destructor_hook(sp_counted_base * pn, T * px, boost::checked_deleter< T > const &)
-{
-    boost::sp_scalar_destructor_hook(px, sizeof(T), pn);
-}
-
-template<class T> void cbi_call_destructor_hook(sp_counted_base *, T * px, boost::checked_array_deleter< T > const &)
-{
-    boost::sp_array_destructor_hook(px);
-}
-
-template<class P, class D> void cbi_call_destructor_hook(sp_counted_base *, P const &, D const &, long)
-{
-}
-
-#endif
-
-//
-// Borland's Codeguard trips up over the -Vx- option here:
-//
-#ifdef __CODEGUARD__
-# pragma option push -Vx-
-#endif
-
-template<class P, class D> class sp_counted_base_impl: public sp_counted_base
-{
-//private:
-public:
-    P ptr; // copy constructor must not throw
-    D del; // copy constructor must not throw
-
-    sp_counted_base_impl(sp_counted_base_impl const &);
-    sp_counted_base_impl & operator= (sp_counted_base_impl const &);
-
-    typedef sp_counted_base_impl<P, D> this_type;
-
-public:
-
-    // pre: initial_use_count <= initial_weak_count, d(p) must not throw
-
-    sp_counted_base_impl(P p, D d): ptr(p), del(d)
-    {
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
-        detail::cbi_call_constructor_hook(this, p, d, 0);
-#endif
-    }
-
-    virtual void dispose() // nothrow
-    {
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
-        detail::cbi_call_destructor_hook(this, ptr, del, 0);
-#endif
-        del(ptr);
-    }
-
-    virtual void * get_deleter(std::type_info const & ti)
-    {
-        return ti == typeid(D)? &del: 0;
-    }
-
-#if defined(BOOST_SP_USE_STD_ALLOCATOR)
-
-    void * operator new(std::size_t)
-    {
-        return std::allocator<this_type>().allocate(1, static_cast<this_type *>(0));
-    }
-
-    void operator delete(void * p)
-    {
-        std::allocator<this_type>().deallocate(static_cast<this_type *>(p), 1);
-    }
-
-#endif
-
-#if defined(BOOST_SP_USE_QUICK_ALLOCATOR)
-
-    void * operator new(std::size_t)
-    {
-        return boost::detail::quick_allocator<this_type>::alloc();
-    }
-
-    void operator delete(void * p)
-    {
-        boost::detail::quick_allocator<this_type>::dealloc(p);
-    }
-
-#endif
-};
-
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
-
-int const shared_count_id = 0x2C35F101;
-int const   weak_count_id = 0x298C38A4;
-
-#endif
-
-class weak_count;
-
-class shared_count
-{
-//private:
-public:
-    sp_counted_base * pi_;
-
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
-    int id_;
-#endif
-
-    friend class weak_count;
-
-public:
-
-    shared_count(): pi_(0) // nothrow
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
-        , id_(shared_count_id)
-#endif
-    {
-    }
-
-    template<class P, class D> shared_count(P p, D d): pi_(0)
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
-        , id_(shared_count_id)
-#endif
-    {
-#ifndef BOOST_NO_EXCEPTIONS
-
-        try
-        {
-            pi_ = new sp_counted_base_impl<P, D>(p, d);
-        }
-        catch(...)
-        {
-            d(p); // delete p
-            throw;
-        }
-
-#else
-
-        pi_ = new sp_counted_base_impl<P, D>(p, d);
-
-        if(pi_ == 0)
-        {
-            d(p); // delete p
-            boost::serialization::throw_exception(std::bad_alloc());
-        }
-
-#endif
-    }
-
-#ifndef BOOST_NO_AUTO_PTR
-
-    // auto_ptr<Y> is special cased to provide the strong guarantee
-
-    template<class Y>
-    explicit shared_count(std::auto_ptr<Y> & r): pi_(
-        new sp_counted_base_impl<
-            Y *, 
-            boost::checked_deleter<Y>
-        >(r.get(), boost::checked_deleter<Y>()))
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
-        , id_(shared_count_id)
-#endif
-    {
-        r.release();
-    }
-
-#endif 
-
-    ~shared_count() // nothrow
-    {
-        if(pi_ != 0) pi_->release();
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
-        id_ = 0;
-#endif
-    }
-
-    shared_count(shared_count const & r): pi_(r.pi_) // nothrow
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
-        , id_(shared_count_id)
-#endif
-    {
-        if(pi_ != 0) pi_->add_ref_copy();
-    }
-
-    explicit shared_count(weak_count const & r); // throws bad_weak_ptr when r.use_count() == 0
-
-    shared_count & operator= (shared_count const & r) // nothrow
-    {
-        sp_counted_base * tmp = r.pi_;
-
-        if(tmp != pi_)
-        {
-            if(tmp != 0) tmp->add_ref_copy();
-            if(pi_ != 0) pi_->release();
-            pi_ = tmp;
-        }
-
-        return *this;
-    }
-
-    void swap(shared_count & r) // nothrow
-    {
-        sp_counted_base * tmp = r.pi_;
-        r.pi_ = pi_;
-        pi_ = tmp;
-    }
-
-    long use_count() const // nothrow
-    {
-        return pi_ != 0? pi_->use_count(): 0;
-    }
-
-    bool unique() const // nothrow
-    {
-        return use_count() == 1;
-    }
-
-    friend inline bool operator==(shared_count const & a, shared_count const & b)
-    {
-        return a.pi_ == b.pi_;
-    }
-
-    friend inline bool operator<(shared_count const & a, shared_count const & b)
-    {
-        return std::less<sp_counted_base *>()(a.pi_, b.pi_);
-    }
-
-    void * get_deleter(std::type_info const & ti) const
-    {
-        return pi_? pi_->get_deleter(ti): 0;
-    }
-};
-
-#ifdef __CODEGUARD__
-# pragma option pop
-#endif
-
-
-class weak_count
-{
-private:
-
-    sp_counted_base * pi_;
-
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
-    int id_;
-#endif
-
-    friend class shared_count;
-
-public:
-
-    weak_count(): pi_(0) // nothrow
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
-        , id_(weak_count_id)
-#endif
-    {
-    }
-
-    weak_count(shared_count const & r): pi_(r.pi_) // nothrow
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
-        , id_(shared_count_id)
-#endif
-    {
-        if(pi_ != 0) pi_->weak_add_ref();
-    }
-
-    weak_count(weak_count const & r): pi_(r.pi_) // nothrow
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
-        , id_(shared_count_id)
-#endif
-    {
-        if(pi_ != 0) pi_->weak_add_ref();
-    }
-
-    ~weak_count() // nothrow
-    {
-        if(pi_ != 0) pi_->weak_release();
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
-        id_ = 0;
-#endif
-    }
-
-    weak_count & operator= (shared_count const & r) // nothrow
-    {
-        sp_counted_base * tmp = r.pi_;
-        if(tmp != 0) tmp->weak_add_ref();
-        if(pi_ != 0) pi_->weak_release();
-        pi_ = tmp;
-
-        return *this;
-    }
-
-    weak_count & operator= (weak_count const & r) // nothrow
-    {
-        sp_counted_base * tmp = r.pi_;
-        if(tmp != 0) tmp->weak_add_ref();
-        if(pi_ != 0) pi_->weak_release();
-        pi_ = tmp;
-
-        return *this;
-    }
-
-    void swap(weak_count & r) // nothrow
-    {
-        sp_counted_base * tmp = r.pi_;
-        r.pi_ = pi_;
-        pi_ = tmp;
-    }
-
-    long use_count() const // nothrow
-    {
-        return pi_ != 0? pi_->use_count(): 0;
-    }
-
-    friend inline bool operator==(weak_count const & a, weak_count const & b)
-    {
-        return a.pi_ == b.pi_;
-    }
-
-    friend inline bool operator<(weak_count const & a, weak_count const & b)
-    {
-        return std::less<sp_counted_base *>()(a.pi_, b.pi_);
-    }
-};
-
-inline shared_count::shared_count(weak_count const & r): pi_(r.pi_)
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
-        , id_(shared_count_id)
-#endif
-{
-    if(pi_ != 0)
-    {
-        pi_->add_ref_lock();
-    }
-    else
-    {
-        boost::serialization::throw_exception(bad_weak_ptr());
-    }
-}
-
-} // namespace detail
-
-} // namespace boost
-
-BOOST_SERIALIZATION_ASSUME_ABSTRACT(boost_132::detail::sp_counted_base)
-
-#endif  // #ifndef BOOST_DETAIL_SHARED_COUNT_HPP_INCLUDED
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/detail/shared_ptr_132.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/detail/shared_ptr_132.hpp
deleted file mode 100644
index ee98b7b9449..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/detail/shared_ptr_132.hpp
+++ /dev/null
@@ -1,443 +0,0 @@
-#ifndef BOOST_SHARED_PTR_132_HPP_INCLUDED
-#define BOOST_SHARED_PTR_132_HPP_INCLUDED
-
-//
-//  shared_ptr.hpp
-//
-//  (C) Copyright Greg Colvin and Beman Dawes 1998, 1999.
-//  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)
-//
-//  See http://www.boost.org/libs/smart_ptr/shared_ptr.htm for documentation.
-//
-
-#include <boost/config.hpp>   // for broken compiler workarounds
-
-#if defined(BOOST_NO_MEMBER_TEMPLATES) && !defined(BOOST_MSVC6_MEMBER_TEMPLATES)
-#include <boost/serialization/detail/shared_ptr_nmt_132.hpp>
-#else
-
-#include <boost/assert.hpp>
-#include <boost/checked_delete.hpp>
-#include <boost/serialization/throw_exception.hpp>
-#include <boost/detail/workaround.hpp>
-
-#include <boost/serialization/access.hpp>
-#include <boost/serialization/detail/shared_count_132.hpp>
-
-#include <memory>               // for std::auto_ptr
-#include <algorithm>            // for std::swap
-#include <functional>           // for std::less
-#include <typeinfo>             // for std::bad_cast
-#include <iosfwd>               // for std::basic_ostream
-
-#ifdef BOOST_MSVC  // moved here to work around VC++ compiler crash
-# pragma warning(push)
-# pragma warning(disable:4284) // odd return type for operator->
-#endif
-
-namespace boost_132 {
-
-template<class T> class weak_ptr;
-template<class T> class enable_shared_from_this;
-
-namespace detail
-{
-
-struct static_cast_tag {};
-struct const_cast_tag {};
-struct dynamic_cast_tag {};
-struct polymorphic_cast_tag {};
-
-template<class T> struct shared_ptr_traits
-{
-    typedef T & reference;
-};
-
-template<> struct shared_ptr_traits<void>
-{
-    typedef void reference;
-};
-
-#if !defined(BOOST_NO_CV_VOID_SPECIALIZATIONS)
-
-template<> struct shared_ptr_traits<void const>
-{
-    typedef void reference;
-};
-
-template<> struct shared_ptr_traits<void volatile>
-{
-    typedef void reference;
-};
-
-template<> struct shared_ptr_traits<void const volatile>
-{
-    typedef void reference;
-};
-
-#endif
-
-// enable_shared_from_this support
-
-template<class T, class Y> void sp_enable_shared_from_this( shared_count const & pn, enable_shared_from_this< T > const * pe, Y const * px )
-{
-    if(pe != 0) pe->_internal_weak_this._internal_assign(const_cast<Y*>(px), pn);
-}
-
-inline void sp_enable_shared_from_this( shared_count const & /*pn*/, ... )
-{
-}
-
-} // namespace detail
-
-
-//
-//  shared_ptr
-//
-//  An enhanced relative of scoped_ptr with reference counted copy semantics.
-//  The object pointed to is deleted when the last shared_ptr pointing to it
-//  is destroyed or reset.
-//
-
-template<class T> class shared_ptr
-{
-private:
-    // Borland 5.5.1 specific workaround
-    typedef shared_ptr< T > this_type;
-
-public:
-
-    typedef T element_type;
-    typedef T value_type;
-    typedef T * pointer;
-    typedef typename detail::shared_ptr_traits< T >::reference reference;
-
-    shared_ptr(): px(0), pn() // never throws in 1.30+
-    {
-    }
-
-    template<class Y>
-    explicit shared_ptr(Y * p): px(p), pn(p, boost::checked_deleter<Y>()) // Y must be complete
-    {
-        detail::sp_enable_shared_from_this( pn, p, p );
-    }
-
-    //
-    // Requirements: D's copy constructor must not throw
-    //
-    // shared_ptr will release p by calling d(p)
-    //
-
-    template<class Y, class D> shared_ptr(Y * p, D d): px(p), pn(p, d)
-    {
-        detail::sp_enable_shared_from_this( pn, p, p );
-    }
-
-//  generated copy constructor, assignment, destructor are fine...
-
-//  except that Borland C++ has a bug, and g++ with -Wsynth warns
-#if defined(__GNUC__)
-    shared_ptr & operator=(shared_ptr const & r) // never throws
-    {
-        px = r.px;
-        pn = r.pn; // shared_count::op= doesn't throw
-        return *this;
-    }
-#endif
-
-    template<class Y>
-    explicit shared_ptr(weak_ptr<Y> const & r): pn(r.pn) // may throw
-    {
-        // it is now safe to copy r.px, as pn(r.pn) did not throw
-        px = r.px;
-    }
-
-    template<class Y>
-    shared_ptr(shared_ptr<Y> const & r): px(r.px), pn(r.pn) // never throws
-    {
-    }
-
-    template<class Y>
-    shared_ptr(shared_ptr<Y> const & r, detail::static_cast_tag): px(static_cast<element_type *>(r.px)), pn(r.pn)
-    {
-    }
-
-    template<class Y>
-    shared_ptr(shared_ptr<Y> const & r, detail::const_cast_tag): px(const_cast<element_type *>(r.px)), pn(r.pn)
-    {
-    }
-
-    template<class Y>
-    shared_ptr(shared_ptr<Y> const & r, detail::dynamic_cast_tag): px(dynamic_cast<element_type *>(r.px)), pn(r.pn)
-    {
-        if(px == 0) // need to allocate new counter -- the cast failed
-        {
-            pn = detail::shared_count();
-        }
-    }
-
-    template<class Y>
-    shared_ptr(shared_ptr<Y> const & r, detail::polymorphic_cast_tag): px(dynamic_cast<element_type *>(r.px)), pn(r.pn)
-    {
-        if(px == 0)
-        {
-            boost::serialization::throw_exception(std::bad_cast());
-        }
-    }
-
-#ifndef BOOST_NO_AUTO_PTR
-
-    template<class Y>
-    explicit shared_ptr(std::auto_ptr<Y> & r): px(r.get()), pn()
-    {
-        Y * tmp = r.get();
-        pn = detail::shared_count(r);
-        detail::sp_enable_shared_from_this( pn, tmp, tmp );
-    }
-
-#endif
-
-#if !defined(BOOST_MSVC) || (BOOST_MSVC > 1200)
-
-    template<class Y>
-    shared_ptr & operator=(shared_ptr<Y> const & r) // never throws
-    {
-        px = r.px;
-        pn = r.pn; // shared_count::op= doesn't throw
-        return *this;
-    }
-
-#endif
-
-#ifndef BOOST_NO_AUTO_PTR
-
-    template<class Y>
-    shared_ptr & operator=(std::auto_ptr<Y> & r)
-    {
-        this_type(r).swap(*this);
-        return *this;
-    }
-
-#endif
-
-    void reset() // never throws in 1.30+
-    {
-        this_type().swap(*this);
-    }
-
-    template<class Y> void reset(Y * p) // Y must be complete
-    {
-        BOOST_ASSERT(p == 0 || p != px); // catch self-reset errors
-        this_type(p).swap(*this);
-    }
-
-    template<class Y, class D> void reset(Y * p, D d)
-    {
-        this_type(p, d).swap(*this);
-    }
-
-    reference operator* () const // never throws
-    {
-        BOOST_ASSERT(px != 0);
-        return *px;
-    }
-
-    T * operator-> () const // never throws
-    {
-        BOOST_ASSERT(px != 0);
-        return px;
-    }
-    
-    T * get() const // never throws
-    {
-        return px;
-    }
-
-    // implicit conversion to "bool"
-
-#if defined(__SUNPRO_CC) && BOOST_WORKAROUND(__SUNPRO_CC, <= 0x530)
-
-    operator bool () const
-    {
-        return px != 0;
-    }
-
-#elif defined(__MWERKS__) && BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3003))
-    typedef T * (this_type::*unspecified_bool_type)() const;
-    
-    operator unspecified_bool_type() const // never throws
-    {
-        return px == 0? 0: &this_type::get;
-    }
-
-#else 
-
-    typedef T * this_type::*unspecified_bool_type;
-
-    operator unspecified_bool_type() const // never throws
-    {
-        return px == 0? 0: &this_type::px;
-    }
-
-#endif
-
-    // operator! is redundant, but some compilers need it
-
-    bool operator! () const // never throws
-    {
-        return px == 0;
-    }
-
-    bool unique() const // never throws
-    {
-        return pn.unique();
-    }
-
-    long use_count() const // never throws
-    {
-        return pn.use_count();
-    }
-
-    void swap(shared_ptr< T > & other) // never throws
-    {
-        std::swap(px, other.px);
-        pn.swap(other.pn);
-    }
-
-    template<class Y> bool _internal_less(shared_ptr<Y> const & rhs) const
-    {
-        return pn < rhs.pn;
-    }
-
-    void * _internal_get_deleter(std::type_info const & ti) const
-    {
-        return pn.get_deleter(ti);
-    }
-
-// Tasteless as this may seem, making all members public allows member templates
-// to work in the absence of member template friends. (Matthew Langston)
-
-#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
-
-private:
-
-    template<class Y> friend class shared_ptr;
-    template<class Y> friend class weak_ptr;
-
-
-#endif
-public: // for serialization
-    T * px;                     // contained pointer
-    detail::shared_count pn;    // reference counter
-
-};  // shared_ptr
-
-template<class T, class U> inline bool operator==(shared_ptr< T > const & a, shared_ptr<U> const & b)
-{
-    return a.get() == b.get();
-}
-
-template<class T, class U> inline bool operator!=(shared_ptr< T > const & a, shared_ptr<U> const & b)
-{
-    return a.get() != b.get();
-}
-
-template<class T, class U> inline bool operator<(shared_ptr< T > const & a, shared_ptr<U> const & b)
-{
-    return a._internal_less(b);
-}
-
-template<class T> inline void swap(shared_ptr< T > & a, shared_ptr< T > & b)
-{
-    a.swap(b);
-}
-
-template<class T, class U> shared_ptr< T > static_pointer_cast(shared_ptr<U> const & r)
-{
-    return shared_ptr< T >(r, detail::static_cast_tag());
-}
-
-template<class T, class U> shared_ptr< T > const_pointer_cast(shared_ptr<U> const & r)
-{
-    return shared_ptr< T >(r, detail::const_cast_tag());
-}
-
-template<class T, class U> shared_ptr< T > dynamic_pointer_cast(shared_ptr<U> const & r)
-{
-    return shared_ptr< T >(r, detail::dynamic_cast_tag());
-}
-
-// shared_*_cast names are deprecated. Use *_pointer_cast instead.
-
-template<class T, class U> shared_ptr< T > shared_static_cast(shared_ptr<U> const & r)
-{
-    return shared_ptr< T >(r, detail::static_cast_tag());
-}
-
-template<class T, class U> shared_ptr< T > shared_dynamic_cast(shared_ptr<U> const & r)
-{
-    return shared_ptr< T >(r, detail::dynamic_cast_tag());
-}
-
-template<class T, class U> shared_ptr< T > shared_polymorphic_cast(shared_ptr<U> const & r)
-{
-    return shared_ptr< T >(r, detail::polymorphic_cast_tag());
-}
-
-template<class T, class U> shared_ptr< T > shared_polymorphic_downcast(shared_ptr<U> const & r)
-{
-    BOOST_ASSERT(dynamic_cast<T *>(r.get()) == r.get());
-    return shared_static_cast< T >(r);
-}
-
-// get_pointer() enables boost::mem_fn to recognize shared_ptr
-
-template<class T> inline T * get_pointer(shared_ptr< T > const & p)
-{
-    return p.get();
-}
-
-// operator<<
-
-
-template<class E, class T, class Y> std::basic_ostream<E, T> & operator<< (std::basic_ostream<E, T> & os, shared_ptr<Y> const & p)
-{
-    os << p.get();
-    return os;
-}
-
-// get_deleter (experimental)
-
-#if defined(__EDG_VERSION__) && (__EDG_VERSION__ <= 238)
-
-// g++ 2.9x doesn't allow static_cast<X const *>(void *)
-// apparently EDG 2.38 also doesn't accept it
-
-template<class D, class T> D * get_deleter(shared_ptr< T > const & p)
-{
-    void const * q = p._internal_get_deleter(typeid(D));
-    return const_cast<D *>(static_cast<D const *>(q));
-}
-
-#else
-
-template<class D, class T> D * get_deleter(shared_ptr< T > const & p)
-{
-    return static_cast<D *>(p._internal_get_deleter(typeid(D)));
-}
-
-#endif
-
-} // namespace boost
-
-#ifdef BOOST_MSVC
-# pragma warning(pop)
-#endif    
-
-#endif  // #if defined(BOOST_NO_MEMBER_TEMPLATES) && !defined(BOOST_MSVC6_MEMBER_TEMPLATES)
-
-#endif  // #ifndef BOOST_SHARED_PTR_132_HPP_INCLUDED
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/detail/shared_ptr_nmt_132.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/detail/shared_ptr_nmt_132.hpp
deleted file mode 100644
index 490e7ddd3d0..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/detail/shared_ptr_nmt_132.hpp
+++ /dev/null
@@ -1,182 +0,0 @@
-#ifndef BOOST_DETAIL_SHARED_PTR_NMT_132_HPP_INCLUDED
-#define BOOST_DETAIL_SHARED_PTR_NMT_132_HPP_INCLUDED
-
-//
-//  detail/shared_ptr_nmt.hpp - shared_ptr.hpp without member templates
-//
-//  (C) Copyright Greg Colvin and Beman Dawes 1998, 1999.
-//  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)
-//
-//  See http://www.boost.org/libs/smart_ptr/shared_ptr.htm for documentation.
-//
-
-#include <boost/assert.hpp>
-#include <boost/checked_delete.hpp>
-#include <boost/serialization/throw_exception.hpp>
-#include <boost/detail/atomic_count.hpp>
-
-#ifndef BOOST_NO_AUTO_PTR
-# include <memory>          // for std::auto_ptr
-#endif
-
-#include <algorithm>        // for std::swap
-#include <functional>       // for std::less
-#include <new>              // for std::bad_alloc
-
-namespace boost
-{
-
-template<class T> class shared_ptr
-{
-private:
-
-    typedef detail::atomic_count count_type;
-
-public:
-
-    typedef T element_type;
-    typedef T value_type;
-
-    explicit shared_ptr(T * p = 0): px(p)
-    {
-#ifndef BOOST_NO_EXCEPTIONS
-
-        try  // prevent leak if new throws
-        {
-            pn = new count_type(1);
-        }
-        catch(...)
-        {
-            boost::checked_delete(p);
-            throw;
-        }
-
-#else
-
-        pn = new count_type(1);
-
-        if(pn == 0)
-        {
-            boost::checked_delete(p);
-            boost::serialization::throw_exception(std::bad_alloc());
-        }
-
-#endif
-    }
-
-    ~shared_ptr()
-    {
-        if(--*pn == 0)
-        {
-            boost::checked_delete(px);
-            delete pn;
-        }
-    }
-
-    shared_ptr(shared_ptr const & r): px(r.px)  // never throws
-    {
-        pn = r.pn;
-        ++*pn;
-    }
-
-    shared_ptr & operator=(shared_ptr const & r)
-    {
-        shared_ptr(r).swap(*this);
-        return *this;
-    }
-
-#ifndef BOOST_NO_AUTO_PTR
-
-    explicit shared_ptr(std::auto_ptr< T > & r)
-    { 
-        pn = new count_type(1); // may throw
-        px = r.release(); // fix: moved here to stop leak if new throws
-    } 
-
-    shared_ptr & operator=(std::auto_ptr< T > & r)
-    {
-        shared_ptr(r).swap(*this);
-        return *this;
-    }
-
-#endif
-
-    void reset(T * p = 0)
-    {
-        BOOST_ASSERT(p == 0 || p != px);
-        shared_ptr(p).swap(*this);
-    }
-
-    T & operator*() const  // never throws
-    {
-        BOOST_ASSERT(px != 0);
-        return *px;
-    }
-
-    T * operator->() const  // never throws
-    {
-        BOOST_ASSERT(px != 0);
-        return px;
-    }
-
-    T * get() const  // never throws
-    {
-        return px;
-    }
-
-    long use_count() const  // never throws
-    {
-        return *pn;
-    }
-
-    bool unique() const  // never throws
-    {
-        return *pn == 1;
-    }
-    
-    void swap(shared_ptr< T > & other)  // never throws
-    {
-        std::swap(px, other.px);
-        std::swap(pn, other.pn);
-    }
-
-private:
-
-    T * px;            // contained pointer
-    count_type * pn;   // ptr to reference counter
-};
-
-template<class T, class U> inline bool operator==(shared_ptr< T > const & a, shared_ptr<U> const & b)
-{
-    return a.get() == b.get();
-}
-
-template<class T, class U> inline bool operator!=(shared_ptr< T > const & a, shared_ptr<U> const & b)
-{
-    return a.get() != b.get();
-}
-
-template<class T> inline bool operator<(shared_ptr< T > const & a, shared_ptr< T > const & b)
-{
-    return std::less<T*>()(a.get(), b.get());
-}
-
-template<class T> void swap(shared_ptr< T > & a, shared_ptr< T > & b)
-{
-    a.swap(b);
-}
-
-// get_pointer() enables boost::mem_fn to recognize shared_ptr
-
-template<class T> inline T * get_pointer(shared_ptr< T > const & p)
-{
-    return p.get();
-}
-
-} // namespace boost
-
-#endif  // #ifndef BOOST_DETAIL_SHARED_PTR_NMT_132_HPP_INCLUDED
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/detail/stack_constructor.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/detail/stack_constructor.hpp
deleted file mode 100644
index ae14832c6db..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/detail/stack_constructor.hpp
+++ /dev/null
@@ -1,66 +0,0 @@
-#ifndef  BOOST_SERIALIZATION_DETAIL_STACK_CONSTRUCTOR_HPP
-#define BOOST_SERIALIZATION_DETAIL_STACK_CONSTRUCTOR_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// stack_constructor.hpp: serialization for loading stl collections
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/aligned_storage.hpp>
-#include <boost/serialization/serialization.hpp>
-
-namespace boost{
-namespace serialization {
-namespace detail {
-
-// reserve space on stack for an object of type T without actually
-// construction such an object
-template<typename T > 
-struct stack_allocate
-{
-    T * address() {
-        return static_cast<T*>(storage_.address()); 
-    }
-    T & reference() {
-        return * address();
-    }
-private:
-    typedef typename boost::aligned_storage<
-        sizeof(T), 
-        boost::alignment_of<T>::value
-    > type;
-    type storage_;
-};
-
-// construct element on the stack
-template<class Archive, class T>
-struct stack_construct : public stack_allocate<T>
-{
-    stack_construct(Archive & ar, const unsigned int version){
-        // note borland emits a no-op without the explicit namespace
-        boost::serialization::load_construct_data_adl(
-            ar, 
-            this->address(), 
-            version
-        );
-    }
-    ~stack_construct(){
-        this->address()->~T(); // undo load_construct_data above
-    }
-};
-
-} // detail
-} // serializaition
-} // boost
-
-#endif //  BOOST_SERIALIZATION_DETAIL_STACH_CONSTRUCTOR_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/ephemeral.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/ephemeral.hpp
deleted file mode 100644
index 3a422c30a35..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/ephemeral.hpp
+++ /dev/null
@@ -1,72 +0,0 @@
-#ifndef BOOST_SERIALIZATION_EPHEMERAL_HPP
-#define BOOST_SERIALIZATION_EPHEMERAL_HPP
-
-// MS compatible compilers support 
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// ephemeral_object.hpp: interface for serialization system.
-
-// (C) Copyright 2007 Matthias Troyer. 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <utility>
-
-#include <boost/config.hpp>
-#include <boost/detail/workaround.hpp>
-
-#include <boost/mpl/integral_c.hpp>
-#include <boost/mpl/integral_c_tag.hpp>
-
-#include <boost/serialization/level.hpp>
-#include <boost/serialization/tracking.hpp>
-#include <boost/serialization/split_member.hpp>
-#include <boost/serialization/base_object.hpp>
-#include <boost/serialization/traits.hpp>
-#include <boost/serialization/wrapper.hpp>
-
-namespace boost {
-namespace serialization {
-
-template<class T>
-struct ephemeral_object : 
-    public wrapper_traits<ephemeral_object<T> >
-{
-    explicit ephemeral_object(T& t) :
-        val(t)
-    {}
-
-    T & value() const {
-        return val;
-    }
-
-    const T & const_value() const {
-        return val;
-    }
-
-    template<class Archive>
-    void serialize(Archive &ar, const unsigned int) const
-    {
-       ar & val;
-    }
-
-private:
-    T & val;
-};
-
-template<class T>
-inline
-const ephemeral_object<T> ephemeral(const char * name, T & t){
-    return ephemeral_object<T>(name, t);
-}
-
-} // seralization
-} // boost
-
-#endif // BOOST_SERIALIZATION_EPHEMERAL_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/export.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/export.hpp
deleted file mode 100644
index 9eef440df42..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/export.hpp
+++ /dev/null
@@ -1,225 +0,0 @@
-#ifndef BOOST_SERIALIZATION_EXPORT_HPP
-#define BOOST_SERIALIZATION_EXPORT_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// export.hpp: set traits of classes to be serialized
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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 2006 David Abrahams - http://www.boost.org.
-// implementation of class export functionality.  This is an alternative to
-// "forward declaration" method to provoke instantiation of derived classes
-// that are to be serialized through pointers.
-
-#include <utility>
-#include <cstddef> // NULL
-
-#include <boost/config.hpp>
-#include <boost/static_assert.hpp>
-#include <boost/preprocessor/stringize.hpp>
-#include <boost/type_traits/is_polymorphic.hpp>
-
-#include <boost/mpl/assert.hpp>
-#include <boost/mpl/and.hpp>
-#include <boost/mpl/not.hpp>
-#include <boost/mpl/bool_fwd.hpp>
-
-#include <boost/serialization/extended_type_info.hpp> // for guid_defined only
-#include <boost/serialization/static_warning.hpp>
-#include <boost/serialization/assume_abstract.hpp>
-#include <boost/serialization/force_include.hpp>
-#include <boost/serialization/singleton.hpp>
-
-#include <boost/archive/detail/register_archive.hpp>
-
-#include <iostream>
-
-namespace boost {
-namespace archive {
-namespace detail {
-
-class basic_pointer_iserializer;
-class basic_pointer_oserializer;
-
-template<class Archive, class T>
-class pointer_iserializer;
-template<class Archive, class T>
-class pointer_oserializer;
-
-template <class Archive, class Serializable>
-struct export_impl
-{
-    static const basic_pointer_iserializer &
-    enable_load(mpl::true_){
-        return boost::serialization::singleton<
-            pointer_iserializer<Archive, Serializable> 
-        >::get_const_instance();
-    }
-
-    static const basic_pointer_oserializer &
-    enable_save(mpl::true_){
-        return boost::serialization::singleton<
-            pointer_oserializer<Archive, Serializable> 
-        >::get_const_instance();
-    }
-    inline static void enable_load(mpl::false_) {}
-    inline static void enable_save(mpl::false_) {}
-};
-
-// On many platforms, naming a specialization of this template is
-// enough to cause its argument to be instantiated.
-template <void(*)()>
-struct instantiate_function {};
-
-template <class Archive, class Serializable>
-struct ptr_serialization_support
-{
-# if defined(BOOST_MSVC) || defined(__SUNPRO_CC)
-    virtual BOOST_DLLEXPORT void instantiate() BOOST_USED;
-# else
-    static BOOST_DLLEXPORT void instantiate() BOOST_USED;
-    typedef instantiate_function<
-        &ptr_serialization_support::instantiate
-    > x;
-# endif
-};
-
-template <class Archive, class Serializable>
-BOOST_DLLEXPORT void 
-ptr_serialization_support<Archive,Serializable>::instantiate()
-{
-    export_impl<Archive,Serializable>::enable_save(
-        typename Archive::is_saving()
-    );
-
-    export_impl<Archive,Serializable>::enable_load(
-        typename Archive::is_loading()
-    );
-}
-
-// Note INTENTIONAL usage of anonymous namespace in header.
-// This was made this way so that export.hpp could be included
-// in other headers.  This is still under study.
-
-namespace extra_detail {
-
-template<class T>
-struct guid_initializer
-{
-    void export_guid(mpl::false_) const {
-        // generates the statically-initialized objects whose constructors
-        // register the information allowing serialization of T objects
-        // through pointers to their base classes.
-        instantiate_ptr_serialization((T*)0, 0, adl_tag());
-    }
-    void export_guid(mpl::true_) const {
-    }
-    guid_initializer const & export_guid() const {
-        BOOST_STATIC_WARNING(boost::is_polymorphic< T >::value);
-        // note: exporting an abstract base class will have no effect
-        // and cannot be used to instantitiate serialization code
-        // (one might be using this in a DLL to instantiate code)
-        //BOOST_STATIC_WARNING(! boost::serialization::is_abstract< T >::value);
-        export_guid(boost::serialization::is_abstract< T >());
-        return *this;
-    }
-};
-
-template<typename T>
-struct init_guid;
-
-} // anonymous
-} // namespace detail
-} // namespace archive
-} // namespace boost
-
-#define BOOST_CLASS_EXPORT_IMPLEMENT(T)                      \
-    namespace boost {                                        \
-    namespace archive {                                      \
-    namespace detail {                                       \
-    namespace extra_detail {                                 \
-    template<>                                               \
-    struct init_guid< T > {                                  \
-        static guid_initializer< T > const & g;              \
-    };                                                       \
-    guid_initializer< T > const & init_guid< T >::g =        \
-        ::boost::serialization::singleton<                   \
-            guid_initializer< T >                            \
-        >::get_mutable_instance().export_guid();             \
-    }}}}                                                     \
-/**/
-
-#define BOOST_CLASS_EXPORT_KEY2(T, K)          \
-namespace boost {                              \
-namespace serialization {                      \
-template<>                                     \
-struct guid_defined< T > : boost::mpl::true_ {}; \
-template<>                                     \
-inline const char * guid< T >(){                 \
-    return K;                                  \
-}                                              \
-} /* serialization */                          \
-} /* boost */                                  \
-/**/
-
-#define BOOST_CLASS_EXPORT_KEY(T)                                      \
-    BOOST_CLASS_EXPORT_KEY2(T, BOOST_PP_STRINGIZE(T))                                                                  \
-/**/
-
-#define BOOST_CLASS_EXPORT_GUID(T, K)                                  \
-BOOST_CLASS_EXPORT_KEY2(T, K)                                          \
-BOOST_CLASS_EXPORT_IMPLEMENT(T)                                        \
-/**/
-
-#if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3205))
-
-// CodeWarrior fails to construct static members of class templates
-// when they are instantiated from within templates, so on that
-// compiler we ask users to specifically register base/derived class
-// relationships for exported classes.  On all other compilers, use of
-// this macro is entirely optional.
-# define BOOST_SERIALIZATION_MWERKS_BASE_AND_DERIVED(Base,Derived)             \
-namespace {                                                                    \
-  static int BOOST_PP_CAT(boost_serialization_mwerks_init_, __LINE__) =        \
-  (::boost::archive::detail::instantiate_ptr_serialization((Derived*)0,0), 3); \
-  static int BOOST_PP_CAT(boost_serialization_mwerks_init2_, __LINE__) = (     \
-      ::boost::serialization::void_cast_register((Derived*)0,(Base*)0)         \
-    , 3);                                                                      \
-}
-
-#else
-
-# define BOOST_SERIALIZATION_MWERKS_BASE_AND_DERIVED(Base,Derived)
-
-#endif 
-
-// check for unnecessary export.  T isn't polymorphic so there is no
-// need to export it.
-#define BOOST_CLASS_EXPORT_CHECK(T)                              \
-    BOOST_STATIC_WARNING(                                        \
-        boost::is_polymorphic<U>::value                          \
-    );                                                           \
-    /**/
-
-// the default exportable class identifier is the class name
-// the default list of archives types for which code id generated
-// are the originally included with this serialization system
-#define BOOST_CLASS_EXPORT(T)                   \
-    BOOST_CLASS_EXPORT_GUID(                    \
-        T,                                      \
-        BOOST_PP_STRINGIZE(T)                   \
-    )                                           \
-    /**/
-
-#endif // BOOST_SERIALIZATION_EXPORT_HPP
-
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/extended_type_info.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/extended_type_info.hpp
deleted file mode 100644
index bb2a190d465..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/extended_type_info.hpp
+++ /dev/null
@@ -1,116 +0,0 @@
-#ifndef BOOST_SERIALIZATION_EXTENDED_TYPE_INFO_HPP
-#define BOOST_SERIALIZATION_EXTENDED_TYPE_INFO_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// extended_type_info.hpp: interface for portable version of type_info
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-// for now, extended type info is part of the serialization libraries
-// this could change in the future.
-#include <cstdarg>
-#include <boost/assert.hpp>
-#include <cstddef> // NULL
-#include <boost/config.hpp>
-#include <boost/noncopyable.hpp>
-#include <boost/mpl/bool.hpp>
-
-#include <boost/serialization/config.hpp>
-#include <boost/config/abi_prefix.hpp> // must be the last header
-#ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable : 4251 4231 4660 4275)
-#endif
-
-#define BOOST_SERIALIZATION_MAX_KEY_SIZE 128
-
-namespace boost { 
-namespace serialization {
-
-namespace void_cast_detail{
-    class void_caster;
-}
-
-class BOOST_SYMBOL_VISIBLE extended_type_info :
-    private boost::noncopyable
-{
-private:
-    friend class boost::serialization::void_cast_detail::void_caster;
-
-    // used to uniquely identify the type of class derived from this one
-    // so that different derivations of this class can be simultaneously
-    // included in implementation of sets and maps.
-    const unsigned int m_type_info_key;
-    virtual bool is_less_than(const extended_type_info & /*rhs*/) const = 0;
-    virtual bool is_equal(const extended_type_info & /*rhs*/) const = 0;
-    const char * m_key;
-
-protected:
-    BOOST_SERIALIZATION_DECL void key_unregister() const;
-    BOOST_SERIALIZATION_DECL void key_register() const;
-    // this class can't be used as is. It's just the 
-    // common functionality for all type_info replacement
-    // systems.  Hence, make these protected
-    BOOST_SERIALIZATION_DECL extended_type_info(
-        const unsigned int type_info_key,
-        const char * key
-    );
-    virtual BOOST_SERIALIZATION_DECL ~extended_type_info();
-public:
-    const char * get_key() const {
-        return m_key;
-    }
-    virtual const char * get_debug_info() const = 0;
-    BOOST_SERIALIZATION_DECL bool operator<(const extended_type_info &rhs) const;
-    BOOST_SERIALIZATION_DECL bool operator==(const extended_type_info &rhs) const;
-    bool operator!=(const extended_type_info &rhs) const {
-        return !(operator==(rhs));
-    }
-    // note explicit "export" of static function to work around
-    // gcc 4.5 mingw error
-    static BOOST_SERIALIZATION_DECL const extended_type_info *
-    find(const char *key);
-    // for plugins
-    virtual void * construct(unsigned int /*count*/ = 0, ...) const = 0;
-    virtual void destroy(void const * const /*p*/) const = 0;
-};
-
-template<class T>
-struct guid_defined : boost::mpl::false_ {};
-
-namespace ext {
-    template <typename T>
-    struct guid_impl
-    {
-        static inline const char * call()
-        {
-            return NULL;
-        }
-    };
-}
-
-template<class T>
-inline const char * guid(){
-    return ext::guid_impl<T>::call();
-}
-
-} // namespace serialization 
-} // namespace boost
-
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
-
-#include <boost/config/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
-
-#endif // BOOST_SERIALIZATION_EXTENDED_TYPE_INFO_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/extended_type_info_no_rtti.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/extended_type_info_no_rtti.hpp
deleted file mode 100644
index aaa8b44459b..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/extended_type_info_no_rtti.hpp
+++ /dev/null
@@ -1,182 +0,0 @@
-#ifndef BOOST_EXTENDED_TYPE_INFO_NO_RTTI_HPP
-#define BOOST_EXTENDED_TYPE_INFO_NO_RTTI_HPP
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-// extended_type_info_no_rtti.hpp: implementation for version that depends
-// on runtime typing (rtti - typeid) but uses a user specified string
-// as the portable class identifier.
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-#include <boost/assert.hpp>
-
-#include <boost/config.hpp>
-#include <boost/static_assert.hpp>
-
-#include <boost/mpl/if.hpp>
-#include <boost/type_traits/is_polymorphic.hpp>
-#include <boost/type_traits/remove_const.hpp>
-
-#include <boost/serialization/static_warning.hpp>
-#include <boost/serialization/singleton.hpp>
-#include <boost/serialization/extended_type_info.hpp>
-#include <boost/serialization/factory.hpp>
-#include <boost/serialization/throw_exception.hpp>
-
-#include <boost/serialization/config.hpp>
-// hijack serialization access
-#include <boost/serialization/access.hpp>
-
-#include <boost/config/abi_prefix.hpp> // must be the last header
-#ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable : 4251 4231 4660 4275 4511 4512)
-#endif
-
-namespace boost {
-namespace serialization {
-///////////////////////////////////////////////////////////////////////
-// define a special type_info that doesn't depend on rtti which is not
-// available in all situations.
-
-namespace no_rtti_system {
-
-// common base class to share type_info_key.  This is used to 
-// identify the method used to keep track of the extended type
-class BOOST_SYMBOL_VISIBLE extended_type_info_no_rtti_0 :
-    public extended_type_info
-{
-protected:
-    BOOST_SERIALIZATION_DECL extended_type_info_no_rtti_0(const char * key);
-    BOOST_SERIALIZATION_DECL ~extended_type_info_no_rtti_0();
-public:
-    virtual BOOST_SERIALIZATION_DECL bool
-    is_less_than(const boost::serialization::extended_type_info &rhs) const ;
-    virtual BOOST_SERIALIZATION_DECL bool
-    is_equal(const boost::serialization::extended_type_info &rhs) const ;
-};
-
-} // no_rtti_system
-
-template<class T>
-class extended_type_info_no_rtti : 
-    public no_rtti_system::extended_type_info_no_rtti_0,
-    public singleton<extended_type_info_no_rtti< T > >
-{
-    template<bool tf>
-    struct action {
-        struct defined {
-            static const char * invoke(){
-                return guid< T >();
-            }
-        };
-        struct undefined {
-            // if your program traps here - you failed to 
-            // export a guid for this type.  the no_rtti
-            // system requires export for types serialized
-            // as pointers.
-            BOOST_STATIC_ASSERT(0 == sizeof(T));
-            static const char * invoke();
-        };
-        static const char * invoke(){
-            typedef 
-                typename boost::mpl::if_c<
-                    tf,
-                    defined,
-                    undefined
-                >::type type;
-            return type::invoke();
-        }
-    };
-public:
-    extended_type_info_no_rtti() :
-        no_rtti_system::extended_type_info_no_rtti_0(get_key())
-    {
-        key_register();
-    }
-    ~extended_type_info_no_rtti(){
-        key_unregister();
-    }
-    const extended_type_info *
-    get_derived_extended_type_info(const T & t) const {
-        // find the type that corresponds to the most derived type.
-        // this implementation doesn't depend on typeid() but assumes
-        // that the specified type has a function of the following signature.
-        // A common implemention of such a function is to define as a virtual
-        // function. So if the is not a polymporphic type it's likely an error
-        BOOST_STATIC_WARNING(boost::is_polymorphic< T >::value);
-        const char * derived_key = t.get_key();
-        BOOST_ASSERT(NULL != derived_key);
-        return boost::serialization::extended_type_info::find(derived_key);
-    }
-    const char * get_key() const{
-        return action<guid_defined< T >::value >::invoke();
-    }
-    virtual const char * get_debug_info() const{
-        return action<guid_defined< T >::value >::invoke();
-    }
-    virtual void * construct(unsigned int count, ...) const{
-        // count up the arguments
-        std::va_list ap;
-        va_start(ap, count);
-        switch(count){
-        case 0:
-            return factory<typename boost::remove_const< T >::type, 0>(ap);
-        case 1:
-            return factory<typename boost::remove_const< T >::type, 1>(ap);
-        case 2:
-            return factory<typename boost::remove_const< T >::type, 2>(ap);
-        case 3:
-            return factory<typename boost::remove_const< T >::type, 3>(ap);
-        case 4:
-            return factory<typename boost::remove_const< T >::type, 4>(ap);
-        default:
-            BOOST_ASSERT(false); // too many arguments
-            // throw exception here?
-            return NULL;
-        }
-    }
-    virtual void destroy(void const * const p) const{
-        boost::serialization::access::destroy(
-            static_cast<T const *>(p)
-        );
-        //delete static_cast<T const * const>(p) ;
-    }
-};
-
-} // namespace serialization
-} // namespace boost
-
-///////////////////////////////////////////////////////////////////////////////
-// If no other implementation has been designated as default, 
-// use this one.  To use this implementation as the default, specify it
-// before any of the other headers.
-
-#ifndef BOOST_SERIALIZATION_DEFAULT_TYPE_INFO
-    #define BOOST_SERIALIZATION_DEFAULT_TYPE_INFO
-    namespace boost {
-    namespace serialization {
-    template<class T>
-    struct extended_type_info_impl {
-        typedef typename 
-            boost::serialization::extended_type_info_no_rtti< T > type;
-    };
-    } // namespace serialization
-    } // namespace boost
-#endif
-
-#ifdef BOOST_MSVC
-#  pragma warning(pop)
-#endif
-#include <boost/config/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
-
-#endif // BOOST_EXTENDED_TYPE_INFO_NO_RTTI_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/extended_type_info_typeid.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/extended_type_info_typeid.hpp
deleted file mode 100644
index 8ee591b3169..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/extended_type_info_typeid.hpp
+++ /dev/null
@@ -1,167 +0,0 @@
-#ifndef BOOST_SERIALIZATION_EXTENDED_TYPE_INFO_TYPEID_HPP
-#define BOOST_SERIALIZATION_EXTENDED_TYPE_INFO_TYPEID_HPP
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-// extended_type_info_typeid.hpp: implementation for version that depends
-// on runtime typing (rtti - typeid) but uses a user specified string
-// as the portable class identifier.
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <typeinfo>
-#include <cstdarg>
-#include <boost/assert.hpp>
-#include <boost/config.hpp>
-
-#include <boost/static_assert.hpp>
-#include <boost/serialization/static_warning.hpp>
-#include <boost/type_traits/is_polymorphic.hpp>
-#include <boost/type_traits/remove_const.hpp>
-
-#include <boost/serialization/config.hpp>
-#include <boost/serialization/singleton.hpp>
-#include <boost/serialization/extended_type_info.hpp>
-#include <boost/serialization/factory.hpp>
-
-// hijack serialization access
-#include <boost/serialization/access.hpp>
-
-#include <boost/mpl/if.hpp>
-
-#include <boost/config/abi_prefix.hpp> // must be the last header
-
-#ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable : 4251 4231 4660 4275 4511 4512)
-#endif
-
-namespace boost {
-namespace serialization {
-namespace typeid_system {
-
-class BOOST_SYMBOL_VISIBLE extended_type_info_typeid_0 :
-    public extended_type_info
-{
-    virtual const char * get_debug_info() const {
-        if(static_cast<const std::type_info *>(0) == m_ti)
-            return static_cast<const char *>(0);
-        return m_ti->name();
-    }
-protected:
-    const std::type_info * m_ti;
-    BOOST_SERIALIZATION_DECL extended_type_info_typeid_0(const char * key);
-    BOOST_SERIALIZATION_DECL ~extended_type_info_typeid_0();
-    BOOST_SERIALIZATION_DECL void type_register(const std::type_info & ti);
-    BOOST_SERIALIZATION_DECL void type_unregister();
-    BOOST_SERIALIZATION_DECL const extended_type_info *
-    get_extended_type_info(const std::type_info & ti) const;
-public:
-    virtual BOOST_SERIALIZATION_DECL bool
-    is_less_than(const extended_type_info &rhs) const;
-    virtual BOOST_SERIALIZATION_DECL bool
-    is_equal(const extended_type_info &rhs) const;
-    const std::type_info & get_typeid() const {
-        return *m_ti;
-    }
-};
-
-} // typeid_system
-
-template<class T>
-class extended_type_info_typeid : 
-    public typeid_system::extended_type_info_typeid_0,
-    public singleton<extended_type_info_typeid< T > >
-{
-public:
-    extended_type_info_typeid() :
-        typeid_system::extended_type_info_typeid_0(
-            boost::serialization::guid< T >()
-        )
-    {
-        type_register(typeid(T));
-        key_register();
-    }
-    ~extended_type_info_typeid(){
-        key_unregister();
-        type_unregister();
-    }
-    // get the eti record for the true type of this record
-    // relying upon standard type info implemenation (rtti)
-    const extended_type_info *
-    get_derived_extended_type_info(const T & t) const {
-        // note: this implementation - based on usage of typeid (rtti)
-        // only does something if the class has at least one virtual function.
-        BOOST_STATIC_WARNING(boost::is_polymorphic< T >::value);
-        return 
-            typeid_system::extended_type_info_typeid_0::get_extended_type_info(
-                typeid(t)
-            );
-    }
-    const char * get_key() const {
-        return boost::serialization::guid< T >();
-    }
-    virtual void * construct(unsigned int count, ...) const{
-        // count up the arguments
-        std::va_list ap;
-        va_start(ap, count);
-        switch(count){
-        case 0:
-            return factory<typename boost::remove_const< T >::type, 0>(ap);
-        case 1:
-            return factory<typename boost::remove_const< T >::type, 1>(ap);
-        case 2:
-            return factory<typename boost::remove_const< T >::type, 2>(ap);
-        case 3:
-            return factory<typename boost::remove_const< T >::type, 3>(ap);
-        case 4:
-            return factory<typename boost::remove_const< T >::type, 4>(ap);
-        default:
-            BOOST_ASSERT(false); // too many arguments
-            // throw exception here?
-            return NULL;
-        }
-    }
-    virtual void destroy(void const * const p) const {
-        boost::serialization::access::destroy(
-            static_cast<T const *>(p)
-        );
-        //delete static_cast<T const * const>(p);
-    }
-};
-
-} // namespace serialization
-} // namespace boost
-
-///////////////////////////////////////////////////////////////////////////////
-// If no other implementation has been designated as default, 
-// use this one.  To use this implementation as the default, specify it
-// before any of the other headers.
-#ifndef BOOST_SERIALIZATION_DEFAULT_TYPE_INFO
-    #define BOOST_SERIALIZATION_DEFAULT_TYPE_INFO
-    namespace boost {
-    namespace serialization {
-    template<class T>
-    struct extended_type_info_impl {
-        typedef typename 
-            boost::serialization::extended_type_info_typeid< T > type;
-    };
-    } // namespace serialization
-    } // namespace boost
-#endif
-
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
-#include <boost/config/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
-
-#endif // BOOST_SERIALIZATION_EXTENDED_TYPE_INFO_TYPEID_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/factory.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/factory.hpp
deleted file mode 100644
index 2db7e7e36c3..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/factory.hpp
+++ /dev/null
@@ -1,102 +0,0 @@
-#ifndef BOOST_SERIALIZATION_FACTORY_HPP
-#define BOOST_SERIALIZATION_FACTORY_HPP
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-// factory.hpp: create an instance from an extended_type_info instance.
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <cstdarg> // valist
-#include <cstddef> // NULL
-
-#include <boost/preprocessor/control/if.hpp> 
-#include <boost/preprocessor/comparison/greater.hpp>
-#include <boost/assert.hpp>
-
-namespace std{
-    #if defined(__LIBCOMO__)
-        using ::va_list;
-    #endif
-} // namespace std
-
-namespace boost {
-namespace serialization {
-
-// default implementation does nothing.
-template<class T, int N>
-T * factory(std::va_list){
-    BOOST_ASSERT(false);
-    // throw exception here?
-    return NULL;
-}
-
-} // namespace serialization
-} // namespace boost
-
-#define BOOST_SERIALIZATION_FACTORY(N, T, A0, A1, A2, A3) \
-namespace boost {                                         \
-namespace serialization {                                 \
-    template<>                                            \
-    T * factory<T, N>(std::va_list ap){                   \
-        BOOST_PP_IF(BOOST_PP_GREATER(N, 0)                \
-            , A0 a0 = va_arg(ap, A0);, BOOST_PP_EMPTY())  \
-        BOOST_PP_IF(BOOST_PP_GREATER(N, 1)                \
-            , A1 a1 = va_arg(ap, A1);, BOOST_PP_EMPTY())  \
-        BOOST_PP_IF(BOOST_PP_GREATER(N, 2)                \
-            , A2 a2 = va_arg(ap, A2);, BOOST_PP_EMPTY())  \
-        BOOST_PP_IF(BOOST_PP_GREATER(N, 3)                \
-            , A3 a3 = va_arg(ap, A3);, BOOST_PP_EMPTY())  \
-        return new T(                                     \
-            BOOST_PP_IF(BOOST_PP_GREATER(N, 0)            \
-                , a0, BOOST_PP_EMPTY())                   \
-            BOOST_PP_IF(BOOST_PP_GREATER(N, 1))           \
-                , BOOST_PP_COMMA, BOOST_PP_EMPTY)()       \
-            BOOST_PP_IF(BOOST_PP_GREATER(N, 1)            \
-                , a1, BOOST_PP_EMPTY())                   \
-            BOOST_PP_IF(BOOST_PP_GREATER(N, 2))           \
-                , BOOST_PP_COMMA, BOOST_PP_EMPTY)()       \
-            BOOST_PP_IF(BOOST_PP_GREATER(N, 2)            \
-                , a2, BOOST_PP_EMPTY())                   \
-            BOOST_PP_IF(BOOST_PP_GREATER(N, 3))           \
-                , BOOST_PP_COMMA, BOOST_PP_EMPTY)()       \
-            BOOST_PP_IF(BOOST_PP_GREATER(N, 3)            \
-                , a3, BOOST_PP_EMPTY())                   \
-        );                                                \
-    }                                                     \
-}                                                         \
-}   /**/
-
-#define BOOST_SERIALIZATION_FACTORY_4(T, A0, A1, A2, A3) \
-    BOOST_SERIALIZATION_FACTORY(4, T, A0, A1, A2, A3)
-
-#define BOOST_SERIALIZATION_FACTORY_3(T, A0, A1, A2)     \
-    BOOST_SERIALIZATION_FACTORY(3, T, A0, A1, A2, 0)
-
-#define BOOST_SERIALIZATION_FACTORY_2(T, A0, A1)         \
-    BOOST_SERIALIZATION_FACTORY(2, T, A0, A1, 0, 0)
-
-#define BOOST_SERIALIZATION_FACTORY_1(T, A0)             \
-    BOOST_SERIALIZATION_FACTORY(1, T, A0, 0, 0, 0)
-
-#define BOOST_SERIALIZATION_FACTORY_0(T)                 \
-namespace boost {                                        \
-namespace serialization {                                \
-    template<>                                           \
-    T * factory<T, 0>(std::va_list){                     \
-        return new T();                                  \
-    }                                                    \
-}                                                        \
-}                                                        \
-/**/
-
-#endif // BOOST_SERIALIZATION_FACTORY_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/force_include.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/force_include.hpp
deleted file mode 100644
index 55ab79d0d58..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/force_include.hpp
+++ /dev/null
@@ -1,55 +0,0 @@
-#ifndef BOOST_SERIALIZATION_FORCE_INCLUDE_HPP
-#define BOOST_SERIALIZATION_FORCE_INCLUDE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// force_include.hpp:
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/config.hpp>
-
-// the following help macro is to guarentee that certain coded
-// is not removed by over-eager linker optimiser.  In certain cases
-// we create static objects must be created but are actually never
-// referenced - creation has a side-effect such as global registration
-// which is important to us. We make an effort to refer these objects
-// so that a smart linker won't remove them as being unreferenced.
-// In microsoft compilers, inlining the code that does the referring
-// means the code gets lost and the static object is not included
-// in the library and hence never registered.  This manifests itself
-// in an ungraceful crash at runtime when (and only when) built in
-// release mode.
-
-#if defined(BOOST_HAS_DECLSPEC) && !defined(__COMO__)
-#   define BOOST_DLLEXPORT __declspec(dllexport)
-#elif ! defined(_WIN32) && ! defined(_WIN64)
-#   if defined(__MWERKS__)
-#       define BOOST_DLLEXPORT __declspec(dllexport)
-#   elif defined(__GNUC__) && (__GNUC__ >= 3)
-#       define BOOST_USED __attribute__ ((__used__))
-#   elif defined(__IBMCPP__) && (__IBMCPP__ >= 1110)
-#       define BOOST_USED __attribute__ ((__used__))
-#   elif defined(__INTEL_COMPILER) && (BOOST_INTEL_CXX_VERSION >= 800)
-#       define BOOST_USED __attribute__ ((__used__))
-#   endif
-#endif
-
-#ifndef BOOST_USED
-#    define BOOST_USED
-#endif
-
-#ifndef BOOST_DLLEXPORT
-#    define BOOST_DLLEXPORT
-#endif
-
-#endif // BOOST_SERIALIZATION_FORCE_INCLUDE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/forward_list.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/forward_list.hpp
deleted file mode 100644
index b8a3c20a6ea..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/forward_list.hpp
+++ /dev/null
@@ -1,124 +0,0 @@
-#ifndef BOOST_SERIALIZATION_FORWARD_LIST_HPP
-#define BOOST_SERIALIZATION_FORWARD_LIST_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// forward_list.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/config.hpp>
-
-#include <forward_list>
-#include <iterator>  // distance
-
-#include <boost/serialization/collections_save_imp.hpp>
-#include <boost/serialization/collections_load_imp.hpp>
-#include <boost/archive/detail/basic_iarchive.hpp>
-#include <boost/serialization/nvp.hpp>
-#include <boost/serialization/collection_size_type.hpp>
-#include <boost/serialization/item_version_type.hpp>
-#include <boost/serialization/split_free.hpp>
-#include <boost/serialization/detail/stack_constructor.hpp>
-#include <boost/serialization/detail/is_default_constructible.hpp>
-#include <boost/move/utility_core.hpp>
-
-namespace boost { 
-namespace serialization {
-
-template<class Archive, class U, class Allocator>
-inline void save(
-    Archive & ar,
-    const std::forward_list<U, Allocator> &t,
-    const unsigned int /*file_version*/
-){
-    const collection_size_type count(std::distance(t.cbegin(), t.cend()));
-    boost::serialization::stl::save_collection<
-        Archive,
-        std::forward_list<U, Allocator>
-    >(ar, t, count);
-}
-
-namespace stl {
-
-template<
-    class Archive,
-    class T,
-    class Allocator
->
-typename boost::disable_if<
-    typename detail::is_default_constructible<
-        typename std::forward_list<T, Allocator>::value_type
-    >,
-    void
->::type
-collection_load_impl(
-    Archive & ar,
-    std::forward_list<T, Allocator> &t,
-    collection_size_type count,
-    item_version_type item_version
-){
-    t.clear();
-    boost::serialization::detail::stack_construct<Archive, T> u(ar, item_version);
-    ar >> boost::serialization::make_nvp("item", u.reference());
-    t.push_front(boost::move(u.reference()));
-    typename std::forward_list<T, Allocator>::iterator last;
-    last = t.begin();
-    ar.reset_object_address(&(*t.begin()) , & u.reference());
-    while(--count > 0){
-        detail::stack_construct<Archive, T> u(ar, item_version);
-        ar >> boost::serialization::make_nvp("item", u.reference());
-        last = t.insert_after(last, boost::move(u.reference()));
-        ar.reset_object_address(&(*last) , & u.reference());
-    }
-}
-
-} // stl
-
-template<class Archive, class U, class Allocator>
-inline void load(
-    Archive & ar,
-    std::forward_list<U, Allocator> &t,
-    const unsigned int /*file_version*/
-){
-    const boost::archive::library_version_type library_version(
-        ar.get_library_version()
-    );
-    // retrieve number of elements
-    item_version_type item_version(0);
-    collection_size_type count;
-    ar >> BOOST_SERIALIZATION_NVP(count);
-    if(boost::archive::library_version_type(3) < library_version){
-        ar >> BOOST_SERIALIZATION_NVP(item_version);
-    }
-    stl::collection_load_impl(ar, t, count, item_version);
-}
-
-// split non-intrusive serialization function member into separate
-// non intrusive save/load member functions
-template<class Archive, class U, class Allocator>
-inline void serialize(
-    Archive & ar,
-    std::forward_list<U, Allocator> &t,
-    const unsigned int file_version
-){
-    boost::serialization::split_free(ar, t, file_version);
-}
-
-} // serialization
-} // namespace boost
-
-#include <boost/serialization/collection_traits.hpp>
-
-BOOST_SERIALIZATION_COLLECTION_TRAITS(std::forward_list)
-
-#endif  // BOOST_SERIALIZATION_FORWARD_LIST_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/hash_collections_load_imp.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/hash_collections_load_imp.hpp
deleted file mode 100644
index 88def8f1aa4..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/hash_collections_load_imp.hpp
+++ /dev/null
@@ -1,77 +0,0 @@
-#ifndef BOOST_SERIALIZATION_HASH_COLLECTIONS_LOAD_IMP_HPP
-#define BOOST_SERIALIZATION_HASH_COLLECTIONS_LOAD_IMP_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-# pragma warning (disable : 4786) // too long name, harmless warning
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// hash_collections_load_imp.hpp: serialization for loading stl collections
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-// helper function templates for serialization of hashed collections
-#include <boost/config.hpp>
-#include <boost/archive/detail/basic_iarchive.hpp>
-#include <boost/serialization/nvp.hpp>
-#include <boost/serialization/collection_size_type.hpp>
-#include <boost/serialization/item_version_type.hpp>
-
-namespace boost{
-namespace serialization {
-namespace stl {
-
-//////////////////////////////////////////////////////////////////////
-// implementation of serialization for STL containers
-//
-template<class Archive, class Container, class InputFunction>
-inline void load_hash_collection(Archive & ar, Container &s)
-{
-    collection_size_type count;
-    collection_size_type bucket_count;
-    boost::serialization::item_version_type item_version(0);
-    boost::archive::library_version_type library_version(
-        ar.get_library_version()
-    );
-    // retrieve number of elements
-    if(boost::archive::library_version_type(6) != library_version){
-        ar >> BOOST_SERIALIZATION_NVP(count);
-        ar >> BOOST_SERIALIZATION_NVP(bucket_count);
-    }
-    else{
-        // note: fixup for error in version 6.  collection size was
-        // changed to size_t BUT for hashed collections it was implemented
-        // as an unsigned int.  This should be a problem only on win64 machines
-        // but I'll leave it for everyone just in case.
-        unsigned int c;
-        unsigned int bc;
-        ar >> BOOST_SERIALIZATION_NVP(c);
-        count = c;
-        ar >> BOOST_SERIALIZATION_NVP(bc);
-        bucket_count = bc;
-    }
-    if(boost::archive::library_version_type(3) < library_version){
-        ar >> BOOST_SERIALIZATION_NVP(item_version);
-    }
-    s.clear();
-    #if ! defined(__MWERKS__)
-    s.resize(bucket_count);
-    #endif
-    InputFunction ifunc;
-    while(count-- > 0){
-        ifunc(ar, s, item_version);
-    }
-}
-
-} // namespace stl 
-} // namespace serialization
-} // namespace boost
-
-#endif //BOOST_SERIALIZATION_HASH_COLLECTIONS_LOAD_IMP_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/hash_collections_save_imp.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/hash_collections_save_imp.hpp
deleted file mode 100644
index 65dfe83f16e..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/hash_collections_save_imp.hpp
+++ /dev/null
@@ -1,97 +0,0 @@
-#ifndef BOOST_SERIALIZATION_HASH_COLLECTIONS_SAVE_IMP_HPP
-#define BOOST_SERIALIZATION_HASH_COLLECTIONS_SAVE_IMP_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// hash_collections_save_imp.hpp: serialization for stl collections
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-// helper function templates for serialization of collections
-
-#include <boost/config.hpp>
-#include <boost/serialization/nvp.hpp>
-#include <boost/serialization/serialization.hpp>
-#include <boost/serialization/version.hpp>
-#include <boost/serialization/collection_size_type.hpp>
-#include <boost/serialization/item_version_type.hpp>
-
-namespace boost{
-namespace serialization {
-namespace stl {
-
-//////////////////////////////////////////////////////////////////////
-// implementation of serialization for STL containers
-//
-
-template<class Archive, class Container>
-inline void save_hash_collection(Archive & ar, const Container &s)
-{
-    collection_size_type count(s.size());
-    const collection_size_type bucket_count(s.bucket_count());
-    const item_version_type item_version(
-        version<typename Container::value_type>::value
-    );
-
-    #if 0
-    /* should only be necessary to create archives of previous versions
-     * which is not currently supported.  So for now comment this out
-     */
-    boost::archive::library_version_type library_version(
-        ar.get_library_version()
-    );
-    // retrieve number of elements
-    if(boost::archive::library_version_type(6) != library_version){
-        ar << BOOST_SERIALIZATION_NVP(count);
-        ar << BOOST_SERIALIZATION_NVP(bucket_count);
-    }
-    else{
-        // note: fixup for error in version 6.  collection size was
-        // changed to size_t BUT for hashed collections it was implemented
-        // as an unsigned int.  This should be a problem only on win64 machines
-        // but I'll leave it for everyone just in case.
-        const unsigned int c = count;
-        const unsigned int bc = bucket_count;
-        ar << BOOST_SERIALIZATION_NVP(c);
-        ar << BOOST_SERIALIZATION_NVP(bc);
-    }
-    if(boost::archive::library_version_type(3) < library_version){
-        // record number of elements
-        // make sure the target type is registered so we can retrieve
-        // the version when we load
-        ar << BOOST_SERIALIZATION_NVP(item_version);
-    }
-    #else
-        ar << BOOST_SERIALIZATION_NVP(count);
-        ar << BOOST_SERIALIZATION_NVP(bucket_count);
-        ar << BOOST_SERIALIZATION_NVP(item_version);
-    #endif
-
-    typename Container::const_iterator it = s.begin();
-    while(count-- > 0){
-        // note borland emits a no-op without the explicit namespace
-        boost::serialization::save_construct_data_adl(
-            ar, 
-            &(*it), 
-            boost::serialization::version<
-                typename Container::value_type
-            >::value
-        );
-        ar << boost::serialization::make_nvp("item", *it++);
-    }
-}
-
-} // namespace stl 
-} // namespace serialization
-} // namespace boost
-
-#endif //BOOST_SERIALIZATION_HASH_COLLECTIONS_SAVE_IMP_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/hash_map.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/hash_map.hpp
deleted file mode 100644
index 22626db6838..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/hash_map.hpp
+++ /dev/null
@@ -1,232 +0,0 @@
-#ifndef  BOOST_SERIALIZATION_HASH_MAP_HPP
-#define BOOST_SERIALIZATION_HASH_MAP_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// serialization/hash_map.hpp:
-// serialization for stl hash_map templates
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/config.hpp>
-#ifdef BOOST_HAS_HASH
-#include BOOST_HASH_MAP_HEADER
-
-#include <boost/serialization/utility.hpp>
-#include <boost/serialization/hash_collections_save_imp.hpp>
-#include <boost/serialization/hash_collections_load_imp.hpp>
-#include <boost/serialization/split_free.hpp>
-#include <boost/move/utility_core.hpp>
-
-namespace boost { 
-namespace serialization {
-
-namespace stl {
-
-// map input
-template<class Archive, class Container>
-struct archive_input_hash_map
-{
-    inline void operator()(
-        Archive &ar, 
-        Container &s, 
-        const unsigned int v
-    ){
-        typedef typename Container::value_type type;
-        detail::stack_construct<Archive, type> t(ar, v);
-        // borland fails silently w/o full namespace
-        ar >> boost::serialization::make_nvp("item", t.reference());
-        std::pair<typename Container::const_iterator, bool> result = 
-            s.insert(boost::move(t.reference()));
-        // note: the following presumes that the map::value_type was NOT tracked
-        // in the archive.  This is the usual case, but here there is no way
-        // to determine that.  
-        if(result.second){
-            ar.reset_object_address(
-                & (result.first->second),
-                & t.reference().second
-            );
-        }
-    }
-};
-
-// multimap input
-template<class Archive, class Container>
-struct archive_input_hash_multimap
-{
-    inline void operator()(
-        Archive &ar, 
-        Container &s, 
-        const unsigned int v
-    ){
-        typedef typename Container::value_type type;
-        detail::stack_construct<Archive, type> t(ar, v);
-        // borland fails silently w/o full namespace
-        ar >> boost::serialization::make_nvp("item", t.reference());
-        typename Container::const_iterator result 
-            = s.insert(boost::move(t.reference()));
-        // note: the following presumes that the map::value_type was NOT tracked
-        // in the archive.  This is the usual case, but here there is no way
-        // to determine that.  
-        ar.reset_object_address(
-            & result->second,
-            & t.reference()
-        );
-    }
-};
-
-} // stl
-
-template<
-    class Archive, 
-    class Key, 
-    class HashFcn, 
-    class EqualKey,
-    class Allocator
->
-inline void save(
-    Archive & ar,
-    const BOOST_STD_EXTENSION_NAMESPACE::hash_map<
-        Key, HashFcn, EqualKey, Allocator
-    > &t,
-    const unsigned int file_version
-){
-    boost::serialization::stl::save_hash_collection<
-        Archive, 
-        BOOST_STD_EXTENSION_NAMESPACE::hash_map<
-            Key, HashFcn, EqualKey, Allocator
-        >
-    >(ar, t);
-}
-
-template<
-    class Archive, 
-    class Key, 
-    class HashFcn, 
-    class EqualKey,
-    class Allocator
->
-inline void load(
-    Archive & ar,
-    BOOST_STD_EXTENSION_NAMESPACE::hash_map<
-        Key, HashFcn, EqualKey, Allocator
-    > &t,
-    const unsigned int file_version
-){
-    boost::serialization::stl::load_hash_collection<
-        Archive,
-        BOOST_STD_EXTENSION_NAMESPACE::hash_map<
-            Key, HashFcn, EqualKey, Allocator
-        >,
-        boost::serialization::stl::archive_input_hash_map<
-            Archive, 
-            BOOST_STD_EXTENSION_NAMESPACE::hash_map<
-                Key, HashFcn, EqualKey, Allocator
-            >
-        >
-    >(ar, t);
-}
-
-// split non-intrusive serialization function member into separate
-// non intrusive save/load member functions
-template<
-    class Archive, 
-    class Key, 
-    class HashFcn, 
-    class EqualKey,
-    class Allocator
->
-inline void serialize(
-    Archive & ar,
-    BOOST_STD_EXTENSION_NAMESPACE::hash_map<
-        Key, HashFcn, EqualKey, Allocator
-    > &t,
-    const unsigned int file_version
-){
-    boost::serialization::split_free(ar, t, file_version);
-}
-
-// hash_multimap
-template<
-    class Archive, 
-    class Key, 
-    class HashFcn, 
-    class EqualKey,
-    class Allocator
->
-inline void save(
-    Archive & ar,
-    const BOOST_STD_EXTENSION_NAMESPACE::hash_multimap<
-        Key, HashFcn, EqualKey, Allocator
-    > &t,
-    const unsigned int file_version
-){
-    boost::serialization::stl::save_hash_collection<
-        Archive, 
-        BOOST_STD_EXTENSION_NAMESPACE::hash_multimap<
-            Key, HashFcn, EqualKey, Allocator
-        >
-    >(ar, t);
-}
-
-template<
-    class Archive, 
-    class Key, 
-    class HashFcn, 
-    class EqualKey,
-    class Allocator
->
-inline void load(
-    Archive & ar,
-    BOOST_STD_EXTENSION_NAMESPACE::hash_multimap<
-        Key, HashFcn, EqualKey, Allocator
-    > &t,
-    const unsigned int file_version
-){
-    boost::serialization::stl::load_hash_collection<
-        Archive,
-        BOOST_STD_EXTENSION_NAMESPACE::hash_multimap<
-            Key, HashFcn, EqualKey, Allocator
-        >,
-        boost::serialization::stl::archive_input_hash_multimap<
-            Archive, 
-            BOOST_STD_EXTENSION_NAMESPACE::hash_multimap<
-                Key, HashFcn, EqualKey, Allocator
-            >
-        >
-    >(ar, t);
-}
-
-// split non-intrusive serialization function member into separate
-// non intrusive save/load member functions
-template<
-    class Archive, 
-    class Key, 
-    class HashFcn, 
-    class EqualKey,
-    class Allocator
->
-inline void serialize(
-    Archive & ar,
-    BOOST_STD_EXTENSION_NAMESPACE::hash_multimap<
-        Key, HashFcn, EqualKey, Allocator
-    > &t,
-    const unsigned int file_version
-){
-    boost::serialization::split_free(ar, t, file_version);
-}
-
-} // namespace serialization
-} // namespace boost
-
-#endif // BOOST_HAS_HASH
-#endif // BOOST_SERIALIZATION_HASH_MAP_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/hash_set.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/hash_set.hpp
deleted file mode 100644
index 0c72c18457e..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/hash_set.hpp
+++ /dev/null
@@ -1,222 +0,0 @@
-#ifndef  BOOST_SERIALIZATION_HASH_SET_HPP
-#define BOOST_SERIALIZATION_HASH_SET_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// hash_set.hpp: serialization for stl hash_set templates
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/config.hpp>
-#ifdef BOOST_HAS_HASH
-#include BOOST_HASH_SET_HEADER
-
-#include <boost/serialization/hash_collections_save_imp.hpp>
-#include <boost/serialization/hash_collections_load_imp.hpp>
-#include <boost/serialization/split_free.hpp>
-#include <boost/move/utility_core.hpp>
-
-namespace boost { 
-namespace serialization {
-
-namespace stl {
-
-// hash_set input
-template<class Archive, class Container>
-struct archive_input_hash_set
-{
-    inline void operator()(
-        Archive &ar, 
-        Container &s, 
-        const unsigned int v
-    ){
-        typedef typename Container::value_type type;
-        detail::stack_construct<Archive, type> t(ar, v);
-        // borland fails silently w/o full namespace
-        ar >> boost::serialization::make_nvp("item", t.reference());
-        std::pair<typename Container::const_iterator, bool> result = 
-            s.insert(boost::move(t.reference()));
-        if(result.second)
-            ar.reset_object_address(& (* result.first), & t.reference());
-    }
-};
-
-// hash_multiset input
-template<class Archive, class Container>
-struct archive_input_hash_multiset
-{
-    inline void operator()(
-        Archive &ar, 
-        Container &s, 
-        const unsigned int v
-    ){
-        typedef typename Container::value_type type;
-        detail::stack_construct<Archive, type> t(ar, v);
-        // borland fails silently w/o full namespace
-        ar >> boost::serialization::make_nvp("item", t.reference());
-        typename Container::const_iterator result 
-            = s.insert(boost::move(t.reference()));
-        ar.reset_object_address(& (* result), & t.reference());
-    }
-};
-
-} // stl
-
-template<
-    class Archive, 
-    class Key, 
-    class HashFcn, 
-    class EqualKey,
-    class Allocator
->
-inline void save(
-    Archive & ar,
-    const BOOST_STD_EXTENSION_NAMESPACE::hash_set<
-        Key, HashFcn, EqualKey, Allocator
-    > &t,
-    const unsigned int file_version
-){
-    boost::serialization::stl::save_hash_collection<
-        Archive, 
-        BOOST_STD_EXTENSION_NAMESPACE::hash_set<
-            Key, HashFcn, EqualKey, Allocator
-        > 
-    >(ar, t);
-}
-
-template<
-    class Archive, 
-    class Key, 
-    class HashFcn, 
-    class EqualKey,
-    class Allocator
->
-inline void load(
-    Archive & ar,
-    BOOST_STD_EXTENSION_NAMESPACE::hash_set<
-        Key, HashFcn, EqualKey, Allocator
-    > &t,
-    const unsigned int file_version
-){
-    boost::serialization::stl::load_hash_collection<
-        Archive,
-        BOOST_STD_EXTENSION_NAMESPACE::hash_set<
-            Key, HashFcn, EqualKey, Allocator
-        >,
-        boost::serialization::stl::archive_input_hash_set<
-            Archive, 
-            BOOST_STD_EXTENSION_NAMESPACE::hash_set<
-                Key, HashFcn, EqualKey, Allocator
-            >
-        >
-    >(ar, t);
-}
-
-// split non-intrusive serialization function member into separate
-// non intrusive save/load member functions
-template<
-    class Archive, 
-    class Key, 
-    class HashFcn, 
-    class EqualKey,
-    class Allocator
->
-inline void serialize(
-    Archive & ar,
-    BOOST_STD_EXTENSION_NAMESPACE::hash_set<
-        Key, HashFcn, EqualKey, Allocator
-    > &t,
-    const unsigned int file_version
-){
-    boost::serialization::split_free(ar, t, file_version);
-}
-
-// hash_multiset
-template<
-    class Archive, 
-    class Key, 
-    class HashFcn, 
-    class EqualKey,
-    class Allocator
->
-inline void save(
-    Archive & ar,
-    const BOOST_STD_EXTENSION_NAMESPACE::hash_multiset<
-        Key, HashFcn, EqualKey, Allocator
-    > &t,
-    const unsigned int file_version
-){
-    boost::serialization::stl::save_hash_collection<
-        Archive, 
-        BOOST_STD_EXTENSION_NAMESPACE::hash_multiset<
-            Key, HashFcn, EqualKey, Allocator
-        > 
-    >(ar, t);
-}
-
-template<
-    class Archive, 
-    class Key, 
-    class HashFcn, 
-    class EqualKey,
-    class Allocator
->
-inline void load(
-    Archive & ar,
-    BOOST_STD_EXTENSION_NAMESPACE::hash_multiset<
-        Key, HashFcn, EqualKey, Allocator
-    > &t,
-    const unsigned int file_version
-){
-    boost::serialization::stl::load_hash_collection<
-        Archive,
-        BOOST_STD_EXTENSION_NAMESPACE::hash_multiset<
-            Key, HashFcn, EqualKey, Allocator
-        >,
-        boost::serialization::stl::archive_input_hash_multiset<
-            Archive,
-            BOOST_STD_EXTENSION_NAMESPACE::hash_multiset<
-                Key, HashFcn, EqualKey, Allocator
-            > 
-        >
-    >(ar, t);
-}
-
-// split non-intrusive serialization function member into separate
-// non intrusive save/load member functions
-template<
-    class Archive, 
-    class Key, 
-    class HashFcn, 
-    class EqualKey,
-    class Allocator
->
-inline void serialize(
-    Archive & ar,
-    BOOST_STD_EXTENSION_NAMESPACE::hash_multiset<
-        Key, HashFcn, EqualKey, Allocator
-    > & t,
-    const unsigned int file_version
-){
-    boost::serialization::split_free(ar, t, file_version);
-}
-
-} // namespace serialization
-} // namespace boost
-
-#include <boost/serialization/collection_traits.hpp>
-
-BOOST_SERIALIZATION_COLLECTION_TRAITS(BOOST_STD_EXTENSION_NAMESPACE::hash_set)
-BOOST_SERIALIZATION_COLLECTION_TRAITS(BOOST_STD_EXTENSION_NAMESPACE::hash_multiset)
-
-#endif // BOOST_HAS_HASH
-#endif // BOOST_SERIALIZATION_HASH_SET_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/is_bitwise_serializable.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/is_bitwise_serializable.hpp
deleted file mode 100644
index 7e24a2cb6d8..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/is_bitwise_serializable.hpp
+++ /dev/null
@@ -1,46 +0,0 @@
-// (C) Copyright 2007 Matthias Troyer
-
-// Use, modification and distribution is subject to the 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: Matthias Troyer
-
-/** @file is_bitwise_serializable.hpp
- *
- *  This header provides a traits class for determining whether a class
- * can be serialized (in a non-portable way) just by copying the bits.
- */
-
-
-#ifndef BOOST_SERIALIZATION_IS_BITWISE_SERIALIZABLE_HPP
-#define BOOST_SERIALIZATION_IS_BITWISE_SERIALIZABLE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-#include <boost/mpl/bool_fwd.hpp>
-#include <boost/type_traits/is_arithmetic.hpp>
-
-namespace boost {
-namespace serialization {
-    template<class T>
-    struct is_bitwise_serializable
-     : public is_arithmetic< T >
-    {};
-} // namespace serialization
-} // namespace boost
-
-
-// define a macro to make explicit designation of this more transparent
-#define BOOST_IS_BITWISE_SERIALIZABLE(T)              \
-namespace boost {                                     \
-namespace serialization {                             \
-template<>                                            \
-struct is_bitwise_serializable< T > : mpl::true_ {};  \
-}}                                                    \
-/**/
-
-#endif //BOOST_SERIALIZATION_IS_BITWISE_SERIALIZABLE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/item_version_type.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/item_version_type.hpp
deleted file mode 100644
index f3e5adac6f8..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/item_version_type.hpp
+++ /dev/null
@@ -1,68 +0,0 @@
-#ifndef BOOST_SERIALIZATION_ITEM_VERSION_TYPE_HPP
-#define BOOST_SERIALIZATION_ITEM_VERSION_TYPE_HPP
-
-// (C) Copyright 2010 Robert Ramey
-// Use, modification and distribution is subject to the 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/cstdint.hpp> // uint_least8_t
-#include <boost/integer_traits.hpp>
-#include <boost/serialization/level.hpp>
-#include <boost/serialization/is_bitwise_serializable.hpp>
-
-// fixes broken example build on x86_64-linux-gnu-gcc-4.6.0
-#include <boost/assert.hpp>
-
-namespace boost { 
-namespace serialization {
-
-#if defined(_MSC_VER)
-#pragma warning( push )
-#pragma warning( disable : 4244 4267 )
-#endif
-
-class item_version_type {
-private:
-    typedef unsigned int base_type;
-    base_type t;
-public:
-    // should be private - but MPI fails if it's not!!!
-    item_version_type(): t(0) {};
-    explicit item_version_type(const unsigned int t_) : t(t_){
-        BOOST_ASSERT(t_ <= boost::integer_traits<base_type>::const_max);
-    }
-    item_version_type(const item_version_type & t_) : 
-        t(t_.t)
-    {}
-    item_version_type & operator=(item_version_type rhs){
-        t = rhs.t; 
-        return *this;
-    }
-    // used for text output
-    operator base_type () const {
-        return t;
-    }                
-    // used for text input
-    operator base_type & () {
-        return t;
-    }
-    bool operator==(const item_version_type & rhs) const {
-        return t == rhs.t;
-    } 
-    bool operator<(const item_version_type & rhs) const {
-        return t < rhs.t;
-    }
-};
-
-#if defined(_MSC_VER)
-#pragma warning( pop )
-#endif
-
-} } // end namespace boost::serialization
-
-BOOST_IS_BITWISE_SERIALIZABLE(item_version_type)
-
-BOOST_CLASS_IMPLEMENTATION(item_version_type, primitive_type)
-
-#endif //BOOST_SERIALIZATION_ITEM_VERSION_TYPE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/level.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/level.hpp
deleted file mode 100644
index f6a84d10422..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/level.hpp
+++ /dev/null
@@ -1,116 +0,0 @@
-#ifndef BOOST_SERIALIZATION_LEVEL_HPP
-#define BOOST_SERIALIZATION_LEVEL_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// level.hpp:
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/config.hpp>
-#include <boost/detail/workaround.hpp>
-
-#include <boost/type_traits/is_fundamental.hpp>
-#include <boost/type_traits/is_enum.hpp>
-#include <boost/type_traits/is_array.hpp>
-#include <boost/type_traits/is_class.hpp>
-#include <boost/type_traits/is_base_and_derived.hpp>
-
-#include <boost/mpl/eval_if.hpp>
-#include <boost/mpl/int.hpp>
-#include <boost/mpl/integral_c.hpp>
-#include <boost/mpl/integral_c_tag.hpp>
-
-#include <boost/serialization/level_enum.hpp>
-
-namespace boost {
-namespace serialization {
-
-struct basic_traits;
-
-// default serialization implementation level
-template<class T>
-struct implementation_level_impl {
-    template<class U>
-    struct traits_class_level {
-        typedef typename U::level type;
-    };
-
-    typedef mpl::integral_c_tag tag;
-    // note: at least one compiler complained w/o the full qualification
-    // on basic traits below
-    typedef
-        typename mpl::eval_if<
-            is_base_and_derived<boost::serialization::basic_traits, T>,
-            traits_class_level< T >,
-        //else
-        typename mpl::eval_if<
-            is_fundamental< T >,
-            mpl::int_<primitive_type>,
-        //else
-        typename mpl::eval_if<
-            is_class< T >,
-            mpl::int_<object_class_info>,
-        //else
-        typename mpl::eval_if<
-            is_array< T >,
-                mpl::int_<object_serializable>,
-        //else
-        typename mpl::eval_if<
-            is_enum< T >,
-                mpl::int_<primitive_type>,
-        //else
-            mpl::int_<not_serializable>
-        >
-        >
-        >
-        >
-        >::type type;
-        // vc 7.1 doesn't like enums here
-    BOOST_STATIC_CONSTANT(int, value = type::value);
-};
-
-template<class T>
-struct implementation_level : 
-    public implementation_level_impl<const T>
-{
-};
-
-template<class T, int L>
-inline bool operator>=(implementation_level< T > t, enum level_type l)
-{
-    return t.value >= (int)l;
-}
-
-} // namespace serialization
-} // namespace boost
-
-// specify the level of serialization implementation for the class
-// require that class info saved when versioning is used
-#define BOOST_CLASS_IMPLEMENTATION(T, E)                 \
-    namespace boost {                                    \
-    namespace serialization {                            \
-    template <>                                          \
-    struct implementation_level_impl< const T >                     \
-    {                                                    \
-        typedef mpl::integral_c_tag tag;                 \
-        typedef mpl::int_< E > type;                     \
-        BOOST_STATIC_CONSTANT(                           \
-            int,                                         \
-            value = implementation_level_impl::type::value    \
-        );                                               \
-    };                                                   \
-    }                                                    \
-    }
-    /**/
-
-#endif // BOOST_SERIALIZATION_LEVEL_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/level_enum.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/level_enum.hpp
deleted file mode 100644
index baf64e04f31..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/level_enum.hpp
+++ /dev/null
@@ -1,55 +0,0 @@
-#ifndef BOOST_SERIALIZATION_LEVEL_ENUM_HPP
-#define BOOST_SERIALIZATION_LEVEL_ENUM_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// level_enum.hpp:
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-namespace boost {
-namespace serialization {
-
-// for each class used in the program, specify which level
-// of serialization should be implemented
-
-// names for each level
-enum level_type
-{
-    // Don't serialize this type. An attempt to do so should
-    // invoke a compile time assertion.
-    not_serializable = 0,
-    // write/read this type directly to the archive. In this case
-    // serialization code won't be called.  This is the default
-    // case for fundamental types.  It presumes a member function or
-    // template in the archive class that can handle this type.
-    // there is no runtime overhead associated reading/writing
-    // instances of this level
-    primitive_type = 1,
-    // Serialize the objects of this type using the objects "serialize"
-    // function or template. This permits values to be written/read
-    // to/from archives but includes no class or version information. 
-    object_serializable = 2,
-    ///////////////////////////////////////////////////////////////////
-    // once an object is serialized at one of the above levels, the
-    // corresponding archives cannot be read if the implementation level
-    // for the archive object is changed.  
-    ///////////////////////////////////////////////////////////////////
-    // Add class information to the archive.  Class information includes
-    // implementation level, class version and class name if available
-    object_class_info = 3
-};
-
-} // namespace serialization
-} // namespace boost
-
-#endif // BOOST_SERIALIZATION_LEVEL_ENUM_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/list.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/list.hpp
deleted file mode 100644
index 5fdc114d7ed..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/list.hpp
+++ /dev/null
@@ -1,85 +0,0 @@
-#ifndef BOOST_SERIALIZATION_LIST_HPP
-#define BOOST_SERIALIZATION_LIST_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// list.hpp: serialization for stl list templates
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <list>
-
-#include <boost/config.hpp>
-
-#include <boost/serialization/collections_save_imp.hpp>
-#include <boost/serialization/collections_load_imp.hpp>
-
-#include <boost/archive/detail/basic_iarchive.hpp>
-#include <boost/serialization/access.hpp>
-#include <boost/serialization/nvp.hpp>
-#include <boost/serialization/collection_size_type.hpp>
-#include <boost/serialization/item_version_type.hpp>
-#include <boost/serialization/split_free.hpp>
-
-namespace boost { 
-namespace serialization {
-
-template<class Archive, class U, class Allocator>
-inline void save(
-    Archive & ar,
-    const std::list<U, Allocator> &t,
-    const unsigned int /* file_version */
-){
-    boost::serialization::stl::save_collection<
-        Archive, 
-        std::list<U, Allocator> 
-    >(ar, t);
-}
-
-template<class Archive, class U, class Allocator>
-inline void load(
-    Archive & ar,
-    std::list<U, Allocator> &t,
-    const unsigned int /* file_version */
-){
-    const boost::archive::library_version_type library_version(
-        ar.get_library_version()
-    );
-    // retrieve number of elements
-    item_version_type item_version(0);
-    collection_size_type count;
-    ar >> BOOST_SERIALIZATION_NVP(count);
-    if(boost::archive::library_version_type(3) < library_version){
-        ar >> BOOST_SERIALIZATION_NVP(item_version);
-    }
-    stl::collection_load_impl(ar, t, count, item_version);
-}
-
-// split non-intrusive serialization function member into separate
-// non intrusive save/load member functions
-template<class Archive, class U, class Allocator>
-inline void serialize(
-    Archive & ar,
-    std::list<U, Allocator> & t,
-    const unsigned int file_version
-){
-    boost::serialization::split_free(ar, t, file_version);
-}
-
-} // serialization
-} // namespace boost
-
-#include <boost/serialization/collection_traits.hpp>
-
-BOOST_SERIALIZATION_COLLECTION_TRAITS(std::list)
-
-#endif // BOOST_SERIALIZATION_LIST_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/map.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/map.hpp
deleted file mode 100644
index 9209864c8cf..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/map.hpp
+++ /dev/null
@@ -1,139 +0,0 @@
-#ifndef  BOOST_SERIALIZATION_MAP_HPP
-#define BOOST_SERIALIZATION_MAP_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// serialization/map.hpp:
-// serialization for stl map templates
-
-// (C) Copyright 2002-2014 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <map>
-
-#include <boost/config.hpp>
-
-#include <boost/archive/detail/basic_iarchive.hpp>
-#include <boost/serialization/access.hpp>
-#include <boost/serialization/nvp.hpp>
-#include <boost/serialization/collection_size_type.hpp>
-#include <boost/serialization/item_version_type.hpp>
-#include <boost/serialization/detail/stack_constructor.hpp>
-
-#include <boost/serialization/utility.hpp>
-#include <boost/serialization/collections_save_imp.hpp>
-#include <boost/serialization/split_free.hpp>
-#include <boost/move/utility_core.hpp>
-
-namespace boost { 
-namespace serialization {
-
-////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// implementation of serialization for map and mult-map STL containers
-
-template<class Archive, class Container>
-inline void load_map_collection(Archive & ar, Container &s)
-{
-    s.clear();
-    const boost::archive::library_version_type library_version(
-        ar.get_library_version()
-    );
-    // retrieve number of elements
-    item_version_type item_version(0);
-    collection_size_type count;
-    ar >> BOOST_SERIALIZATION_NVP(count);
-    if(boost::archive::library_version_type(3) < library_version){
-        ar >> BOOST_SERIALIZATION_NVP(item_version);
-    }
-    typename Container::iterator hint;
-    hint = s.begin();
-    while(count-- > 0){
-        typedef typename Container::value_type type;
-        detail::stack_construct<Archive, type> t(ar, item_version);
-        ar >> boost::serialization::make_nvp("item", t.reference());
-        typename Container::iterator result =
-            s.insert(hint, boost::move(t.reference()));
-        ar.reset_object_address(& (result->second), & t.reference().second);
-        hint = result;
-        ++hint;
-    }
-}
-
-// map
-template<class Archive, class Type, class Key, class Compare, class Allocator >
-inline void save(
-    Archive & ar,
-    const std::map<Key, Type, Compare, Allocator> &t,
-    const unsigned int /* file_version */
-){
-    boost::serialization::stl::save_collection<
-        Archive, 
-        std::map<Key, Type, Compare, Allocator> 
-    >(ar, t);
-}
-
-template<class Archive, class Type, class Key, class Compare, class Allocator >
-inline void load(
-    Archive & ar,
-    std::map<Key, Type, Compare, Allocator> &t,
-    const unsigned int /* file_version */
-){
-    load_map_collection(ar, t);
-}
-
-// split non-intrusive serialization function member into separate
-// non intrusive save/load member functions
-template<class Archive, class Type, class Key, class Compare, class Allocator >
-inline void serialize(
-    Archive & ar,
-    std::map<Key, Type, Compare, Allocator> &t,
-    const unsigned int file_version
-){
-    boost::serialization::split_free(ar, t, file_version);
-}
-
-// multimap
-template<class Archive, class Type, class Key, class Compare, class Allocator >
-inline void save(
-    Archive & ar,
-    const std::multimap<Key, Type, Compare, Allocator> &t,
-    const unsigned int /* file_version */
-){
-    boost::serialization::stl::save_collection<
-        Archive, 
-        std::multimap<Key, Type, Compare, Allocator> 
-    >(ar, t);
-}
-
-template<class Archive, class Type, class Key, class Compare, class Allocator >
-inline void load(
-    Archive & ar,
-    std::multimap<Key, Type, Compare, Allocator> &t,
-    const unsigned int /* file_version */
-){
-    load_map_collection(ar, t);
-}
-
-// split non-intrusive serialization function member into separate
-// non intrusive save/load member functions
-template<class Archive, class Type, class Key, class Compare, class Allocator >
-inline void serialize(
-    Archive & ar,
-    std::multimap<Key, Type, Compare, Allocator> &t,
-    const unsigned int file_version
-){
-    boost::serialization::split_free(ar, t, file_version);
-}
-
-} // serialization
-} // namespace boost
-
-#endif // BOOST_SERIALIZATION_MAP_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/nvp.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/nvp.hpp
deleted file mode 100644
index 4e2297b3cc9..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/nvp.hpp
+++ /dev/null
@@ -1,123 +0,0 @@
-#ifndef BOOST_SERIALIZATION_NVP_HPP
-#define BOOST_SERIALIZATION_NVP_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// nvp.hpp: interface for serialization system.
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <utility>
-
-#include <boost/config.hpp>
-#include <boost/detail/workaround.hpp>
-
-#include <boost/serialization/level.hpp>
-#include <boost/serialization/tracking.hpp>
-#include <boost/serialization/split_member.hpp>
-#include <boost/serialization/base_object.hpp>
-#include <boost/serialization/traits.hpp>
-#include <boost/serialization/wrapper.hpp>
-
-namespace boost {
-namespace serialization {
-
-template<class T>
-struct nvp : 
-    public std::pair<const char *, T *>,
-    public wrapper_traits<const nvp< T > >
-{
-//private:
-    nvp(const nvp & rhs) :
-        std::pair<const char *, T *>(rhs.first, rhs.second)
-    {}
-public:
-    explicit nvp(const char * name_, T & t) :
-        // note: added _ to suppress useless gcc warning
-        std::pair<const char *, T *>(name_, & t)
-    {}
-
-    const char * name() const {
-        return this->first;
-    }
-    T & value() const {
-        return *(this->second);
-    }
-
-    const T & const_value() const {
-        return *(this->second);
-    }
-
-    template<class Archive>
-    void save(
-        Archive & ar,
-        const unsigned int /* file_version */
-    ) const {
-        ar.operator<<(const_value());
-    }
-    template<class Archive>
-    void load(
-        Archive & ar,
-        const unsigned int /* file_version */
-    ){
-        ar.operator>>(value());
-    }
-    BOOST_SERIALIZATION_SPLIT_MEMBER()
-};
-
-template<class T>
-inline
-const nvp< T > make_nvp(const char * name, T & t){
-    return nvp< T >(name, t);
-}
-
-// to maintain efficiency and portability, we want to assign
-// specific serialization traits to all instances of this wrappers.
-// we can't strait forward method below as it depends upon
-// Partial Template Specialization and doing so would mean that wrappers
-// wouldn't be treated the same on different platforms.  This would
-// break archive portability. Leave this here as reminder not to use it !!!
-
-template <class T>
-struct implementation_level<nvp< T > >
-{
-    typedef mpl::integral_c_tag tag;
-    typedef mpl::int_<object_serializable> type;
-    BOOST_STATIC_CONSTANT(int, value = implementation_level::type::value);
-};
-
-// nvp objects are generally created on the stack and are never tracked
-template<class T>
-struct tracking_level<nvp< T > >
-{
-    typedef mpl::integral_c_tag tag;
-    typedef mpl::int_<track_never> type;
-    BOOST_STATIC_CONSTANT(int, value = tracking_level::type::value);
-};
-
-} // seralization
-} // boost
-
-#include <boost/preprocessor/stringize.hpp>
-
-#define BOOST_SERIALIZATION_NVP(name)                              \
-    boost::serialization::make_nvp(BOOST_PP_STRINGIZE(name), name)
-/**/
-
-#define BOOST_SERIALIZATION_BASE_OBJECT_NVP(name)                  \
-    boost::serialization::make_nvp(                                \
-        BOOST_PP_STRINGIZE(name),                                  \
-        boost::serialization::base_object<name >(*this)            \
-    )
-/**/
-
-#endif // BOOST_SERIALIZATION_NVP_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/optional.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/optional.hpp
deleted file mode 100644
index d6ff830a8c3..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/optional.hpp
+++ /dev/null
@@ -1,107 +0,0 @@
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-
-// (C) Copyright 2002-4 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)
-
-// Provides non-intrusive serialization for boost::optional.
-
-#ifndef BOOST_SERIALIZATION_OPTIONAL_HPP_
-#define BOOST_SERIALIZATION_OPTIONAL_HPP_
-
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-#include <boost/config.hpp>
-
-#include <boost/archive/detail/basic_iarchive.hpp>
-
-#include <boost/optional.hpp>
-#include <boost/move/utility_core.hpp>
-
-#include <boost/serialization/item_version_type.hpp>
-#include <boost/serialization/split_free.hpp>
-#include <boost/serialization/level.hpp>
-#include <boost/serialization/nvp.hpp>
-#include <boost/serialization/version.hpp>
-#include <boost/type_traits/is_pointer.hpp>
-#include <boost/serialization/detail/stack_constructor.hpp>
-#include <boost/serialization/detail/is_default_constructible.hpp>
-#include <boost/serialization/force_include.hpp>
-
-// function specializations must be defined in the appropriate
-// namespace - boost::serialization
-namespace boost { 
-namespace serialization {
-
-template<class Archive, class T>
-void save(
-    Archive & ar, 
-    const boost::optional< T > & t, 
-    const unsigned int /*version*/
-){
-    // It is an inherent limitation to the serialization of optional.hpp
-    // that the underlying type must be either a pointer or must have a
-    // default constructor.  It's possible that this could change sometime
-    // in the future, but for now, one will have to work around it.  This can
-    // be done by serialization the optional<T> as optional<T *>
-    #if ! defined(BOOST_NO_CXX11_HDR_TYPE_TRAITS)
-        BOOST_STATIC_ASSERT(
-            boost::serialization::detail::is_default_constructible<T>::value
-            || boost::is_pointer<T>::value
-        );
-    #endif
-    const bool tflag = t.is_initialized();
-    ar << boost::serialization::make_nvp("initialized", tflag);
-    if (tflag){
-        ar << boost::serialization::make_nvp("value", *t);
-    }
-}
-
-template<class Archive, class T>
-void load(
-    Archive & ar, 
-    boost::optional< T > & t, 
-    const unsigned int version
-){
-    bool tflag;
-    ar >> boost::serialization::make_nvp("initialized", tflag);
-    if(! tflag){
-        t.reset();
-        return;
-    }
-
-    if(0 == version){
-        boost::serialization::item_version_type item_version(0);
-        boost::archive::library_version_type library_version(
-            ar.get_library_version()
-        );
-        if(boost::archive::library_version_type(3) < library_version){
-            ar >> BOOST_SERIALIZATION_NVP(item_version);
-        }
-    }
-    if(! t.is_initialized())
-        t = T();
-    ar >> boost::serialization::make_nvp("value", *t);
-}
-
-template<class Archive, class T>
-void serialize(
-    Archive & ar, 
-    boost::optional< T > & t, 
-    const unsigned int version
-){
-    boost::serialization::split_free(ar, t, version);
-}
-
-template<class T>
-struct version<boost::optional<T> > {
-    BOOST_STATIC_CONSTANT(int, value = 1);
-};
-
-} // serialization
-} // boost
-
-#endif // BOOST_SERIALIZATION_OPTIONAL_HPP_
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/priority_queue.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/priority_queue.hpp
deleted file mode 100644
index 5b08ffd1e82..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/priority_queue.hpp
+++ /dev/null
@@ -1,76 +0,0 @@
-#ifndef  BOOST_SERIALIZATION_PRIORITY_QUEUE_HPP
-#define BOOST_SERIALIZATION_PRIORITY_QUEUE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// priority_queue.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <queue>
-#include <boost/config.hpp>
-#include <boost/mpl/eval_if.hpp>
-#include <boost/mpl/identity.hpp>
-
-// function specializations must be defined in the appropriate
-// namespace - boost::serialization
-#if defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION)
-#define STD _STLP_STD
-#else
-#define STD std
-#endif
-
-namespace boost { 
-namespace serialization {
-namespace detail{
-
-template <typename U, typename Container, typename Compare>
-struct priority_queue_save : public STD::priority_queue<U, Container, Compare> {
-    template<class Archive>
-    void operator()(Archive & ar, const unsigned int file_version) const {
-        save(ar, STD::priority_queue<U, Container, Compare>::c, file_version);
-    }
-};
-template <typename U, typename Container, typename Compare>
-struct priority_queue_load : public STD::priority_queue<U, Container, Compare> {
-    template<class Archive>
-    void operator()(Archive & ar, const unsigned int file_version) {
-        load(ar, STD::priority_queue<U, Container, Compare>::c, file_version);
-    }
-};
-
-} // detail
-
-template<class Archive, class T, class Container, class Compare>
-inline void serialize(
-    Archive & ar,
-    std::priority_queue< T, Container, Compare> & t,
-    const unsigned int file_version 
-){
-    typedef typename mpl::eval_if<
-        typename Archive::is_saving,
-        mpl::identity<detail::priority_queue_save<T, Container, Compare> >,
-        mpl::identity<detail::priority_queue_load<T, Container, Compare> >
-    >::type typex;
-    static_cast<typex &>(t)(ar, file_version);
-}
-
-} // namespace serialization
-} // namespace boost
-
-#include <boost/serialization/collection_traits.hpp>
-
-BOOST_SERIALIZATION_COLLECTION_TRAITS(STD::priority_queue)
-
-#undef STD
-
-#endif // BOOST_SERIALIZATION_PRIORITY_QUEUE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/queue.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/queue.hpp
deleted file mode 100644
index b22745215d9..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/queue.hpp
+++ /dev/null
@@ -1,76 +0,0 @@
-#ifndef  BOOST_SERIALIZATION_QUEUE_HPP
-#define BOOST_SERIALIZATION_QUEUE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// queue.hpp
-
-// (C) Copyright 2014 Robert Ramey - http://www.rrsd.com .
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <queue>
-#include <boost/config.hpp>
-#include <boost/mpl/eval_if.hpp>
-#include <boost/mpl/identity.hpp>
-
-// function specializations must be defined in the appropriate
-// namespace - boost::serialization
-#if defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION)
-#define STD _STLP_STD
-#else
-#define STD std
-#endif
-
-namespace boost { 
-namespace serialization {
-namespace detail {
-
-template <typename U, typename C>
-struct queue_save : public STD::queue<U, C> {
-    template<class Archive>
-    void operator()(Archive & ar, const unsigned int file_version) const {
-        save(ar, STD::queue<U, C>::c, file_version);
-    }
-};
-template <typename U, typename C>
-struct queue_load : public STD::queue<U, C> {
-    template<class Archive>
-    void operator()(Archive & ar, const unsigned int file_version) {
-        load(ar, STD::queue<U, C>::c, file_version);
-    }
-};
-
-} // detail
-
-template<class Archive, class T, class C>
-inline void serialize(
-    Archive & ar,
-    std::queue< T, C> & t,
-    const unsigned int file_version 
-){
-    typedef typename mpl::eval_if<
-        typename Archive::is_saving,
-        mpl::identity<detail::queue_save<T, C> >,
-        mpl::identity<detail::queue_load<T, C> >
-    >::type typex;
-    static_cast<typex &>(t)(ar, file_version);
-}
-
-} // namespace serialization
-} // namespace boost
-
-#include <boost/serialization/collection_traits.hpp>
-
-BOOST_SERIALIZATION_COLLECTION_TRAITS(STD::queue)
-
-#undef STD
-
-#endif // BOOST_SERIALIZATION_QUEUE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/scoped_ptr.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/scoped_ptr.hpp
deleted file mode 100644
index 0d11f8436e0..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/scoped_ptr.hpp
+++ /dev/null
@@ -1,58 +0,0 @@
-#ifndef BOOST_SERIALIZATION_SCOPED_PTR_HPP_VP_2003_10_30
-#define BOOST_SERIALIZATION_SCOPED_PTR_HPP_VP_2003_10_30
-
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-//  Copyright (c) 2003 Vladimir Prus.
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-
-// Provides non-intrusive serialization for boost::scoped_ptr
-// Does not allow to serialize scoped_ptr's to builtin types.
-
-#include <boost/config.hpp>
-
-#include <boost/scoped_ptr.hpp>
-#include <boost/serialization/nvp.hpp>
-#include <boost/serialization/split_free.hpp>
-
-namespace boost { 
-namespace serialization {
-    
-    template<class Archive, class T>
-    void save(
-        Archive & ar, 
-        const boost::scoped_ptr< T > & t, 
-        const unsigned int /* version */
-    ){
-        T* r = t.get();
-        ar << boost::serialization::make_nvp("scoped_ptr", r);
-    }
-
-    template<class Archive, class T>
-    void load(
-        Archive & ar, 
-        boost::scoped_ptr< T > & t, 
-        const unsigned int /* version */
-    ){
-        T* r;
-        ar >> boost::serialization::make_nvp("scoped_ptr", r);
-        t.reset(r); 
-    }
-
-    template<class Archive, class T>
-    void serialize(
-        Archive& ar, 
-        boost::scoped_ptr< T >& t, 
-        const unsigned int version
-    ){
-        boost::serialization::split_free(ar, t, version);
-    }
-
-} // namespace serialization
-} // namespace boost
-
-#endif // BOOST_SERIALIZATION_SCOPED_PTR_HPP_VP_2003_10_30
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/serialization.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/serialization.hpp
deleted file mode 100644
index a4d04723c75..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/serialization.hpp
+++ /dev/null
@@ -1,154 +0,0 @@
-#ifndef BOOST_SERIALIZATION_SERIALIZATION_HPP
-#define BOOST_SERIALIZATION_SERIALIZATION_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-#if defined(_MSC_VER)
-#  pragma warning (disable : 4675) // suppress ADL warning
-#endif
-
-#include <boost/config.hpp>
-#include <boost/serialization/strong_typedef.hpp>
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// serialization.hpp: interface for serialization system.
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-//////////////////////////////////////////////////////////////////////
-// public interface to serialization. 
-
-/////////////////////////////////////////////////////////////////////////////
-// layer 0 - intrusive verison
-// declared and implemented for each user defined class to be serialized
-//
-//  template<Archive>
-//  serialize(Archive &ar, const unsigned int file_version){
-//      ar & base_object<base>(*this) & member1 & member2 ... ;
-//  }
-
-/////////////////////////////////////////////////////////////////////////////
-// layer 1 - layer that routes member access through the access class.
-// this is what permits us to grant access to private class member functions
-// by specifying friend class boost::serialization::access
-
-#include <boost/serialization/access.hpp>
-
-/////////////////////////////////////////////////////////////////////////////
-// layer 2 - default implementation of non-intrusive serialization.
-//
-// note the usage of function overloading to compensate that C++ does not
-// currently support Partial Template Specialization for function templates 
-// We have declared the version number as "const unsigned long".  
-// Overriding templates for specific data types should declare the version
-// number as "const unsigned int". Template matching will first be applied
-// to functions with the same version types - that is the overloads.  
-// If there is no declared function prototype that matches, the second argument
-// will be converted to "const unsigned long" and a match will be made with 
-// one of the default template functions below.
-
-namespace boost {
-namespace serialization {
-
-BOOST_STRONG_TYPEDEF(unsigned int, version_type)
-
-// default implementation - call the member function "serialize"
-template<class Archive, class T>
-inline void serialize(
-    Archive & ar, T & t, const unsigned int file_version
-){
-    access::serialize(ar, t, static_cast<unsigned int>(file_version));
-}
-
-// save data required for construction
-template<class Archive, class T>
-inline void save_construct_data(
-    Archive & /*ar*/, 
-    const T * /*t*/, 
-    const unsigned int /*file_version */
-){
-    // default is to save no data because default constructor
-    // requires no arguments.
-}
-
-// load data required for construction and invoke constructor in place
-template<class Archive, class T>
-inline void load_construct_data(
-    Archive & /*ar*/, 
-    T * t, 
-    const unsigned int /*file_version*/
-){
-    // default just uses the default constructor.  going
-    // through access permits usage of otherwise private default
-    // constructor
-    access::construct(t);
-}
-
-/////////////////////////////////////////////////////////////////////////////
-// layer 3 - move call into serialization namespace so that ADL will function
-// in the manner we desire.
-//
-// on compilers which don't implement ADL. only the current namespace
-// i.e. boost::serialization will be searched.
-// 
-// on compilers which DO implement ADL
-// serialize overrides can be in any of the following
-// 
-// 1) same namepace as Archive
-// 2) same namespace as T
-// 3) boost::serialization
-//
-// Due to Martin Ecker
-
-template<class Archive, class T>
-inline void serialize_adl(
-    Archive & ar, 
-    T & t, 
-    const unsigned int file_version
-){
-    // note usage of function overloading to delay final resolution
-    // until the point of instantiation.  This works around the two-phase
-    // lookup "feature" which inhibits redefintion of a default function
-    // template implementation. Due to Robert Ramey
-    //
-    // Note that this trick generates problems for compiles which don't support
-    // PFTO, suppress it here.  As far as we know, there are no compilers
-    // which fail to support PFTO while supporting two-phase lookup.
-    const version_type v(file_version);
-    serialize(ar, t, v);
-}
-
-template<class Archive, class T>
-inline void save_construct_data_adl(
-    Archive & ar, 
-    const T * t, 
-    const unsigned int file_version
-){
-    // see above
-    const version_type v(file_version);
-    save_construct_data(ar, t, v);
-}
-
-template<class Archive, class T>
-inline void load_construct_data_adl(
-    Archive & ar, 
-    T * t, 
-    const unsigned int file_version
-){
-    // see above comment
-    const version_type v(file_version);
-    load_construct_data(ar, t, v);
-}
-
-} // namespace serialization
-} // namespace boost
-
-#endif //BOOST_SERIALIZATION_SERIALIZATION_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/set.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/set.hpp
deleted file mode 100644
index 643906c5aac..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/set.hpp
+++ /dev/null
@@ -1,137 +0,0 @@
-#ifndef  BOOST_SERIALIZATION_SET_HPP
-#define BOOST_SERIALIZATION_SET_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// set.hpp: serialization for stl set templates
-
-// (C) Copyright 2002-2014 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <set>
-
-#include <boost/config.hpp>
-
-#include <boost/archive/detail/basic_iarchive.hpp>
-#include <boost/serialization/access.hpp>
-#include <boost/serialization/nvp.hpp>
-#include <boost/serialization/detail/stack_constructor.hpp>
-#include <boost/serialization/collection_size_type.hpp>
-#include <boost/serialization/item_version_type.hpp>
-
-#include <boost/serialization/collections_save_imp.hpp>
-#include <boost/serialization/split_free.hpp>
-#include <boost/move/utility_core.hpp>
-
-namespace boost { 
-namespace serialization {
-
-template<class Archive, class Container>
-inline void load_set_collection(Archive & ar, Container &s)
-{
-    s.clear();
-    const boost::archive::library_version_type library_version(
-        ar.get_library_version()
-    );
-    // retrieve number of elements
-    item_version_type item_version(0);
-    collection_size_type count;
-    ar >> BOOST_SERIALIZATION_NVP(count);
-    if(boost::archive::library_version_type(3) < library_version){
-        ar >> BOOST_SERIALIZATION_NVP(item_version);
-    }
-    typename Container::iterator hint;
-    hint = s.begin();
-    while(count-- > 0){
-        typedef typename Container::value_type type;
-        detail::stack_construct<Archive, type> t(ar, item_version);
-        // borland fails silently w/o full namespace
-        ar >> boost::serialization::make_nvp("item", t.reference());
-        typename Container::iterator result =
-            s.insert(hint, boost::move(t.reference()));
-        ar.reset_object_address(& (* result), & t.reference());
-        hint = result;
-    }
-}
-
-template<class Archive, class Key, class Compare, class Allocator >
-inline void save(
-    Archive & ar,
-    const std::set<Key, Compare, Allocator> &t,
-    const unsigned int /* file_version */
-){
-    boost::serialization::stl::save_collection<
-        Archive, std::set<Key, Compare, Allocator> 
-    >(ar, t);
-}
-
-template<class Archive, class Key, class Compare, class Allocator >
-inline void load(
-    Archive & ar,
-    std::set<Key, Compare, Allocator> &t,
-    const unsigned int /* file_version */
-){
-    load_set_collection(ar, t);
-}
-
-// split non-intrusive serialization function member into separate
-// non intrusive save/load member functions
-template<class Archive, class Key, class Compare, class Allocator >
-inline void serialize(
-    Archive & ar,
-    std::set<Key, Compare, Allocator> & t,
-    const unsigned int file_version
-){
-    boost::serialization::split_free(ar, t, file_version);
-}
-
-// multiset
-template<class Archive, class Key, class Compare, class Allocator >
-inline void save(
-    Archive & ar,
-    const std::multiset<Key, Compare, Allocator> &t,
-    const unsigned int /* file_version */
-){
-    boost::serialization::stl::save_collection<
-        Archive, 
-        std::multiset<Key, Compare, Allocator> 
-    >(ar, t);
-}
-
-template<class Archive, class Key, class Compare, class Allocator >
-inline void load(
-    Archive & ar,
-    std::multiset<Key, Compare, Allocator> &t,
-    const unsigned int /* file_version */
-){
-    load_set_collection(ar, t);
-}
-
-// split non-intrusive serialization function member into separate
-// non intrusive save/load member functions
-template<class Archive, class Key, class Compare, class Allocator >
-inline void serialize(
-    Archive & ar,
-    std::multiset<Key, Compare, Allocator> & t,
-    const unsigned int file_version
-){
-    boost::serialization::split_free(ar, t, file_version);
-}
-
-} // namespace serialization
-} // namespace boost
-
-#include <boost/serialization/collection_traits.hpp>
-
-BOOST_SERIALIZATION_COLLECTION_TRAITS(std::set)
-BOOST_SERIALIZATION_COLLECTION_TRAITS(std::multiset)
-
-#endif // BOOST_SERIALIZATION_SET_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/shared_ptr.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/shared_ptr.hpp
deleted file mode 100644
index 0d4c5ae6056..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/shared_ptr.hpp
+++ /dev/null
@@ -1,281 +0,0 @@
-#ifndef BOOST_SERIALIZATION_SHARED_PTR_HPP
-#define BOOST_SERIALIZATION_SHARED_PTR_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// shared_ptr.hpp: serialization for boost shared pointer
-
-// (C) Copyright 2004 Robert Ramey and Martin Ecker
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <cstddef> // NULL
-#include <memory>
-
-#include <boost/config.hpp>
-#include <boost/mpl/integral_c.hpp>
-#include <boost/mpl/integral_c_tag.hpp>
-
-#include <boost/detail/workaround.hpp>
-#include <boost/shared_ptr.hpp>
-
-#include <boost/serialization/shared_ptr_helper.hpp>
-#include <boost/serialization/split_free.hpp>
-#include <boost/serialization/nvp.hpp>
-#include <boost/serialization/version.hpp>
-#include <boost/serialization/tracking.hpp>
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// boost:: shared_ptr serialization traits
-// version 1 to distinguish from boost 1.32 version. Note: we can only do this
-// for a template when the compiler supports partial template specialization
-
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-    namespace boost {
-    namespace serialization{
-        template<class T>
-        struct version< ::boost::shared_ptr< T > > {
-            typedef mpl::integral_c_tag tag;
-            #if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3206))
-            typedef typename mpl::int_<1> type;
-            #else
-            typedef mpl::int_<1> type;
-            #endif
-            BOOST_STATIC_CONSTANT(int, value = type::value);
-        };
-        // don't track shared pointers
-        template<class T>
-        struct tracking_level< ::boost::shared_ptr< T > > { 
-            typedef mpl::integral_c_tag tag;
-            #if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3206))
-            typedef typename mpl::int_< ::boost::serialization::track_never> type;
-            #else
-            typedef mpl::int_< ::boost::serialization::track_never> type;
-            #endif
-            BOOST_STATIC_CONSTANT(int, value = type::value);
-        };
-    }}
-    #define BOOST_SERIALIZATION_SHARED_PTR(T)
-#else
-    // define macro to let users of these compilers do this
-    #define BOOST_SERIALIZATION_SHARED_PTR(T)                         \
-    BOOST_CLASS_VERSION(                                              \
-        ::boost::shared_ptr< T >,                                     \
-        1                                                             \
-    )                                                                 \
-    BOOST_CLASS_TRACKING(                                             \
-        ::boost::shared_ptr< T >,                                     \
-        ::boost::serialization::track_never                           \
-    )                                                                 \
-    /**/
-#endif
-
-namespace boost {
-namespace serialization{
-
-struct null_deleter {
-    void operator()(void const *) const {}
-};
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// serialization for boost::shared_ptr
-
-// Using a constant means that all shared pointers are held in the same set.
-// Thus we detect handle multiple pointers to the same value instances
-// in the archive.
-void * const shared_ptr_helper_id = 0;
-
-template<class Archive, class T>
-inline void save(
-    Archive & ar,
-    const boost::shared_ptr< T > &t,
-    const unsigned int /* file_version */
-){
-    // The most common cause of trapping here would be serializing
-    // something like shared_ptr<int>.  This occurs because int
-    // is never tracked by default.  Wrap int in a trackable type
-    BOOST_STATIC_ASSERT((tracking_level< T >::value != track_never));
-    const T * t_ptr = t.get();
-    ar << boost::serialization::make_nvp("px", t_ptr);
-}
-
-#ifdef BOOST_SERIALIZATION_SHARED_PTR_132_HPP
-template<class Archive, class T>
-inline void load(
-    Archive & ar,
-    boost::shared_ptr< T > &t,
-    const unsigned int file_version
-){
-    // something like shared_ptr<int>.  This occurs because int
-    // is never tracked by default.  Wrap int in a trackable type
-    BOOST_STATIC_ASSERT((tracking_level< T >::value != track_never));
-    T* r;
-    if(file_version < 1){
-        ar.register_type(static_cast<
-            boost_132::detail::sp_counted_base_impl<T *, null_deleter > *
-        >(NULL));
-        boost_132::shared_ptr< T > sp;
-        ar >> boost::serialization::make_nvp("px", sp.px);
-        ar >> boost::serialization::make_nvp("pn", sp.pn);
-        // got to keep the sps around so the sp.pns don't disappear
-        boost::serialization::shared_ptr_helper<boost::shared_ptr> & h =
-            ar.template get_helper< shared_ptr_helper<boost::shared_ptr> >(
-                shared_ptr_helper_id
-            );
-        h.append(sp);
-        r = sp.get();
-    }
-    else{
-        ar >> boost::serialization::make_nvp("px", r);
-    }
-    shared_ptr_helper<boost::shared_ptr> & h =
-        ar.template get_helper<shared_ptr_helper<boost::shared_ptr> >(
-            shared_ptr_helper_id
-        );
-    h.reset(t,r);
-}
-#else
-
-template<class Archive, class T>
-inline void load(
-    Archive & ar,
-    boost::shared_ptr< T > &t,
-    const unsigned int /*file_version*/
-){
-    // The most common cause of trapping here would be serializing
-    // something like shared_ptr<int>.  This occurs because int
-    // is never tracked by default.  Wrap int in a trackable type
-    BOOST_STATIC_ASSERT((tracking_level< T >::value != track_never));
-    T* r;
-    ar >> boost::serialization::make_nvp("px", r);
-
-    boost::serialization::shared_ptr_helper<boost::shared_ptr> & h =
-        ar.template get_helper<shared_ptr_helper<boost::shared_ptr> >(
-            shared_ptr_helper_id
-        );
-    h.reset(t,r);    
-}
-#endif
-
-template<class Archive, class T>
-inline void serialize(
-    Archive & ar,
-    boost::shared_ptr< T > &t,
-    const unsigned int file_version
-){
-    // correct shared_ptr serialization depends upon object tracking
-    // being used.
-    BOOST_STATIC_ASSERT(
-        boost::serialization::tracking_level< T >::value
-        != boost::serialization::track_never
-    );
-    boost::serialization::split_free(ar, t, file_version);
-}
-
-} // namespace serialization
-} // namespace boost
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// std::shared_ptr serialization traits
-// version 1 to distinguish from boost 1.32 version. Note: we can only do this
-// for a template when the compiler supports partial template specialization
-
-#ifndef BOOST_NO_CXX11_SMART_PTR
-#include <boost/static_assert.hpp>
-
-// note: we presume that any compiler/library which supports C++11
-// std::pointers also supports template partial specialization
-// trap here if such presumption were to turn out to wrong!!!
-#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-    BOOST_STATIC_ASSERT(false);
-#endif
-
-namespace boost {
-namespace serialization{
-    template<class T>
-    struct version< ::std::shared_ptr< T > > {
-        typedef mpl::integral_c_tag tag;
-        typedef mpl::int_<1> type;
-        BOOST_STATIC_CONSTANT(int, value = type::value);
-    };
-    // don't track shared pointers
-    template<class T>
-    struct tracking_level< ::std::shared_ptr< T > > { 
-        typedef mpl::integral_c_tag tag;
-        typedef mpl::int_< ::boost::serialization::track_never> type;
-        BOOST_STATIC_CONSTANT(int, value = type::value);
-    };
-}}
-// the following just keeps older programs from breaking
-#define BOOST_SERIALIZATION_SHARED_PTR(T)
-
-namespace boost {
-namespace serialization{
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// serialization for std::shared_ptr
-
-template<class Archive, class T>
-inline void save(
-    Archive & ar,
-    const std::shared_ptr< T > &t,
-    const unsigned int /* file_version */
-){
-    // The most common cause of trapping here would be serializing
-    // something like shared_ptr<int>.  This occurs because int
-    // is never tracked by default.  Wrap int in a trackable type
-    BOOST_STATIC_ASSERT((tracking_level< T >::value != track_never));
-    const T * t_ptr = t.get();
-    ar << boost::serialization::make_nvp("px", t_ptr);
-}
-
-template<class Archive, class T>
-inline void load(
-    Archive & ar,
-    std::shared_ptr< T > &t,
-    const unsigned int /*file_version*/
-){
-    // The most common cause of trapping here would be serializing
-    // something like shared_ptr<int>.  This occurs because int
-    // is never tracked by default.  Wrap int in a trackable type
-    BOOST_STATIC_ASSERT((tracking_level< T >::value != track_never));
-    T* r;
-    ar >> boost::serialization::make_nvp("px", r);
-    //void (* const id)(Archive &, std::shared_ptr< T > &, const unsigned int) = & load;
-    boost::serialization::shared_ptr_helper<std::shared_ptr> & h =
-        ar.template get_helper<
-            shared_ptr_helper<std::shared_ptr>
-        >(
-            shared_ptr_helper_id
-        );
-    h.reset(t,r);
-}
-
-template<class Archive, class T>
-inline void serialize(
-    Archive & ar,
-    std::shared_ptr< T > &t,
-    const unsigned int file_version
-){
-    // correct shared_ptr serialization depends upon object tracking
-    // being used.
-    BOOST_STATIC_ASSERT(
-        boost::serialization::tracking_level< T >::value
-        != boost::serialization::track_never
-    );
-    boost::serialization::split_free(ar, t, file_version);
-}
-
-} // namespace serialization
-} // namespace boost
-
-#endif // BOOST_NO_CXX11_SMART_PTR
-
-#endif // BOOST_SERIALIZATION_SHARED_PTR_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/shared_ptr_132.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/shared_ptr_132.hpp
deleted file mode 100644
index 3dfaba4d69a..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/shared_ptr_132.hpp
+++ /dev/null
@@ -1,222 +0,0 @@
-#ifndef BOOST_SERIALIZATION_SHARED_PTR_132_HPP
-#define BOOST_SERIALIZATION_SHARED_PTR_132_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// shared_ptr.hpp: serialization for boost shared pointer
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-// note: totally unadvised hack to gain access to private variables
-// in shared_ptr and shared_count. Unfortunately its the only way to
-// do this without changing shared_ptr and shared_count
-// the best we can do is to detect a conflict here
-#include <boost/config.hpp>
-
-#include <list>
-#include <cstddef> // NULL
-
-#include <boost/serialization/assume_abstract.hpp>
-#include <boost/serialization/split_free.hpp>
-#include <boost/serialization/nvp.hpp>
-#include <boost/serialization/tracking.hpp>
-#include <boost/serialization/void_cast.hpp>
-
-// mark base class as an (uncreatable) base class
-#include <boost/serialization/detail/shared_ptr_132.hpp>
-
-/////////////////////////////////////////////////////////////
-// Maintain a couple of lists of loaded shared pointers of the old previous
-// version (1.32)
-
-namespace boost_132 { 
-namespace serialization {
-namespace detail {
-
-struct null_deleter {
-    void operator()(void const *) const {}
-};
-
-} // namespace detail
-} // namespace serialization
-} // namespace boost_132
-
-/////////////////////////////////////////////////////////////
-// sp_counted_base_impl serialization
-
-namespace boost { 
-namespace serialization {
-
-template<class Archive, class P, class D>
-inline void serialize(
-    Archive & /* ar */,
-    boost_132::detail::sp_counted_base_impl<P, D> & /* t */,
-    const unsigned int /*file_version*/
-){
-    // register the relationship between each derived class
-    // its polymorphic base
-    boost::serialization::void_cast_register<
-        boost_132::detail::sp_counted_base_impl<P, D>,
-        boost_132::detail::sp_counted_base 
-    >(
-        static_cast<boost_132::detail::sp_counted_base_impl<P, D> *>(NULL),
-        static_cast<boost_132::detail::sp_counted_base *>(NULL)
-    );
-}
-
-template<class Archive, class P, class D>
-inline void save_construct_data(
-    Archive & ar,
-    const 
-    boost_132::detail::sp_counted_base_impl<P, D> *t, 
-    const unsigned int /* file_version */
-){
-    // variables used for construction
-    ar << boost::serialization::make_nvp("ptr", t->ptr);
-}
-
-template<class Archive, class P, class D>
-inline void load_construct_data(
-    Archive & ar,
-    boost_132::detail::sp_counted_base_impl<P, D> * t, 
-    const unsigned int /* file_version */
-){
-    P ptr_;
-    ar >> boost::serialization::make_nvp("ptr", ptr_);
-    // ::new(t)boost_132::detail::sp_counted_base_impl<P, D>(ptr_,  D()); 
-    // placement
-    // note: the original ::new... above is replaced by the one here.  This one
-    // creates all new objects with a null_deleter so that after the archive
-    // is finished loading and the shared_ptrs are destroyed - the underlying
-    // raw pointers are NOT deleted.  This is necessary as they are used by the 
-    // new system as well.
-    ::new(t)boost_132::detail::sp_counted_base_impl<
-        P, 
-        boost_132::serialization::detail::null_deleter
-    >(
-        ptr_,  boost_132::serialization::detail::null_deleter()
-    ); // placement new
-    // compensate for that fact that a new shared count always is 
-    // initialized with one. the add_ref_copy below will increment it
-    // every time its serialized so without this adjustment
-    // the use and weak counts will be off by one.
-    t->use_count_ = 0;
-}
-
-} // serialization
-} // namespace boost
-
-/////////////////////////////////////////////////////////////
-// shared_count serialization
-
-namespace boost { 
-namespace serialization {
-
-template<class Archive>
-inline void save(
-    Archive & ar,
-    const boost_132::detail::shared_count &t,
-    const unsigned int /* file_version */
-){
-    ar << boost::serialization::make_nvp("pi", t.pi_);
-}
-
-template<class Archive>
-inline void load(
-    Archive & ar,
-    boost_132::detail::shared_count &t,
-    const unsigned int /* file_version */
-){
-    ar >> boost::serialization::make_nvp("pi", t.pi_);
-    if(NULL != t.pi_)
-        t.pi_->add_ref_copy();
-}
-
-} // serialization
-} // namespace boost
-
-BOOST_SERIALIZATION_SPLIT_FREE(boost_132::detail::shared_count)
-
-/////////////////////////////////////////////////////////////
-// implement serialization for shared_ptr< T >
-
-namespace boost { 
-namespace serialization {
-
-template<class Archive, class T>
-inline void save(
-    Archive & ar,
-    const boost_132::shared_ptr< T > &t,
-    const unsigned int /* file_version */
-){
-    // only the raw pointer has to be saved
-    // the ref count is maintained automatically as shared pointers are loaded
-    ar.register_type(static_cast<
-        boost_132::detail::sp_counted_base_impl<T *, boost::checked_deleter< T > > *
-    >(NULL));
-    ar << boost::serialization::make_nvp("px", t.px);
-    ar << boost::serialization::make_nvp("pn", t.pn);
-}
-
-template<class Archive, class T>
-inline void load(
-    Archive & ar,
-    boost_132::shared_ptr< T > &t,
-    const unsigned int /* file_version */
-){
-    // only the raw pointer has to be saved
-    // the ref count is maintained automatically as shared pointers are loaded
-    ar.register_type(static_cast<
-        boost_132::detail::sp_counted_base_impl<T *, boost::checked_deleter< T > > *
-    >(NULL));
-    ar >> boost::serialization::make_nvp("px", t.px);
-    ar >> boost::serialization::make_nvp("pn", t.pn);
-}
-
-template<class Archive, class T>
-inline void serialize(
-    Archive & ar,
-    boost_132::shared_ptr< T > &t,
-    const unsigned int file_version
-){
-    // correct shared_ptr serialization depends upon object tracking
-    // being used.
-    BOOST_STATIC_ASSERT(
-        boost::serialization::tracking_level< T >::value
-        != boost::serialization::track_never
-    );
-    boost::serialization::split_free(ar, t, file_version);
-}
-
-} // serialization
-} // namespace boost
-
-// note: change below uses null_deleter 
-// This macro is used to export GUIDS for shared pointers to allow
-// the serialization system to export them properly. David Tonge
-#define BOOST_SHARED_POINTER_EXPORT_GUID(T, K)                     \
-    typedef boost_132::detail::sp_counted_base_impl<               \
-        T *,                                                       \
-        boost::checked_deleter< T >                                \
-    > __shared_ptr_ ## T;                                          \
-    BOOST_CLASS_EXPORT_GUID(__shared_ptr_ ## T, "__shared_ptr_" K) \
-    BOOST_CLASS_EXPORT_GUID(T, K)                                  \
-    /**/
-
-#define BOOST_SHARED_POINTER_EXPORT(T)                             \
-    BOOST_SHARED_POINTER_EXPORT_GUID(                              \
-        T,                                                         \
-        BOOST_PP_STRINGIZE(T)                                      \
-    )                                                              \
-    /**/
-
-#endif // BOOST_SERIALIZATION_SHARED_PTR_132_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/shared_ptr_helper.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/shared_ptr_helper.hpp
deleted file mode 100644
index 37c34d6b2c4..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/shared_ptr_helper.hpp
+++ /dev/null
@@ -1,209 +0,0 @@
-#ifndef BOOST_SERIALIZATION_SHARED_PTR_HELPER_HPP
-#define BOOST_SERIALIZATION_SHARED_PTR_HELPER_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// shared_ptr_helper.hpp: serialization for boost shared pointern
-
-// (C) Copyright 2004-2009 Robert Ramey, Martin Ecker and Takatoshi Kondo
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <map>
-#include <list>
-#include <utility>
-#include <cstddef> // NULL
-
-#include <boost/config.hpp>
-#include <boost/shared_ptr.hpp>
-#include <boost/type_traits/is_polymorphic.hpp>
-#include <boost/mpl/if.hpp>
-
-#include <boost/serialization/singleton.hpp>
-#include <boost/serialization/extended_type_info.hpp>
-#include <boost/serialization/throw_exception.hpp>
-#include <boost/serialization/type_info_implementation.hpp>
-#include <boost/archive/archive_exception.hpp>
-
-namespace boost_132 {
-    template<class T> class shared_ptr;
-}
-namespace boost {
-namespace serialization {
-
-#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
-template<class Archive, template<class U> class SPT >
-void load(
-    Archive & ar,
-    SPT< class U > &t,
-    const unsigned int file_version
-);
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// a common class for holding various types of shared pointers
-
-template<template<class T> class SPT>
-class shared_ptr_helper {
-    typedef std::map<
-        const void *, // address of object
-        SPT<const void> // address shared ptr to single instance
-    > object_shared_pointer_map;
-
-    // list of shared_pointers create accessable by raw pointer. This
-    // is used to "match up" shared pointers loaded at different
-    // points in the archive. Note, we delay construction until
-    // it is actually used since this is by default included as
-    // a "mix-in" even if shared_ptr isn't used.
-    object_shared_pointer_map * m_o_sp;
-
-    struct null_deleter {
-        void operator()(void const *) const {}
-    };
-
-#if defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS) \
-|| defined(BOOST_MSVC) \
-|| defined(__SUNPRO_CC)
-public:
-#else
-    template<class Archive, class U>
-    friend void boost::serialization::load(
-        Archive & ar,
-        SPT< U > &t,
-        const unsigned int file_version
-    );
-#endif
-
-    #ifdef BOOST_SERIALIZATION_SHARED_PTR_132_HPP
-    // list of loaded pointers.  This is used to be sure that the pointers
-    // stay around long enough to be "matched" with other pointers loaded
-    // by the same archive.  These are created with a "null_deleter" so that
-    // when this list is destroyed - the underlaying raw pointers are not
-    // destroyed.  This has to be done because the pointers are also held by
-    // new system which is disjoint from this set.  This is implemented
-    // by a change in load_construct_data below.  It makes this file suitable
-    // only for loading pointers into a 1.33 or later boost system.
-    std::list<boost_132::shared_ptr<const void> > * m_pointers_132;
-    void
-    append(const boost_132::shared_ptr<const void> & t){
-        if(NULL == m_pointers_132)
-            m_pointers_132 = new std::list<boost_132::shared_ptr<const void> >;
-        m_pointers_132->push_back(t);
-    }
-    #endif
-
-    struct non_polymorphic {
-        template<class U>
-        static const boost::serialization::extended_type_info * 
-        get_object_type(U & ){
-            return & boost::serialization::singleton<
-                typename 
-                boost::serialization::type_info_implementation< U >::type
-            >::get_const_instance();
-        }
-    };
-    struct polymorphic {
-        template<class U>
-        static const boost::serialization::extended_type_info * 
-        get_object_type(U & u){
-            return boost::serialization::singleton<
-                typename 
-                boost::serialization::type_info_implementation< U >::type
-            >::get_const_instance().get_derived_extended_type_info(u);
-        }
-    };
-
-public:
-    template<class T>
-    void reset(SPT< T > & s, T * t){
-        if(NULL == t){
-            s.reset();
-            return;
-        }
-        const boost::serialization::extended_type_info * this_type
-            = & boost::serialization::type_info_implementation< T >::type
-                    ::get_const_instance();
-
-        // get pointer to the most derived object's eti.  This is effectively
-        // the object type identifer
-        typedef typename mpl::if_<
-            is_polymorphic< T >,
-            polymorphic,
-            non_polymorphic
-        >::type type;
-
-        const boost::serialization::extended_type_info * true_type
-            = type::get_object_type(*t);
-
-        // note:if this exception is thrown, be sure that derived pointern
-        // is either registered or exported.
-        if(NULL == true_type)
-            boost::serialization::throw_exception(
-                boost::archive::archive_exception(
-                    boost::archive::archive_exception::unregistered_class,
-                    this_type->get_debug_info()
-                )
-            );
-        // get void pointer to the most derived type
-        // this uniquely identifies the object referred to
-        // oid = "object identifier"
-        const void * oid = void_downcast(
-            *true_type,
-            *this_type,
-            t
-        );
-        if(NULL == oid)
-            boost::serialization::throw_exception(
-                boost::archive::archive_exception(
-                    boost::archive::archive_exception::unregistered_cast,
-                    true_type->get_debug_info(),
-                    this_type->get_debug_info()
-                )
-            );
-
-        // make tracking array if necessary
-        if(NULL == m_o_sp)
-            m_o_sp = new object_shared_pointer_map;
-
-        typename object_shared_pointer_map::iterator i = m_o_sp->find(oid);
-
-        // if it's a new object
-        if(i == m_o_sp->end()){
-            s.reset(t);
-            std::pair<typename object_shared_pointer_map::iterator, bool> result;
-            result = m_o_sp->insert(std::make_pair(oid, s));
-            BOOST_ASSERT(result.second);
-        }
-        // if the object has already been seen
-        else{
-            s = SPT<T>(i->second, t);
-        }
-    }
-
-    shared_ptr_helper() :
-        m_o_sp(NULL)
-        #ifdef BOOST_SERIALIZATION_SHARED_PTR_132_HPP
-            , m_pointers_132(NULL)
-        #endif
-    {}
-    virtual ~shared_ptr_helper(){
-        if(NULL != m_o_sp)
-            delete m_o_sp;
-        #ifdef BOOST_SERIALIZATION_SHARED_PTR_132_HPP
-        if(NULL != m_pointers_132)
-            delete m_pointers_132;
-        #endif
-    }
-};
-
-} // namespace serialization
-} // namespace boost
-
-#endif // BOOST_SERIALIZATION_SHARED_PTR_HELPER_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/singleton.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/singleton.hpp
deleted file mode 100644
index b50afedbb92..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/singleton.hpp
+++ /dev/null
@@ -1,166 +0,0 @@
-#ifndef BOOST_SERIALIZATION_SINGLETON_HPP
-#define BOOST_SERIALIZATION_SINGLETON_HPP
-
-/////////1/////////2///////// 3/////////4/////////5/////////6/////////7/////////8
-//  singleton.hpp
-//
-// Copyright David Abrahams 2006. Original version
-//
-// Copyright Robert Ramey 2007.  Changes made to permit
-// application throughout the serialization library.
-//
-// Distributed under the Boost
-// Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-// The intention here is to define a template which will convert
-// any class into a singleton with the following features:
-//
-// a) initialized before first use.
-// b) thread-safe for const access to the class
-// c) non-locking
-//
-// In order to do this,
-// a) Initialize dynamically when used.
-// b) Require that all singletons be initialized before main
-// is called or any entry point into the shared library is invoked.
-// This guarentees no race condition for initialization.
-// In debug mode, we assert that no non-const functions are called
-// after main is invoked.
-//
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif 
-
-#include <boost/assert.hpp>
-#include <boost/config.hpp>
-#include <boost/noncopyable.hpp>
-#include <boost/serialization/force_include.hpp>
-
-#include <boost/archive/detail/auto_link_archive.hpp>
-#include <boost/serialization/config.hpp>
-#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
-
-#ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable : 4511 4512)
-#endif
-
-namespace boost { 
-namespace serialization { 
-
-//////////////////////////////////////////////////////////////////////
-// Provides a dynamically-initialized (singleton) instance of T in a
-// way that avoids LNK1179 on vc6.  See http://tinyurl.com/ljdp8 or
-// http://lists.boost.org/Archives/boost/2006/05/105286.php for
-// details.
-//
-
-// singletons created by this code are guarenteed to be unique
-// within the executable or shared library which creates them.
-// This is sufficient and in fact ideal for the serialization library.
-// The singleton is created when the module is loaded and destroyed
-// when the module is unloaded.
-
-// This base class has two functions.
-
-// First it provides a module handle for each singleton indicating
-// the executable or shared library in which it was created. This
-// turns out to be necessary and sufficient to implement the tables
-// used by serialization library.
-
-// Second, it provides a mechanism to detect when a non-const function
-// is called after initialization.
-
-// make a singleton to lock/unlock all singletons for alteration.
-// The intent is that all singletons created/used by this code
-// are to be initialized before main is called. A test program
-// can lock all the singletons when main is entereed.  This any
-// attempt to retieve a mutable instances while locked will
-// generate a assertion if compiled for debug.
-
-// note usage of BOOST_DLLEXPORT.  These functions are in danger of
-// being eliminated by the optimizer when building an application in
-// release mode. Usage of the macro is meant to signal the compiler/linker
-// to avoid dropping these functions which seem to be unreferenced.
-// This usage is not related to autolinking.
-
-class BOOST_SYMBOL_VISIBLE singleton_module :
-    public boost::noncopyable
-{
-private:
-    BOOST_SERIALIZATION_DECL BOOST_DLLEXPORT static bool & get_lock() BOOST_USED;
-public:
-    BOOST_DLLEXPORT static void lock(){
-        get_lock() = true;
-    }
-    BOOST_DLLEXPORT static void unlock(){
-        get_lock() = false;
-    }
-    BOOST_DLLEXPORT static bool is_locked(){
-        return get_lock();
-    }
-};
-
-template <class T>
-class singleton : public singleton_module
-{
-private:
-    static T & m_instance;
-    // include this to provoke instantiation at pre-execution time
-    static void use(T const *) {}
-    static T & get_instance() {
-        // use a wrapper so that types T with protected constructors
-        // can be used
-        class singleton_wrapper : public T {};
-        static singleton_wrapper t;
-        // refer to instance, causing it to be instantiated (and
-        // initialized at startup on working compilers)
-        BOOST_ASSERT(! is_destroyed());
-        // note that the following is absolutely essential.
-        // commenting out this statement will cause compilers to fail to
-        // construct the instance at pre-execution time.  This would prevent
-        // our usage/implementation of "locking" and introduce uncertainty into
-        // the sequence of object initializaition.
-        use(& m_instance);
-        return static_cast<T &>(t);
-    }
-    static bool & get_is_destroyed(){
-        static bool is_destroyed;
-        return is_destroyed;
-    }
-
-public:
-    BOOST_DLLEXPORT static T & get_mutable_instance(){
-        BOOST_ASSERT(! is_locked());
-        return get_instance();
-    }
-    BOOST_DLLEXPORT static const T & get_const_instance(){
-        return get_instance();
-    }
-    BOOST_DLLEXPORT static bool is_destroyed(){
-        return get_is_destroyed();
-    }
-    BOOST_DLLEXPORT singleton(){
-        get_is_destroyed() = false;
-    }
-    BOOST_DLLEXPORT ~singleton() {
-        get_is_destroyed() = true;
-    }
-};
-
-template<class T>
-T & singleton< T >::m_instance = singleton< T >::get_instance();
-
-} // namespace serialization
-} // namespace boost
-
-#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
-
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
-
-#endif // BOOST_SERIALIZATION_SINGLETON_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/slist.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/slist.hpp
deleted file mode 100644
index d9b971bc4f1..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/slist.hpp
+++ /dev/null
@@ -1,145 +0,0 @@
-#ifndef BOOST_SERIALIZATION_SLIST_HPP
-#define BOOST_SERIALIZATION_SLIST_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// slist.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/config.hpp>
-#ifdef BOOST_HAS_SLIST
-#include BOOST_SLIST_HEADER
-
-#include <boost/serialization/collections_save_imp.hpp>
-#include <boost/serialization/collections_load_imp.hpp>
-#include <boost/archive/detail/basic_iarchive.hpp>
-#include <boost/serialization/nvp.hpp>
-#include <boost/serialization/collection_size_type.hpp>
-#include <boost/serialization/item_version_type.hpp>
-#include <boost/serialization/split_free.hpp>
-#include <boost/serialization/detail/stack_constructor.hpp>
-#include <boost/serialization/detail/is_default_constructible.hpp>
-#include <boost/move/utility_core.hpp>
-
-namespace boost { 
-namespace serialization {
-
-template<class Archive, class U, class Allocator>
-inline void save(
-    Archive & ar,
-    const BOOST_STD_EXTENSION_NAMESPACE::slist<U, Allocator> &t,
-    const unsigned int file_version
-){
-    boost::serialization::stl::save_collection<
-        Archive,
-        BOOST_STD_EXTENSION_NAMESPACE::slist<U, Allocator> 
-    >(ar, t);
-}
-
-namespace stl {
-
-template<
-    class Archive,
-    class T,
-    class Allocator
->
-typename boost::disable_if<
-    typename detail::is_default_constructible<
-        typename BOOST_STD_EXTENSION_NAMESPACE::slist<T, Allocator>::value_type
-    >,
-    void
->::type
-collection_load_impl(
-    Archive & ar,
-    BOOST_STD_EXTENSION_NAMESPACE::slist<T, Allocator> &t,
-    collection_size_type count,
-    item_version_type item_version
-){
-    t.clear();
-    boost::serialization::detail::stack_construct<Archive, T> u(ar, item_version);
-    ar >> boost::serialization::make_nvp("item", u.reference());
-    t.push_front(boost::move(u.reference()));
-    typename BOOST_STD_EXTENSION_NAMESPACE::slist<T, Allocator>::iterator last;
-    last = t.begin();
-    ar.reset_object_address(&(*t.begin()) , & u.reference());
-    while(--count > 0){
-        detail::stack_construct<Archive, T> u(ar, item_version);
-        ar >> boost::serialization::make_nvp("item", u.reference());
-        last = t.insert_after(last, boost::move(u.reference()));
-        ar.reset_object_address(&(*last) , & u.reference());
-    }
-}
-
-} // stl
-
-template<class Archive, class U, class Allocator>
-inline void load(
-    Archive & ar,
-    BOOST_STD_EXTENSION_NAMESPACE::slist<U, Allocator> &t,
-    const unsigned int file_version
-){
-    const boost::archive::library_version_type library_version(
-        ar.get_library_version()
-    );
-    // retrieve number of elements
-    item_version_type item_version(0);
-    collection_size_type count;
-    ar >> BOOST_SERIALIZATION_NVP(count);
-    if(boost::archive::library_version_type(3) < library_version){
-        ar >> BOOST_SERIALIZATION_NVP(item_version);
-    }
-    if(detail::is_default_constructible<U>()){
-        t.resize(count);
-        typename BOOST_STD_EXTENSION_NAMESPACE::slist<U, Allocator>::iterator hint;
-        hint = t.begin();
-        while(count-- > 0){
-            ar >> boost::serialization::make_nvp("item", *hint++);
-        }
-    }
-    else{
-        t.clear();
-        boost::serialization::detail::stack_construct<Archive, U> u(ar, item_version);
-        ar >> boost::serialization::make_nvp("item", u.reference());
-        t.push_front(boost::move(u.reference()));
-        typename BOOST_STD_EXTENSION_NAMESPACE::slist<U, Allocator>::iterator last;
-        last = t.begin();
-        ar.reset_object_address(&(*t.begin()) , & u.reference());
-        while(--count > 0){
-            detail::stack_construct<Archive, U> u(ar, item_version);
-            ar >> boost::serialization::make_nvp("item", u.reference());
-            last = t.insert_after(last, boost::move(u.reference()));
-            ar.reset_object_address(&(*last) , & u.reference());
-        }
-    }
-}
-
-// split non-intrusive serialization function member into separate
-// non intrusive save/load member functions
-template<class Archive, class U, class Allocator>
-inline void serialize(
-    Archive & ar,
-    BOOST_STD_EXTENSION_NAMESPACE::slist<U, Allocator> &t,
-    const unsigned int file_version
-){
-    boost::serialization::split_free(ar, t, file_version);
-}
-
-} // serialization
-} // namespace boost
-
-#include <boost/serialization/collection_traits.hpp>
-
-BOOST_SERIALIZATION_COLLECTION_TRAITS(BOOST_STD_EXTENSION_NAMESPACE::slist)
-
-#endif  // BOOST_HAS_SLIST
-#endif  // BOOST_SERIALIZATION_SLIST_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/smart_cast.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/smart_cast.hpp
deleted file mode 100644
index 563f36aa20b..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/smart_cast.hpp
+++ /dev/null
@@ -1,275 +0,0 @@
-#ifndef BOOST_SERIALIZATION_SMART_CAST_HPP
-#define BOOST_SERIALIZATION_SMART_CAST_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// smart_cast.hpp:
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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/serialization for updates, documentation, and revision history.
-
-// casting of pointers and references.  
-
-// In casting between different C++ classes, there are a number of
-// rules that have to be kept in mind in deciding whether to use
-// static_cast or dynamic_cast.  
-
-// a) dynamic casting can only be applied when one of the types is polymorphic
-// Otherwise static_cast must be used.
-// b) only dynamic casting can do runtime error checking
-// use of static_cast is generally un checked even when compiled for debug
-// c) static_cast would be considered faster than dynamic_cast.
-
-// If casting is applied to a template parameter, there is no apriori way
-// to know which of the two casting methods will be permitted or convenient.
-
-// smart_cast uses C++ type_traits, and program debug mode to select the
-// most convenient cast to use.
-
-#include <exception>
-#include <typeinfo>
-#include <cstddef> // NULL
-
-#include <boost/config.hpp>
-#include <boost/static_assert.hpp>
-
-#include <boost/type_traits/is_base_and_derived.hpp>
-#include <boost/type_traits/is_polymorphic.hpp>
-#include <boost/type_traits/is_pointer.hpp>
-#include <boost/type_traits/is_reference.hpp>
-#include <boost/type_traits/is_same.hpp>
-#include <boost/type_traits/remove_pointer.hpp>
-#include <boost/type_traits/remove_reference.hpp>
-
-#include <boost/mpl/eval_if.hpp>
-#include <boost/mpl/if.hpp>
-#include <boost/mpl/or.hpp>
-#include <boost/mpl/and.hpp>
-#include <boost/mpl/not.hpp>
-#include <boost/mpl/identity.hpp>
-
-#include <boost/serialization/throw_exception.hpp>
-
-namespace boost {
-namespace serialization {
-namespace smart_cast_impl {
-
-    template<class T>
-    struct reference {
-
-        struct polymorphic {
-
-            struct linear {
-                template<class U>
-                 static T cast(U & u){
-                    return static_cast< T >(u);
-                }
-            };
-
-            struct cross {
-                 template<class U>
-                static T cast(U & u){
-                    return dynamic_cast< T >(u);
-                }
-            };
-
-            template<class U>
-            static T cast(U & u){
-                // if we're in debug mode
-                #if ! defined(NDEBUG)                               \
-                || defined(__MWERKS__)
-                    // do a checked dynamic cast
-                    return cross::cast(u);
-                #else
-                    // borland 5.51 chokes here so we can't use it
-                    // note: if remove_reference isn't function for these types
-                    // cross casting will be selected this will work but will
-                    // not be the most efficient method. This will conflict with
-                    // the original smart_cast motivation.
-                    typedef typename mpl::eval_if<
-                            typename mpl::and_<
-                                mpl::not_<is_base_and_derived<
-                                    typename remove_reference< T >::type,
-                                    U
-                                > >,
-                                mpl::not_<is_base_and_derived<
-                                    U,
-                                    typename remove_reference< T >::type
-                                > >
-                            >,
-                            // borland chokes w/o full qualification here
-                            mpl::identity<cross>,
-                            mpl::identity<linear>
-                    >::type typex;
-                    // typex works around gcc 2.95 issue
-                    return typex::cast(u);
-                #endif
-            }
-        };
-
-        struct non_polymorphic {
-            template<class U>
-             static T cast(U & u){
-                return static_cast< T >(u);
-            }
-        };
-        template<class U>
-        static T cast(U & u){
-            typedef typename mpl::eval_if<
-                boost::is_polymorphic<U>,
-                mpl::identity<polymorphic>,
-                mpl::identity<non_polymorphic>
-            >::type typex;
-            return typex::cast(u);
-        }
-    };
-
-    template<class T>
-    struct pointer {
-
-        struct polymorphic {
-            // unfortunately, this below fails to work for virtual base 
-            // classes.  need has_virtual_base to do this.
-            // Subject for further study
-            #if 0
-            struct linear {
-                template<class U>
-                 static T cast(U * u){
-                    return static_cast< T >(u);
-                }
-            };
-
-            struct cross {
-                template<class U>
-                static T cast(U * u){
-                    T tmp = dynamic_cast< T >(u);
-                    #ifndef NDEBUG
-                        if ( tmp == 0 ) throw_exception(std::bad_cast());
-                    #endif
-                    return tmp;
-                }
-            };
-
-            template<class U>
-            static T cast(U * u){
-                typedef
-                    typename mpl::eval_if<
-                        typename mpl::and_<
-                            mpl::not_<is_base_and_derived<
-                                typename remove_pointer< T >::type,
-                                U
-                            > >,
-                            mpl::not_<is_base_and_derived<
-                                U,
-                                typename remove_pointer< T >::type
-                            > >
-                        >,
-                        // borland chokes w/o full qualification here
-                        mpl::identity<cross>,
-                        mpl::identity<linear>
-                    >::type typex;
-                return typex::cast(u);
-            }
-            #else
-            template<class U>
-            static T cast(U * u){
-                T tmp = dynamic_cast< T >(u);
-                #ifndef NDEBUG
-                    if ( tmp == 0 ) throw_exception(std::bad_cast());
-                #endif
-                return tmp;
-            }
-            #endif
-        };
-
-        struct non_polymorphic {
-            template<class U>
-             static T cast(U * u){
-                return static_cast< T >(u);
-            }
-        };
-
-        template<class U>
-        static T cast(U * u){
-            typedef typename mpl::eval_if<
-                boost::is_polymorphic<U>,
-                mpl::identity<polymorphic>,
-                mpl::identity<non_polymorphic>
-            >::type typex;
-            return typex::cast(u);
-        }
-
-    };
-
-    template<class TPtr>
-    struct void_pointer {
-        template<class UPtr>
-        static TPtr cast(UPtr uptr){
-            return static_cast<TPtr>(uptr);
-        }
-    };
-
-    template<class T>
-    struct error {
-        // if we get here, its because we are using one argument in the
-        // cast on a system which doesn't support partial template 
-        // specialization
-        template<class U>
-        static T cast(U){
-            BOOST_STATIC_ASSERT(sizeof(T)==0);
-            return * static_cast<T *>(NULL);
-        }
-    };
-
-} // smart_cast_impl
-
-// this implements:
-// smart_cast<Target *, Source *>(Source * s)
-// smart_cast<Target &, Source &>(s)
-// note that it will fail with
-// smart_cast<Target &>(s)
-template<class T, class U>
-T smart_cast(U u) {
-    typedef
-        typename mpl::eval_if<
-            typename mpl::or_<
-                boost::is_same<void *, U>,
-                boost::is_same<void *, T>,
-                boost::is_same<const void *, U>,
-                boost::is_same<const void *, T>
-            >,
-            mpl::identity<smart_cast_impl::void_pointer< T > >,
-        // else
-        typename mpl::eval_if<boost::is_pointer<U>,
-            mpl::identity<smart_cast_impl::pointer< T > >,
-        // else
-        typename mpl::eval_if<boost::is_reference<U>,
-            mpl::identity<smart_cast_impl::reference< T > >,
-        // else
-            mpl::identity<smart_cast_impl::error< T >
-        >
-        >
-        >
-        >::type typex;
-    return typex::cast(u);
-}
-
-// this implements:
-// smart_cast_reference<Target &>(Source & s)
-template<class T, class U>
-T smart_cast_reference(U & u) {
-    return smart_cast_impl::reference< T >::cast(u);
-}
-
-} // namespace serialization
-} // namespace boost
-
-#endif // BOOST_SERIALIZATION_SMART_CAST_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/split_free.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/split_free.hpp
deleted file mode 100644
index 85e2f590fe4..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/split_free.hpp
+++ /dev/null
@@ -1,93 +0,0 @@
-#ifndef BOOST_SERIALIZATION_SPLIT_FREE_HPP
-#define BOOST_SERIALIZATION_SPLIT_FREE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// split_free.hpp:
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/config.hpp>
-#include <boost/mpl/eval_if.hpp>
-#include <boost/mpl/identity.hpp>
-#include <boost/serialization/serialization.hpp>
-
-namespace boost {
-namespace archive {
-    namespace detail {
-        template<class Archive> class interface_oarchive;
-        template<class Archive> class interface_iarchive;
-    } // namespace detail
-} // namespace archive
-
-namespace serialization {
-
-//namespace detail {
-template<class Archive, class T>
-struct free_saver {
-    static void invoke(
-        Archive & ar, 
-        const  T & t, 
-        const unsigned int file_version
-    ){
-        // use function overload (version_type) to workaround
-        // two-phase lookup issue
-        const version_type v(file_version);
-        save(ar, t, v);
-    }
-};
-template<class Archive, class T>
-struct free_loader {
-    static void invoke(
-        Archive & ar, 
-        T & t, 
-        const unsigned int file_version
-    ){
-        // use function overload (version_type) to workaround
-        // two-phase lookup issue
-        const version_type v(file_version);
-        load(ar, t, v);
-    }
-};
-//} // namespace detail
-
-template<class Archive, class T>
-inline void split_free(
-    Archive & ar, 
-    T & t, 
-    const unsigned int file_version
-){
-    typedef typename mpl::eval_if<
-        typename Archive::is_saving,
-        mpl::identity</* detail:: */ free_saver<Archive, T> >, 
-        mpl::identity</* detail:: */ free_loader<Archive, T> >
-    >::type typex;
-    typex::invoke(ar, t, file_version);
-}
-
-} // namespace serialization
-} // namespace boost
-
-#define BOOST_SERIALIZATION_SPLIT_FREE(T)       \
-namespace boost { namespace serialization {     \
-template<class Archive>                         \
-inline void serialize(                          \
-        Archive & ar,                               \
-        T & t,                                      \
-        const unsigned int file_version             \
-){                                              \
-        split_free(ar, t, file_version);            \
-}                                               \
-}}
-/**/
-
-#endif // BOOST_SERIALIZATION_SPLIT_FREE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/split_member.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/split_member.hpp
deleted file mode 100644
index 5f32520559e..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/split_member.hpp
+++ /dev/null
@@ -1,86 +0,0 @@
-#ifndef BOOST_SERIALIZATION_SPLIT_MEMBER_HPP
-#define BOOST_SERIALIZATION_SPLIT_MEMBER_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// split_member.hpp:
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/config.hpp>
-#include <boost/mpl/eval_if.hpp>
-#include <boost/mpl/identity.hpp>
-
-#include <boost/serialization/access.hpp>
-
-namespace boost {
-namespace archive {
-    namespace detail {
-        template<class Archive> class interface_oarchive;
-        template<class Archive> class interface_iarchive;
-    } // namespace detail
-} // namespace archive
-
-namespace serialization {
-namespace detail {
-
-    template<class Archive, class T>
-    struct member_saver {
-        static void invoke(
-            Archive & ar, 
-            const T & t,
-            const unsigned int file_version
-        ){
-            access::member_save(ar, t, file_version);
-        }
-    };
-
-    template<class Archive, class T>
-    struct member_loader {
-        static void invoke(
-            Archive & ar, 
-            T & t,
-            const unsigned int file_version
-        ){
-            access::member_load(ar, t, file_version);
-        }
-    };
-
-} // detail
-
-template<class Archive, class T>
-inline void split_member(
-    Archive & ar, T & t, const unsigned int file_version
-){
-    typedef typename mpl::eval_if<
-        typename Archive::is_saving,
-        mpl::identity<detail::member_saver<Archive, T> >, 
-        mpl::identity<detail::member_loader<Archive, T> >
-    >::type typex;
-    typex::invoke(ar, t, file_version);
-}
-
-} // namespace serialization
-} // namespace boost
-
-// split member function serialize funcition into save/load
-#define BOOST_SERIALIZATION_SPLIT_MEMBER()                       \
-template<class Archive>                                          \
-void serialize(                                                  \
-    Archive &ar,                                                 \
-    const unsigned int file_version                              \
-){                                                               \
-    boost::serialization::split_member(ar, *this, file_version); \
-}                                                                \
-/**/
-
-#endif // BOOST_SERIALIZATION_SPLIT_MEMBER_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/stack.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/stack.hpp
deleted file mode 100644
index 96f90fe8767..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/stack.hpp
+++ /dev/null
@@ -1,76 +0,0 @@
-#ifndef  BOOST_SERIALIZATION_STACK_HPP
-#define BOOST_SERIALIZATION_STACK_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// stack.hpp
-
-// (C) Copyright 2014 Robert Ramey - http://www.rrsd.com .
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <stack>
-#include <boost/config.hpp>
-#include <boost/mpl/eval_if.hpp>
-#include <boost/mpl/identity.hpp>
-
-// function specializations must be defined in the appropriate
-// namespace - boost::serialization
-#if defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION)
-#define STD _STLP_STD
-#else
-#define STD std
-#endif
-
-namespace boost { 
-namespace serialization {
-namespace detail{
-
-template <typename U, typename C>
-struct stack_save : public STD::stack<U, C> {
-    template<class Archive>
-    void operator()(Archive & ar, const unsigned int file_version) const {
-        save(ar, STD::stack<U, C>::c, file_version);
-    }
-};
-template <typename U, typename C>
-struct stack_load : public STD::stack<U, C> {
-    template<class Archive>
-    void operator()(Archive & ar, const unsigned int file_version) {
-        load(ar, STD::stack<U, C>::c, file_version);
-    }
-};
-
-} // detail
-
-template<class Archive, class T, class C>
-inline void serialize(
-    Archive & ar,
-    std::stack< T, C> & t,
-    const unsigned int file_version 
-){
-    typedef typename mpl::eval_if<
-        typename Archive::is_saving,
-        mpl::identity<detail::stack_save<T, C> >,
-        mpl::identity<detail::stack_load<T, C> >
-    >::type typex;
-    static_cast<typex &>(t)(ar, file_version);
-}
-
-} // namespace serialization
-} // namespace boost
-
-#include <boost/serialization/collection_traits.hpp>
-
-BOOST_SERIALIZATION_COLLECTION_TRAITS(STD::stack)
-
-#undef STD
-
-#endif // BOOST_SERIALIZATION_DEQUE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/state_saver.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/state_saver.hpp
deleted file mode 100644
index 248b8d91556..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/state_saver.hpp
+++ /dev/null
@@ -1,96 +0,0 @@
-#ifndef BOOST_SERIALIZATION_STATE_SAVER_HPP
-#define BOOST_SERIALIZATION_STATE_SAVER_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// state_saver.hpp:
-
-// (C) Copyright 2003-4 Pavel Vozenilek and Robert Ramey - http://www.rrsd.com.
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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/serialization for updates, documentation, and revision history.
-
-// Inspired by Daryle Walker's iostate_saver concept.  This saves the original
-// value of a variable when a state_saver is constructed and restores
-// upon destruction.  Useful for being sure that state is restored to
-// variables upon exit from scope.
-
-
-#include <boost/config.hpp>
-#ifndef BOOST_NO_EXCEPTIONS
-    #include <exception>
-#endif
-
-#include <boost/call_traits.hpp>
-#include <boost/noncopyable.hpp>
-#include <boost/type_traits/has_nothrow_copy.hpp>
-#include <boost/core/no_exceptions_support.hpp>
-
-#include <boost/mpl/eval_if.hpp>
-#include <boost/mpl/identity.hpp>
-
-namespace boost {
-namespace serialization {
-
-template<class T>
-// T requirements:
-//  - POD or object semantic (cannot be reference, function, ...)
-//  - copy constructor
-//  - operator = (no-throw one preferred)
-class state_saver : private boost::noncopyable
-{
-private:
-    const T previous_value;
-    T & previous_ref;
-
-    struct restore {
-        static void invoke(T & previous_ref, const T & previous_value){
-            previous_ref = previous_value; // won't throw
-        }
-    };
-
-    struct restore_with_exception {
-        static void invoke(T & previous_ref, const T & previous_value){
-            BOOST_TRY{
-                previous_ref = previous_value;
-            } 
-            BOOST_CATCH(::std::exception &) { 
-                // we must ignore it - we are in destructor
-            }
-            BOOST_CATCH_END
-        }
-    };
-
-public:
-    state_saver(
-        T & object
-    ) : 
-        previous_value(object),
-        previous_ref(object) 
-    {}
-    
-    ~state_saver() {
-        #ifndef BOOST_NO_EXCEPTIONS
-            typedef typename mpl::eval_if<
-                has_nothrow_copy< T >,
-                mpl::identity<restore>,
-                mpl::identity<restore_with_exception>
-            >::type typex;
-            typex::invoke(previous_ref, previous_value);
-        #else
-            previous_ref = previous_value;
-        #endif
-    }
-
-}; // state_saver<>
-
-} // serialization
-} // boost
-
-#endif //BOOST_SERIALIZATION_STATE_SAVER_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/static_warning.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/static_warning.hpp
deleted file mode 100644
index 1d9238fc4d9..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/static_warning.hpp
+++ /dev/null
@@ -1,103 +0,0 @@
-#ifndef BOOST_SERIALIZATION_STATIC_WARNING_HPP
-#define BOOST_SERIALIZATION_STATIC_WARNING_HPP
-
-//  (C) Copyright Robert Ramey 2003. Jonathan Turkanis 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
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-// http://www.boost.org/LICENSE_1_0.txt)
-
-//  See http://www.boost.org/libs/static_assert for documentation.
-
-/*
- Revision history:
-   15 June  2003 - Initial version.
-   31 March 2004 - improved diagnostic messages and portability 
-                   (Jonathan Turkanis)
-   03 April 2004 - works on VC6 at class and namespace scope
-                 - ported to DigitalMars
-                 - static warnings disabled by default; when enabled,
-                   uses pragmas to enable required compiler warnings
-                   on MSVC, Intel, Metrowerks and Borland 5.x.
-                   (Jonathan Turkanis)
-   30 May 2004   - tweaked for msvc 7.1 and gcc 3.3
-                 - static warnings ENabled by default; when enabled,
-                   (Robert Ramey)
-*/
-
-#include <boost/config.hpp>
-
-//
-// Implementation
-// Makes use of the following warnings:
-//  1. GCC prior to 3.3: division by zero.
-//  2. BCC 6.0 preview: unreferenced local variable.
-//  3. DigitalMars: returning address of local automatic variable.
-//  4. VC6: class previously seen as struct (as in 'boost/mpl/print.hpp')
-//  5. All others: deletion of pointer to incomplete type.
-//
-// The trick is to find code which produces warnings containing the name of
-// a structure or variable. Details, with same numbering as above:
-// 1. static_warning_impl<B>::value is zero iff B is false, so diving an int
-//    by this value generates a warning iff B is false.
-// 2. static_warning_impl<B>::type has a constructor iff B is true, so an
-//    unreferenced variable of this type generates a warning iff B is false.
-// 3. static_warning_impl<B>::type overloads operator& to return a dynamically
-//    allocated int pointer only is B is true, so  returning the address of an
-//    automatic variable of this type generates a warning iff B is fasle.
-// 4. static_warning_impl<B>::STATIC_WARNING is decalred as a struct iff B is 
-//    false. 
-// 5. static_warning_impl<B>::type is incomplete iff B is false, so deleting a
-//    pointer to this type generates a warning iff B is false.
-//
-
-//------------------Enable selected warnings----------------------------------//
-
-// Enable the warnings relied on by BOOST_STATIC_WARNING, where possible.
-
-// 6. replaced implementation with one which depends solely on
-//    mpl::print<>.  The previous one was found to fail for functions
-//    under recent versions of gcc and intel compilers - Robert Ramey
-
-#include <boost/mpl/bool.hpp>
-#include <boost/mpl/print.hpp>
-#include <boost/mpl/eval_if.hpp>
-#include <boost/mpl/bool_fwd.hpp>
-#include <boost/static_assert.hpp>
-
-namespace boost {
-namespace serialization {
-
-template<int L> 
-struct BOOST_SERIALIZATION_STATIC_WARNING_LINE{};
-
-template<bool B, int L>
-struct static_warning_test{
-    typename boost::mpl::eval_if_c<
-        B,
-        boost::mpl::true_,
-        typename boost::mpl::identity<
-            boost::mpl::print<
-                BOOST_SERIALIZATION_STATIC_WARNING_LINE<L>
-            >
-        >
-    >::type type;
-};
-
-template<int i>
-struct BOOST_SERIALIZATION_SS {};
-
-} // serialization
-} // boost
-
-#define BOOST_SERIALIZATION_BSW(B, L) \
-    typedef boost::serialization::BOOST_SERIALIZATION_SS< \
-        sizeof( boost::serialization::static_warning_test< B, L > ) \
-    > BOOST_JOIN(STATIC_WARNING_LINE, L) BOOST_ATTRIBUTE_UNUSED; 
-#define BOOST_STATIC_WARNING(B) BOOST_SERIALIZATION_BSW(B, __LINE__)
-
-#endif // BOOST_SERIALIZATION_STATIC_WARNING_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/string.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/string.hpp
deleted file mode 100644
index 76e695d4f3c..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/string.hpp
+++ /dev/null
@@ -1,30 +0,0 @@
-#ifndef  BOOST_SERIALIZATION_STRING_HPP
-#define BOOST_SERIALIZATION_STRING_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// serialization/string.hpp:
-// serialization for stl string templates
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <string>
-
-#include <boost/config.hpp>
-#include <boost/serialization/level.hpp>
-
-BOOST_CLASS_IMPLEMENTATION(std::string, boost::serialization::primitive_type)
-#ifndef BOOST_NO_STD_WSTRING
-BOOST_CLASS_IMPLEMENTATION(std::wstring, boost::serialization::primitive_type)
-#endif
-
-#endif // BOOST_SERIALIZATION_STRING_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/strong_typedef.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/strong_typedef.hpp
deleted file mode 100644
index fdd1b24c9cb..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/strong_typedef.hpp
+++ /dev/null
@@ -1,50 +0,0 @@
-#ifndef BOOST_SERIALIZATION_STRONG_TYPEDEF_HPP
-#define BOOST_SERIALIZATION_STRONG_TYPEDEF_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// strong_typedef.hpp:
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// (C) Copyright 2016 Ashish Sadanandan
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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/serialization for updates, documentation, and revision history.
-
-// macro used to implement a strong typedef.  strong typedef
-// guarentees that two types are distinguised even though the
-// share the same underlying implementation.  typedef does not create
-// a new type.  BOOST_STRONG_TYPEDEF(T, D) creates a new type named D
-// that operates as a type T.
-
-#include <boost/config.hpp>
-#include <boost/operators.hpp>
-#include <boost/type_traits/has_nothrow_assign.hpp>
-#include <boost/type_traits/has_nothrow_constructor.hpp>
-#include <boost/type_traits/has_nothrow_copy.hpp>
-
-#define BOOST_STRONG_TYPEDEF(T, D)                                                                               \
-struct D                                                                                                         \
-    : boost::totally_ordered1< D                                                                                 \
-    , boost::totally_ordered2< D, T                                                                              \
-    > >                                                                                                          \
-{                                                                                                                \
-    T t;                                                                                                         \
-    explicit D(const T& t_) BOOST_NOEXCEPT_IF(boost::has_nothrow_copy_constructor<T>::value) : t(t_) {}          \
-    D() BOOST_NOEXCEPT_IF(boost::has_nothrow_default_constructor<T>::value) : t() {}                             \
-    D(const D & t_) BOOST_NOEXCEPT_IF(boost::has_nothrow_copy_constructor<T>::value) : t(t_.t) {}                \
-    D& operator=(const D& rhs) BOOST_NOEXCEPT_IF(boost::has_nothrow_assign<T>::value) {t = rhs.t; return *this;} \
-    D& operator=(const T& rhs) BOOST_NOEXCEPT_IF(boost::has_nothrow_assign<T>::value) {t = rhs; return *this;}   \
-    operator const T&() const {return t;}                                                                        \
-    operator T&() {return t;}                                                                                    \
-    bool operator==(const D& rhs) const {return t == rhs.t;}                                                     \
-    bool operator<(const D& rhs) const {return t < rhs.t;}                                                       \
-};
-
-#endif // BOOST_SERIALIZATION_STRONG_TYPEDEF_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/throw_exception.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/throw_exception.hpp
deleted file mode 100644
index b67618adc92..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/throw_exception.hpp
+++ /dev/null
@@ -1,44 +0,0 @@
-#ifndef BOOST_SERIALIZATION_THROW_EXCEPTION_HPP_INCLUDED
-#define BOOST_SERIALIZATION_THROW_EXCEPTION_HPP_INCLUDED
-
-// MS compatible compilers support #pragma once
-
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-//  boost/throw_exception.hpp
-//
-//  Copyright (c) 2002 Peter Dimov and Multi Media Ltd.
-//
-// Distributed under the 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>
-
-#ifndef BOOST_NO_EXCEPTIONS
-#include <exception>
-#endif
-
-namespace boost {
-namespace serialization {
-
-#ifdef BOOST_NO_EXCEPTIONS
-
-inline void throw_exception(std::exception const & e) {
-    ::boost::throw_exception(e);
-}
-
-#else
-
-template<class E> inline void throw_exception(E const & e){
-    throw e;
-}
-
-#endif
-
-} // namespace serialization
-} // namespace boost
-
-#endif // #ifndef BOOST_SERIALIZATION_THROW_EXCEPTION_HPP_INCLUDED
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/tracking.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/tracking.hpp
deleted file mode 100644
index d5c79b8409d..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/tracking.hpp
+++ /dev/null
@@ -1,118 +0,0 @@
-#ifndef BOOST_SERIALIZATION_TRACKING_HPP
-#define BOOST_SERIALIZATION_TRACKING_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// tracking.hpp:
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/config.hpp>
-#include <boost/static_assert.hpp>
-#include <boost/mpl/eval_if.hpp>
-#include <boost/mpl/identity.hpp>
-#include <boost/mpl/int.hpp>
-#include <boost/mpl/equal_to.hpp>
-#include <boost/mpl/greater.hpp>
-#include <boost/mpl/integral_c_tag.hpp>
-
-#include <boost/type_traits/is_base_and_derived.hpp>
-#include <boost/type_traits/is_pointer.hpp>
-#include <boost/serialization/level.hpp>
-#include <boost/serialization/tracking_enum.hpp>
-#include <boost/serialization/type_info_implementation.hpp>
-
-namespace boost {
-namespace serialization {
-
-struct basic_traits;
-
-// default tracking level
-template<class T>
-struct tracking_level_impl {
-    template<class U>
-    struct traits_class_tracking {
-        typedef typename U::tracking type;
-    };
-    typedef mpl::integral_c_tag tag;
-    // note: at least one compiler complained w/o the full qualification
-    // on basic traits below
-    typedef
-        typename mpl::eval_if<
-            is_base_and_derived<boost::serialization::basic_traits, T>,
-            traits_class_tracking< T >,
-        //else
-        typename mpl::eval_if<
-            is_pointer< T >,
-            // pointers are not tracked by default
-            mpl::int_<track_never>,
-        //else
-        typename mpl::eval_if<
-            // for primitives
-            typename mpl::equal_to<
-                implementation_level< T >,
-                mpl::int_<primitive_type> 
-            >,
-            // is never
-            mpl::int_<track_never>,
-            // otherwise its selective
-            mpl::int_<track_selectively>
-    >  > >::type type;
-    BOOST_STATIC_CONSTANT(int, value = type::value);
-};
-
-template<class T>
-struct tracking_level : 
-    public tracking_level_impl<const T>
-{
-};
-
-template<class T, enum tracking_type L>
-inline bool operator>=(tracking_level< T > t, enum tracking_type l)
-{
-    return t.value >= (int)l;
-}
-
-} // namespace serialization
-} // namespace boost
-
-
-// The STATIC_ASSERT is prevents one from setting tracking for a primitive type.  
-// This almost HAS to be an error.  Doing this will effect serialization of all 
-// char's in your program which is almost certainly what you don't want to do.  
-// If you want to track all instances of a given primitive type, You'll have to 
-// wrap it in your own type so its not a primitive anymore.  Then it will compile
-// without problem.
-#define BOOST_CLASS_TRACKING(T, E)           \
-namespace boost {                            \
-namespace serialization {                    \
-template<>                                   \
-struct tracking_level< T >                   \
-{                                            \
-    typedef mpl::integral_c_tag tag;         \
-    typedef mpl::int_< E> type;              \
-    BOOST_STATIC_CONSTANT(                   \
-        int,                                 \
-        value = tracking_level::type::value  \
-    );                                       \
-    /* tracking for a class  */              \
-    BOOST_STATIC_ASSERT((                    \
-        mpl::greater<                        \
-            /* that is a prmitive */         \
-            implementation_level< T >,       \
-            mpl::int_<primitive_type>        \
-        >::value                             \
-    ));                                      \
-};                                           \
-}}
-
-#endif // BOOST_SERIALIZATION_TRACKING_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/tracking_enum.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/tracking_enum.hpp
deleted file mode 100644
index 278051e1baf..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/tracking_enum.hpp
+++ /dev/null
@@ -1,41 +0,0 @@
-#ifndef BOOST_SERIALIZATION_TRACKING_ENUM_HPP
-#define BOOST_SERIALIZATION_TRACKING_ENUM_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// tracking_enum.hpp:
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-namespace boost {
-namespace serialization {
-
-// addresses of serialized objects may be tracked to avoid saving/loading
-// redundant copies.  This header defines a class trait that can be used
-// to specify when objects should be tracked
-
-// names for each tracking level
-enum tracking_type
-{
-    // never track this type
-    track_never = 0,
-    // track objects of this type if the object is serialized through a 
-    // pointer.
-    track_selectively = 1,
-    // always track this type
-    track_always = 2
-};
-
-} // namespace serialization
-} // namespace boost
-
-#endif // BOOST_SERIALIZATION_TRACKING_ENUM_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/traits.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/traits.hpp
deleted file mode 100644
index 9e114fdd3df..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/traits.hpp
+++ /dev/null
@@ -1,65 +0,0 @@
-#ifndef BOOST_SERIALIZATION_TRAITS_HPP
-#define BOOST_SERIALIZATION_TRAITS_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// traits.hpp:
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-// This header is used to apply serialization traits to templates.  The
-// standard system can't be used for platforms which don't support
-// Partial Templlate Specialization.  
-
-// The motivation for this is the Name-Value Pair (NVP) template.
-// it has to work the same on all platforms in order for archives
-// to be portable accross platforms.
-
-#include <boost/config.hpp>
-#include <boost/static_assert.hpp>
-
-#include <boost/mpl/int.hpp>
-#include <boost/mpl/bool_fwd.hpp>
-#include <boost/serialization/level_enum.hpp>
-#include <boost/serialization/tracking_enum.hpp>
-
-namespace boost {
-namespace serialization {
-
-// common base class used to detect appended traits class
-struct basic_traits {};
-
-template <class T>
-struct extended_type_info_impl;
-
-template<
-    class T, 
-    int Level, 
-    int Tracking,
-    unsigned int Version = 0,
-    class ETII = extended_type_info_impl< T >,
-    class Wrapper = mpl::false_
->
-struct traits : public basic_traits {
-    BOOST_STATIC_ASSERT(Version == 0 || Level >= object_class_info);
-    BOOST_STATIC_ASSERT(Tracking == track_never || Level >= object_serializable);
-    typedef typename mpl::int_<Level> level;
-    typedef typename mpl::int_<Tracking> tracking;
-    typedef typename mpl::int_<Version> version;
-    typedef ETII type_info_implementation;
-    typedef Wrapper is_wrapper;
-};
-
-} // namespace serialization
-} // namespace boost
-
-#endif // BOOST_SERIALIZATION_TRAITS_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/type_info_implementation.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/type_info_implementation.hpp
deleted file mode 100644
index 24637a8dbb3..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/type_info_implementation.hpp
+++ /dev/null
@@ -1,73 +0,0 @@
-#ifndef BOOST_SERIALIZATION_TYPE_INFO_IMPLEMENTATION_HPP
-#define BOOST_SERIALIZATION_TYPE_INFO_IMPLEMENTATION_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// type_info_implementation.hpp: interface for portable version of type_info
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-
-#include <boost/config.hpp>
-#include <boost/detail/workaround.hpp>
-
-#include <boost/static_assert.hpp>
-#include <boost/mpl/eval_if.hpp>
-#include <boost/mpl/identity.hpp>
-#include <boost/type_traits/is_base_and_derived.hpp>
-#include <boost/serialization/traits.hpp>
-
-namespace boost {
-namespace serialization {
-
-// note that T and const T are folded into const T so that
-// there is only one table entry per type
-template<class T>
-struct type_info_implementation {
-    template<class U>
-    struct traits_class_typeinfo_implementation {
-      typedef typename U::type_info_implementation::type type;
-    };
-    // note: at least one compiler complained w/o the full qualification
-    // on basic traits below
-    typedef 
-        typename mpl::eval_if<
-            is_base_and_derived<boost::serialization::basic_traits, T>,
-            traits_class_typeinfo_implementation< T >,
-        //else
-            mpl::identity<
-                typename extended_type_info_impl< T >::type
-            >
-        >::type type;
-};
-
-} // namespace serialization
-} // namespace boost
-
-// define a macro to assign a particular derivation of extended_type_info
-// to a specified a class. 
-#define BOOST_CLASS_TYPE_INFO(T, ETI)              \
-namespace boost {                                  \
-namespace serialization {                          \
-template<>                                         \
-struct type_info_implementation< T > {             \
-    typedef ETI type;                              \
-};                                                 \
-template<>                                         \
-struct type_info_implementation< const T > {       \
-    typedef ETI type;                              \
-};                                                 \
-}                                                  \
-}                                                  \
-/**/
-
-#endif /// BOOST_SERIALIZATION_TYPE_INFO_IMPLEMENTATION_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/unique_ptr.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/unique_ptr.hpp
deleted file mode 100644
index 8d8703ef4f7..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/unique_ptr.hpp
+++ /dev/null
@@ -1,68 +0,0 @@
-#ifndef  BOOST_SERIALIZATION_UNIQUE_PTR_HPP
-#define BOOST_SERIALIZATION_UNIQUE_PTR_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// unique_ptr.hpp:
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-#include <memory>
-#include <boost/serialization/split_free.hpp>
-#include <boost/serialization/nvp.hpp>
-
-namespace boost {
-namespace serialization {
-
-/////////////////////////////////////////////////////////////
-// implement serialization for unique_ptr< T >
-// note: this must be added to the boost namespace in order to
-// be called by the library
-template<class Archive, class T>
-inline void save(
-    Archive & ar,
-    const std::unique_ptr< T > &t,
-    const unsigned int /*file_version*/
-){
-    // only the raw pointer has to be saved
-    // the ref count is rebuilt automatically on load
-    const T * const tx = t.get();
-    ar << BOOST_SERIALIZATION_NVP(tx);
-}
-
-template<class Archive, class T>
-inline void load(
-    Archive & ar,
-    std::unique_ptr< T > &t,
-    const unsigned int /*file_version*/
-){
-    T *tx;
-    ar >> BOOST_SERIALIZATION_NVP(tx);
-    // note that the reset automagically maintains the reference count
-    t.reset(tx);
-}
-
-// split non-intrusive serialization function member into separate
-// non intrusive save/load member functions
-template<class Archive, class T>
-inline void serialize(
-    Archive & ar,
-    std::unique_ptr< T > &t,
-    const unsigned int file_version
-){
-    boost::serialization::split_free(ar, t, file_version);
-}
-
-} // namespace serialization
-} // namespace boost
-
-
-#endif // BOOST_SERIALIZATION_UNIQUE_PTR_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/unordered_collections_load_imp.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/unordered_collections_load_imp.hpp
deleted file mode 100644
index d56a423d180..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/unordered_collections_load_imp.hpp
+++ /dev/null
@@ -1,73 +0,0 @@
-#ifndef BOOST_SERIALIZATION_UNORDERED_COLLECTIONS_LOAD_IMP_HPP
-#define BOOST_SERIALIZATION_UNORDERED_COLLECTIONS_LOAD_IMP_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-# pragma warning (disable : 4786) // too long name, harmless warning
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// unordered_collections_load_imp.hpp: serialization for loading stl collections
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// (C) Copyright 2014 Jim Bell
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-// helper function templates for serialization of collections
-
-#include <boost/assert.hpp>
-#include <cstddef> // size_t
-#include <boost/config.hpp> // msvc 6.0 needs this for warning suppression
-#if defined(BOOST_NO_STDC_NAMESPACE)
-namespace std{ 
-    using ::size_t; 
-} // namespace std
-#endif
-#include <boost/detail/workaround.hpp>
-
-#include <boost/archive/detail/basic_iarchive.hpp>
-#include <boost/serialization/access.hpp>
-#include <boost/serialization/nvp.hpp>
-#include <boost/serialization/collection_size_type.hpp>
-#include <boost/serialization/item_version_type.hpp>
-
-namespace boost{
-namespace serialization {
-namespace stl {
-
-//////////////////////////////////////////////////////////////////////
-// implementation of serialization for STL containers
-//
-template<class Archive, class Container, class InputFunction>
-inline void load_unordered_collection(Archive & ar, Container &s)
-{
-    collection_size_type count;
-    collection_size_type bucket_count;
-    boost::serialization::item_version_type item_version(0);
-    boost::archive::library_version_type library_version(
-        ar.get_library_version()
-    );
-    // retrieve number of elements
-    ar >> BOOST_SERIALIZATION_NVP(count);
-    ar >> BOOST_SERIALIZATION_NVP(bucket_count);
-    if(boost::archive::library_version_type(3) < library_version){
-        ar >> BOOST_SERIALIZATION_NVP(item_version);
-    }
-    s.clear();
-    s.rehash(bucket_count);
-    InputFunction ifunc;
-    while(count-- > 0){
-        ifunc(ar, s, item_version);
-    }
-}
-
-} // namespace stl 
-} // namespace serialization
-} // namespace boost
-
-#endif //BOOST_SERIALIZATION_UNORDERED_COLLECTIONS_LOAD_IMP_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/unordered_collections_save_imp.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/unordered_collections_save_imp.hpp
deleted file mode 100644
index 56746ebeaa3..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/unordered_collections_save_imp.hpp
+++ /dev/null
@@ -1,86 +0,0 @@
-#ifndef BOOST_SERIALIZATION_UNORDERED_COLLECTIONS_SAVE_IMP_HPP
-#define BOOST_SERIALIZATION_UNORDERED_COLLECTIONS_SAVE_IMP_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// hash_collections_save_imp.hpp: serialization for stl collections
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// (C) Copyright 2014 Jim Bell
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-// helper function templates for serialization of collections
-
-#include <boost/config.hpp>
-#include <boost/serialization/nvp.hpp>
-#include <boost/serialization/serialization.hpp>
-#include <boost/serialization/version.hpp>
-#include <boost/serialization/collection_size_type.hpp>
-#include <boost/serialization/item_version_type.hpp>
-
-namespace boost{
-namespace serialization {
-namespace stl {
-
-//////////////////////////////////////////////////////////////////////
-// implementation of serialization for STL containers
-//
-
-template<class Archive, class Container>
-inline void save_unordered_collection(Archive & ar, const Container &s)
-{
-    collection_size_type count(s.size());
-    const collection_size_type bucket_count(s.bucket_count());
-    const item_version_type item_version(
-        version<typename Container::value_type>::value
-    );
-
-    #if 0
-    /* should only be necessary to create archives of previous versions
-     * which is not currently supported.  So for now comment this out
-     */
-    boost::archive::library_version_type library_version(
-        ar.get_library_version()
-    );
-    // retrieve number of elements
-	ar << BOOST_SERIALIZATION_NVP(count);
-	ar << BOOST_SERIALIZATION_NVP(bucket_count);
-    if(boost::archive::library_version_type(3) < library_version){
-        // record number of elements
-        // make sure the target type is registered so we can retrieve
-        // the version when we load
-        ar << BOOST_SERIALIZATION_NVP(item_version);
-    }
-    #else
-        ar << BOOST_SERIALIZATION_NVP(count);
-        ar << BOOST_SERIALIZATION_NVP(bucket_count);
-        ar << BOOST_SERIALIZATION_NVP(item_version);
-    #endif
-
-    typename Container::const_iterator it = s.begin();
-    while(count-- > 0){
-        // note borland emits a no-op without the explicit namespace
-        boost::serialization::save_construct_data_adl(
-            ar, 
-            &(*it), 
-            boost::serialization::version<
-                typename Container::value_type
-            >::value
-        );
-        ar << boost::serialization::make_nvp("item", *it++);
-    }
-}
-
-} // namespace stl 
-} // namespace serialization
-} // namespace boost
-
-#endif //BOOST_SERIALIZATION_UNORDERED_COLLECTIONS_SAVE_IMP_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/unordered_map.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/unordered_map.hpp
deleted file mode 100644
index 4fdbddd7b65..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/unordered_map.hpp
+++ /dev/null
@@ -1,160 +0,0 @@
-#ifndef  BOOST_SERIALIZATION_UNORDERED_MAP_HPP
-#define BOOST_SERIALIZATION_UNORDERED_MAP_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// serialization/unordered_map.hpp:
-// serialization for stl unordered_map templates
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// (C) Copyright 2014 Jim Bell
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/config.hpp>
-
-#include <unordered_map>
-
-#include <boost/serialization/utility.hpp>
-#include <boost/serialization/unordered_collections_save_imp.hpp>
-#include <boost/serialization/unordered_collections_load_imp.hpp>
-#include <boost/serialization/archive_input_unordered_map.hpp>
-#include <boost/serialization/split_free.hpp>
-
-namespace boost { 
-namespace serialization {
-
-template<
-    class Archive, 
-    class Key, 
-    class HashFcn, 
-    class EqualKey,
-    class Allocator
->
-inline void save(
-    Archive & ar,
-    const std::unordered_map<Key, HashFcn, EqualKey, Allocator> &t,
-    const unsigned int /*file_version*/
-){
-    boost::serialization::stl::save_unordered_collection<
-        Archive, 
-        std::unordered_map<Key, HashFcn, EqualKey, Allocator>
-    >(ar, t);
-}
-
-template<
-    class Archive, 
-    class Key, 
-    class HashFcn, 
-    class EqualKey,
-    class Allocator
->
-inline void load(
-    Archive & ar,
-    std::unordered_map<Key, HashFcn, EqualKey, Allocator> &t,
-    const unsigned int /*file_version*/
-){
-    boost::serialization::stl::load_unordered_collection<
-        Archive,
-        std::unordered_map<Key, HashFcn, EqualKey, Allocator>,
-        boost::serialization::stl::archive_input_unordered_map<
-            Archive, 
-            std::unordered_map<Key, HashFcn, EqualKey, Allocator>
-        >
-    >(ar, t);
-}
-
-// split non-intrusive serialization function member into separate
-// non intrusive save/load member functions
-template<
-    class Archive, 
-    class Key, 
-    class HashFcn, 
-    class EqualKey,
-    class Allocator
->
-inline void serialize(
-    Archive & ar,
-    std::unordered_map<Key, HashFcn, EqualKey, Allocator> &t,
-    const unsigned int file_version
-){
-    boost::serialization::split_free(ar, t, file_version);
-}
-
-// unordered_multimap
-template<
-    class Archive, 
-    class Key, 
-    class HashFcn, 
-    class EqualKey,
-    class Allocator
->
-inline void save(
-    Archive & ar,
-    const std::unordered_multimap<
-        Key, HashFcn, EqualKey, Allocator
-    > &t,
-    const unsigned int /*file_version*/
-){
-    boost::serialization::stl::save_unordered_collection<
-        Archive, 
-        std::unordered_multimap<Key, HashFcn, EqualKey, Allocator>
-    >(ar, t);
-}
-
-template<
-    class Archive, 
-    class Key, 
-    class HashFcn, 
-    class EqualKey,
-    class Allocator
->
-inline void load(
-    Archive & ar,
-    std::unordered_multimap<
-        Key, HashFcn, EqualKey, Allocator
-    > &t,
-    const unsigned int /*file_version*/
-){
-    boost::serialization::stl::load_unordered_collection<
-        Archive,
-        std::unordered_multimap<
-            Key, HashFcn, EqualKey, Allocator
-        >,
-        boost::serialization::stl::archive_input_unordered_multimap<
-            Archive, 
-            std::unordered_multimap<Key, HashFcn, EqualKey, Allocator>
-        >
-    >(ar, t);
-}
-
-// split non-intrusive serialization function member into separate
-// non intrusive save/load member functions
-template<
-    class Archive, 
-    class Key, 
-    class HashFcn, 
-    class EqualKey,
-    class Allocator
->
-inline void serialize(
-    Archive & ar,
-    std::unordered_multimap<
-        Key, HashFcn, EqualKey, Allocator
-    > &t,
-    const unsigned int file_version
-){
-    boost::serialization::split_free(ar, t, file_version);
-}
-
-} // namespace serialization
-} // namespace boost
-
-#endif // BOOST_SERIALIZATION_UNORDERED_MAP_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/unordered_set.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/unordered_set.hpp
deleted file mode 100644
index adfee609cbe..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/unordered_set.hpp
+++ /dev/null
@@ -1,162 +0,0 @@
-#ifndef  BOOST_SERIALIZATION_UNORDERED_SET_HPP
-#define BOOST_SERIALIZATION_UNORDERED_SET_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// unordered_set.hpp: serialization for stl unordered_set templates
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// (C) Copyright 2014 Jim Bell
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/config.hpp>
-
-#include <unordered_set>
-
-#include <boost/serialization/unordered_collections_save_imp.hpp>
-#include <boost/serialization/unordered_collections_load_imp.hpp>
-#include <boost/serialization/archive_input_unordered_set.hpp>
-#include <boost/serialization/split_free.hpp>
-
-namespace boost { 
-namespace serialization {
-
-template<
-    class Archive, 
-    class Key, 
-    class HashFcn, 
-    class EqualKey,
-    class Allocator
->
-inline void save(
-    Archive & ar,
-    const std::unordered_set<
-        Key, HashFcn, EqualKey, Allocator
-    > &t,
-    const unsigned int /*file_version*/
-){
-    boost::serialization::stl::save_unordered_collection<
-        Archive, 
-        std::unordered_set<Key, HashFcn, EqualKey, Allocator>
-    >(ar, t);
-}
-
-template<
-    class Archive, 
-    class Key, 
-    class HashFcn, 
-    class EqualKey,
-    class Allocator
->
-inline void load(
-    Archive & ar,
-    std::unordered_set<
-        Key, HashFcn, EqualKey, Allocator
-    > &t,
-    const unsigned int /*file_version*/
-){
-    boost::serialization::stl::load_unordered_collection<
-        Archive,
-        std::unordered_set<Key, HashFcn, EqualKey, Allocator>,
-        stl::archive_input_unordered_set<
-            Archive, 
-            std::unordered_set<
-                Key, HashFcn, EqualKey, Allocator
-            >
-        >
-    >(ar, t);
-}
-
-// split non-intrusive serialization function member into separate
-// non intrusive save/load member functions
-template<
-    class Archive, 
-    class Key, 
-    class HashFcn, 
-    class EqualKey,
-    class Allocator
->
-inline void serialize(
-    Archive & ar,
-    std::unordered_set<
-        Key, HashFcn, EqualKey, Allocator
-    > &t,
-    const unsigned int file_version
-){
-    split_free(ar, t, file_version);
-}
-
-// unordered_multiset
-template<
-    class Archive, 
-    class Key, 
-    class HashFcn, 
-    class EqualKey,
-    class Allocator
->
-inline void save(
-    Archive & ar,
-    const std::unordered_multiset<
-        Key, HashFcn, EqualKey, Allocator
-    > &t,
-    const unsigned int /*file_version*/
-){
-    stl::save_unordered_collection<
-        Archive, 
-        std::unordered_multiset<Key, HashFcn, EqualKey, Allocator>
-    >(ar, t);
-}
-
-template<
-    class Archive, 
-    class Key, 
-    class HashFcn, 
-    class EqualKey,
-    class Allocator
->
-inline void load(
-    Archive & ar,
-    std::unordered_multiset<
-        Key, HashFcn, EqualKey, Allocator
-    > &t,
-    const unsigned int /*file_version*/
-){
-    boost::serialization::stl::load_unordered_collection<
-        Archive,
-        std::unordered_multiset<Key, HashFcn, EqualKey, Allocator>,
-        boost::serialization::stl::archive_input_unordered_multiset<
-            Archive,
-            std::unordered_multiset<Key, HashFcn, EqualKey, Allocator>
-        >
-    >(ar, t);
-}
-
-// split non-intrusive serialization function member into separate
-// non intrusive save/load member functions
-template<
-    class Archive, 
-    class Key, 
-    class HashFcn, 
-    class EqualKey,
-    class Allocator
->
-inline void serialize(
-    Archive & ar,
-    std::unordered_multiset<Key, HashFcn, EqualKey, Allocator> &t,
-    const unsigned int file_version
-){
-    boost::serialization::split_free(ar, t, file_version);
-}
-
-} // namespace serialization
-} // namespace boost
-
-#endif // BOOST_SERIALIZATION_UNORDERED_SET_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/utility.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/utility.hpp
deleted file mode 100644
index 4867a4a12d2..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/utility.hpp
+++ /dev/null
@@ -1,56 +0,0 @@
-#ifndef  BOOST_SERIALIZATION_UTILITY_HPP
-#define BOOST_SERIALIZATION_UTILITY_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// serialization/utility.hpp:
-// serialization for stl utility templates
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <utility>
-#include <boost/config.hpp>
-
-#include <boost/type_traits/remove_const.hpp>
-#include <boost/serialization/nvp.hpp>
-#include <boost/serialization/is_bitwise_serializable.hpp>
-#include <boost/mpl/and.hpp>
-
-namespace boost { 
-namespace serialization {
-
-// pair
-template<class Archive, class F, class S>
-inline void serialize(
-    Archive & ar,
-    std::pair<F, S> & p,
-    const unsigned int /* file_version */
-){
-    // note: we remove any const-ness on the first argument.  The reason is that 
-    // for stl maps, the type saved is pair<const key, T).  We remove
-    // the const-ness in order to be able to load it.
-    typedef typename boost::remove_const<F>::type typef;
-    ar & boost::serialization::make_nvp("first", const_cast<typef &>(p.first));
-    ar & boost::serialization::make_nvp("second", p.second);
-}
-
-/// specialization of is_bitwise_serializable for pairs
-template <class T, class U>
-struct is_bitwise_serializable<std::pair<T,U> >
- : public mpl::and_<is_bitwise_serializable< T >,is_bitwise_serializable<U> >
-{
-};
-
-} // serialization
-} // namespace boost
-
-#endif // BOOST_SERIALIZATION_UTILITY_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/valarray.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/valarray.hpp
deleted file mode 100644
index 9eece5c1737..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/valarray.hpp
+++ /dev/null
@@ -1,86 +0,0 @@
-#ifndef BOOST_SERIALIZATION_VALARAY_HPP
-#define BOOST_SERIALIZATION_VALARAY_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// valarray.hpp: serialization for stl vector templates
-
-// (C) Copyright 2005 Matthias Troyer . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <valarray>
-#include <boost/config.hpp>
-
-#include <boost/serialization/collections_save_imp.hpp>
-#include <boost/serialization/collections_load_imp.hpp>
-#include <boost/serialization/split_free.hpp>
-#include <boost/serialization/collection_size_type.hpp>
-#include <boost/serialization/array_wrapper.hpp>
-
-// function specializations must be defined in the appropriate
-// namespace - boost::serialization
-#if defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION)
-#define STD _STLP_STD
-#else
-#define STD std
-#endif
-
-namespace boost { 
-namespace serialization {
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// valarray< T >
-
-template<class Archive, class U>
-void save( Archive & ar, const STD::valarray<U> &t, const unsigned int /*file_version*/ )
-{
-    const collection_size_type count(t.size());
-    ar << BOOST_SERIALIZATION_NVP(count);
-    if (t.size()){
-        // explict template arguments to pass intel C++ compiler
-        ar << serialization::make_array<const U, collection_size_type>(
-            static_cast<const U *>(&t[0]),
-            count
-        );
-    }
-}
-
-template<class Archive, class U>
-void load( Archive & ar, STD::valarray<U> &t,  const unsigned int /*file_version*/ )
-{
-    collection_size_type count;
-    ar >> BOOST_SERIALIZATION_NVP(count);
-    t.resize(count);
-    if (t.size()){
-        // explict template arguments to pass intel C++ compiler
-        ar >> serialization::make_array<U, collection_size_type>(
-            static_cast<U *>(&t[0]),
-            count
-        );
-    }
-}
-
-// split non-intrusive serialization function member into separate
-// non intrusive save/load member functions
-template<class Archive, class U>
-inline void serialize( Archive & ar, STD::valarray<U> & t, const unsigned int file_version)
-{
-    boost::serialization::split_free(ar, t, file_version);
-}
-
-} } // end namespace boost::serialization
-
-#include <boost/serialization/collection_traits.hpp>
-
-BOOST_SERIALIZATION_COLLECTION_TRAITS(STD::valarray)
-#undef STD
-
-#endif // BOOST_SERIALIZATION_VALARAY_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/variant.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/variant.hpp
deleted file mode 100644
index dce6f3d49e7..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/variant.hpp
+++ /dev/null
@@ -1,158 +0,0 @@
-#ifndef BOOST_SERIALIZATION_VARIANT_HPP
-#define BOOST_SERIALIZATION_VARIANT_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// variant.hpp - non-intrusive serialization of variant types
-//
-// copyright (c) 2005   
-// troy d. straszheim <troy@resophonic.com>
-// http://www.resophonic.com
-//
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-//
-// thanks to Robert Ramey, Peter Dimov, and Richard Crossley.
-//
-
-#include <boost/mpl/front.hpp>
-#include <boost/mpl/pop_front.hpp>
-#include <boost/mpl/eval_if.hpp>
-#include <boost/mpl/identity.hpp>
-#include <boost/mpl/size.hpp>
-#include <boost/mpl/empty.hpp>
-
-#include <boost/serialization/throw_exception.hpp>
-
-#include <boost/variant.hpp>
-
-#include <boost/archive/archive_exception.hpp>
-
-#include <boost/serialization/split_free.hpp>
-#include <boost/serialization/serialization.hpp>
-#include <boost/serialization/nvp.hpp>
-
-namespace boost {
-namespace serialization {
-
-template<class Archive>
-struct variant_save_visitor : 
-    boost::static_visitor<> 
-{
-    variant_save_visitor(Archive& ar) :
-        m_ar(ar)
-    {}
-    template<class T>
-    void operator()(T const & value) const
-    {
-        m_ar << BOOST_SERIALIZATION_NVP(value);
-    }
-private:
-    Archive & m_ar;
-};
-
-template<class Archive, BOOST_VARIANT_ENUM_PARAMS(/* typename */ class T)>
-void save(
-    Archive & ar,
-    boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> const & v,
-    unsigned int /*version*/
-){
-    int which = v.which();
-    ar << BOOST_SERIALIZATION_NVP(which);
-    variant_save_visitor<Archive> visitor(ar);
-    v.apply_visitor(visitor);
-}
-
-template<class S>
-struct variant_impl {
-
-    struct load_null {
-        template<class Archive, class V>
-        static void invoke(
-            Archive & /*ar*/,
-            int /*which*/,
-            V & /*v*/,
-            const unsigned int /*version*/
-        ){}
-    };
-
-    struct load_impl {
-        template<class Archive, class V>
-        static void invoke(
-            Archive & ar,
-            int which,
-            V & v,
-            const unsigned int version
-        ){
-            if(which == 0){
-                // note: A non-intrusive implementation (such as this one)
-                // necessary has to copy the value.  This wouldn't be necessary
-                // with an implementation that de-serialized to the address of the
-                // aligned storage included in the variant.
-                typedef typename mpl::front<S>::type head_type;
-                head_type value;
-                ar >> BOOST_SERIALIZATION_NVP(value);
-                v = value;
-                ar.reset_object_address(& boost::get<head_type>(v), & value);
-                return;
-            }
-            typedef typename mpl::pop_front<S>::type type;
-            variant_impl<type>::load(ar, which - 1, v, version);
-        }
-    };
-
-    template<class Archive, class V>
-    static void load(
-        Archive & ar,
-        int which,
-        V & v,
-        const unsigned int version
-    ){
-        typedef typename mpl::eval_if<mpl::empty<S>,
-            mpl::identity<load_null>,
-            mpl::identity<load_impl>
-        >::type typex;
-        typex::invoke(ar, which, v, version);
-    }
-
-};
-
-template<class Archive, BOOST_VARIANT_ENUM_PARAMS(/* typename */ class T)>
-void load(
-    Archive & ar, 
-    boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)>& v,
-    const unsigned int version
-){
-    int which;
-    typedef typename boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)>::types types;
-    ar >> BOOST_SERIALIZATION_NVP(which);
-    if(which >=  mpl::size<types>::value)
-        // this might happen if a type was removed from the list of variant types
-        boost::serialization::throw_exception(
-            boost::archive::archive_exception(
-                boost::archive::archive_exception::unsupported_version
-            )
-        );
-    variant_impl<types>::load(ar, which, v, version);
-}
-
-template<class Archive,BOOST_VARIANT_ENUM_PARAMS(/* typename */ class T)>
-inline void serialize(
-    Archive & ar,
-    boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> & v,
-    const unsigned int file_version
-){
-    split_free(ar,v,file_version);
-}
-
-} // namespace serialization
-} // namespace boost
-
-#endif //BOOST_SERIALIZATION_VARIANT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/vector.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/vector.hpp
deleted file mode 100644
index 9a114c00e20..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/vector.hpp
+++ /dev/null
@@ -1,233 +0,0 @@
-#ifndef  BOOST_SERIALIZATION_VECTOR_HPP
-#define BOOST_SERIALIZATION_VECTOR_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// vector.hpp: serialization for stl vector templates
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// fast array serialization (C) Copyright 2005 Matthias Troyer 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <vector>
-
-#include <boost/config.hpp>
-#include <boost/detail/workaround.hpp>
-
-#include <boost/archive/detail/basic_iarchive.hpp>
-#include <boost/serialization/access.hpp>
-#include <boost/serialization/nvp.hpp>
-#include <boost/serialization/collection_size_type.hpp>
-#include <boost/serialization/item_version_type.hpp>
-
-#include <boost/serialization/collections_save_imp.hpp>
-#include <boost/serialization/collections_load_imp.hpp>
-#include <boost/serialization/split_free.hpp>
-#include <boost/serialization/array_wrapper.hpp>
-#include <boost/mpl/bool_fwd.hpp>
-#include <boost/mpl/if.hpp>
-
-// default is being compatible with version 1.34.1 files, not 1.35 files
-#ifndef BOOST_SERIALIZATION_VECTOR_VERSIONED
-#define BOOST_SERIALIZATION_VECTOR_VERSIONED(V) (V==4 || V==5)
-#endif
-
-// function specializations must be defined in the appropriate
-// namespace - boost::serialization
-#if defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION)
-#define STD _STLP_STD
-#else
-#define STD std
-#endif
-
-namespace boost { 
-namespace serialization {
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// vector< T >
-
-// the default versions
-
-template<class Archive, class U, class Allocator>
-inline void save(
-    Archive & ar,
-    const std::vector<U, Allocator> &t,
-    const unsigned int /* file_version */,
-    mpl::false_
-){
-    boost::serialization::stl::save_collection<Archive, STD::vector<U, Allocator> >(
-        ar, t
-    );
-}
-
-template<class Archive, class U, class Allocator>
-inline void load(
-    Archive & ar,
-    std::vector<U, Allocator> &t,
-    const unsigned int /* file_version */,
-    mpl::false_
-){
-    const boost::archive::library_version_type library_version(
-        ar.get_library_version()
-    );
-    // retrieve number of elements
-    item_version_type item_version(0);
-    collection_size_type count;
-    ar >> BOOST_SERIALIZATION_NVP(count);
-    if(boost::archive::library_version_type(3) < library_version){
-        ar >> BOOST_SERIALIZATION_NVP(item_version);
-    }
-    t.reserve(count);
-    stl::collection_load_impl(ar, t, count, item_version);
-}
-
-// the optimized versions
-
-template<class Archive, class U, class Allocator>
-inline void save(
-    Archive & ar,
-    const std::vector<U, Allocator> &t,
-    const unsigned int /* file_version */,
-    mpl::true_
-){
-    const collection_size_type count(t.size());
-    ar << BOOST_SERIALIZATION_NVP(count);
-    if (!t.empty())
-        // explict template arguments to pass intel C++ compiler
-        ar << serialization::make_array<const U, collection_size_type>(
-            static_cast<const U *>(&t[0]),
-            count
-        );
-}
-
-template<class Archive, class U, class Allocator>
-inline void load(
-    Archive & ar,
-    std::vector<U, Allocator> &t,
-    const unsigned int /* file_version */,
-    mpl::true_
-){
-    collection_size_type count(t.size());
-    ar >> BOOST_SERIALIZATION_NVP(count);
-    t.resize(count);
-    unsigned int item_version=0;
-    if(BOOST_SERIALIZATION_VECTOR_VERSIONED(ar.get_library_version())) {
-        ar >> BOOST_SERIALIZATION_NVP(item_version);
-    }
-    if (!t.empty())
-        // explict template arguments to pass intel C++ compiler
-        ar >> serialization::make_array<U, collection_size_type>(
-            static_cast<U *>(&t[0]),
-            count
-        );
-  }
-
-// dispatch to either default or optimized versions
-
-template<class Archive, class U, class Allocator>
-inline void save(
-    Archive & ar,
-    const std::vector<U, Allocator> &t,
-    const unsigned int file_version
-){
-    typedef typename 
-    boost::serialization::use_array_optimization<Archive>::template apply<
-        typename remove_const<U>::type 
-    >::type use_optimized;
-    save(ar,t,file_version, use_optimized());
-}
-
-template<class Archive, class U, class Allocator>
-inline void load(
-    Archive & ar,
-    std::vector<U, Allocator> &t,
-    const unsigned int file_version
-){
-#ifdef BOOST_SERIALIZATION_VECTOR_135_HPP
-    if (ar.get_library_version()==boost::archive::library_version_type(5))
-    {
-      load(ar,t,file_version, boost::is_arithmetic<U>());
-      return;
-    }
-#endif
-    typedef typename 
-    boost::serialization::use_array_optimization<Archive>::template apply<
-        typename remove_const<U>::type 
-    >::type use_optimized;
-    load(ar,t,file_version, use_optimized());
-}
-
-// split non-intrusive serialization function member into separate
-// non intrusive save/load member functions
-template<class Archive, class U, class Allocator>
-inline void serialize(
-    Archive & ar,
-    std::vector<U, Allocator> & t,
-    const unsigned int file_version
-){
-    boost::serialization::split_free(ar, t, file_version);
-}
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// vector<bool>
-template<class Archive, class Allocator>
-inline void save(
-    Archive & ar,
-    const std::vector<bool, Allocator> &t,
-    const unsigned int /* file_version */
-){
-    // record number of elements
-    collection_size_type count (t.size());
-    ar << BOOST_SERIALIZATION_NVP(count);
-    std::vector<bool>::const_iterator it = t.begin();
-    while(count-- > 0){
-        bool tb = *it++;
-        ar << boost::serialization::make_nvp("item", tb);
-    }
-}
-
-template<class Archive, class Allocator>
-inline void load(
-    Archive & ar,
-    std::vector<bool, Allocator> &t,
-    const unsigned int /* file_version */
-){
-    // retrieve number of elements
-    collection_size_type count;
-    ar >> BOOST_SERIALIZATION_NVP(count);
-    t.resize(count);
-    for(collection_size_type i = collection_size_type(0); i < count; ++i){
-        bool b;
-        ar >> boost::serialization::make_nvp("item", b);
-        t[i] = b;
-    }
-}
-
-// split non-intrusive serialization function member into separate
-// non intrusive save/load member functions
-template<class Archive, class Allocator>
-inline void serialize(
-    Archive & ar,
-    std::vector<bool, Allocator> & t,
-    const unsigned int file_version
-){
-    boost::serialization::split_free(ar, t, file_version);
-}
-
-} // serialization
-} // namespace boost
-
-#include <boost/serialization/collection_traits.hpp>
-
-BOOST_SERIALIZATION_COLLECTION_TRAITS(std::vector)
-#undef STD
-
-#endif // BOOST_SERIALIZATION_VECTOR_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/vector_135.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/vector_135.hpp
deleted file mode 100644
index fd1a7393d1b..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/vector_135.hpp
+++ /dev/null
@@ -1,26 +0,0 @@
-////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// vector_135.hpp: serialization for stl vector templates for compatibility
-//                 with release 1.35, which had a bug
-
-// (C) Copyright 2008 Matthias Troyer
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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_SERIALIZATION_VECTOR_135_HPP
-#define BOOST_SERIALIZATION_VECTOR_135_HPP
-
-#ifdef BOOST_SERIALIZATION_VECTOR_VERSIONED
-#if BOOST_SERIALIZATION_VECTOR_VERSION != 4
-#error "Boost.Serialization cannot be compatible with both 1.35 and 1.36-1.40 files"
-#endif
-#else
-#define BOOST_SERIALIZATION_VECTOR_VERSIONED(V) (V>4)
-#endif
-
-#include <boost/serialization/vector.hpp>
-
-#endif // BOOST_SERIALIZATION_VECTOR_135_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/version.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/version.hpp
deleted file mode 100644
index 21a74d73daa..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/version.hpp
+++ /dev/null
@@ -1,107 +0,0 @@
-#ifndef BOOST_SERIALIZATION_VERSION_HPP
-#define BOOST_SERIALIZATION_VERSION_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// version.hpp:
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/config.hpp>
-#include <boost/mpl/assert.hpp>
-#include <boost/mpl/int.hpp>
-#include <boost/mpl/eval_if.hpp>
-#include <boost/mpl/identity.hpp>
-#include <boost/mpl/integral_c_tag.hpp>
-
-#include <boost/type_traits/is_base_and_derived.hpp>
-
-namespace boost { 
-namespace serialization {
-
-struct basic_traits;
-
-// default version number is 0. Override with higher version
-// when class definition changes.
-template<class T>
-struct version
-{
-    template<class U>
-    struct traits_class_version {
-        typedef typename U::version type;
-    };
-
-    typedef mpl::integral_c_tag tag;
-    // note: at least one compiler complained w/o the full qualification
-    // on basic traits below
-    typedef
-        typename mpl::eval_if<
-            is_base_and_derived<boost::serialization::basic_traits,T>,
-            traits_class_version< T >,
-            mpl::int_<0>
-        >::type type;
-    BOOST_STATIC_CONSTANT(int, value = version::type::value);
-};
-
-#ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
-template<class T>
-const int version<T>::value;
-#endif
-
-} // namespace serialization
-} // namespace boost
-
-/* note: at first it seemed that this would be a good place to trap
- * as an error an attempt to set a version # for a class which doesn't
- * save its class information (including version #) in the archive.
- * However, this imposes a requirement that the version be set after
- * the implemention level which would be pretty confusing.  If this
- * is to be done, do this check in the input or output operators when
- * ALL the serialization traits are available.  Included the implementation
- * here with this comment as a reminder not to do this!
- */
-//#include <boost/serialization/level.hpp>
-//#include <boost/mpl/equal_to.hpp>
-
-#include <boost/mpl/less.hpp>
-#include <boost/mpl/comparison.hpp>
-
-// specify the current version number for the class
-// version numbers limited to 8 bits !!!
-#define BOOST_CLASS_VERSION(T, N)                                      \
-namespace boost {                                                      \
-namespace serialization {                                              \
-template<>                                                             \
-struct version<T >                                                     \
-{                                                                      \
-    typedef mpl::int_<N> type;                                         \
-    typedef mpl::integral_c_tag tag;                                   \
-    BOOST_STATIC_CONSTANT(int, value = version::type::value);          \
-    BOOST_MPL_ASSERT((                                                 \
-        boost::mpl::less<                                              \
-            boost::mpl::int_<N>,                                       \
-            boost::mpl::int_<256>                                      \
-        >                                                              \
-    ));                                                                \
-    /*                                                                 \
-    BOOST_MPL_ASSERT((                                                 \
-        mpl::equal_to<                                                 \
-            :implementation_level<T >,                                 \
-            mpl::int_<object_class_info>                               \
-        >::value                                                       \
-    ));                                                                \
-    */                                                                 \
-};                                                                     \
-}                                                                      \
-}
-
-#endif // BOOST_SERIALIZATION_VERSION_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/void_cast.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/void_cast.hpp
deleted file mode 100644
index f1b38286115..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/void_cast.hpp
+++ /dev/null
@@ -1,298 +0,0 @@
-#ifndef  BOOST_SERIALIZATION_VOID_CAST_HPP
-#define BOOST_SERIALIZATION_VOID_CAST_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// void_cast.hpp:   interface for run-time casting of void pointers.
-
-// (C) Copyright 2002-2009 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-// gennadiy.rozental@tfn.com
-
-//  See http://www.boost.org for updates, documentation, and revision history.
-
-#include <cstddef> // for ptrdiff_t
-#include <boost/config.hpp>
-#include <boost/noncopyable.hpp>
-
-#include <boost/serialization/smart_cast.hpp>
-#include <boost/serialization/singleton.hpp>
-#include <boost/serialization/force_include.hpp>
-#include <boost/serialization/type_info_implementation.hpp>
-#include <boost/serialization/extended_type_info.hpp>
-#include <boost/type_traits/is_virtual_base_of.hpp>
-#include <boost/serialization/void_cast_fwd.hpp>
-
-#include <boost/serialization/config.hpp>
-#include <boost/config/abi_prefix.hpp> // must be the last header
-
-#ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable : 4251 4231 4660 4275)
-#endif
-
-namespace boost { 
-namespace serialization { 
-
-class extended_type_info;
-
-// Given a void *, assume that it really points to an instance of one type
-// and alter it so that it would point to an instance of a related type.
-// Return the altered pointer. If there exists no sequence of casts that
-// can transform from_type to to_type, return a NULL.  
-
-BOOST_SERIALIZATION_DECL void const *
-void_upcast(
-    extended_type_info const & derived,  
-    extended_type_info const & base, 
-    void const * const t
-);
-
-inline void *
-void_upcast(
-    extended_type_info const & derived,
-    extended_type_info const & base,
-    void * const t 
-){
-    return const_cast<void*>(void_upcast(
-        derived, 
-        base, 
-        const_cast<void const *>(t)
-    ));
-}
-
-BOOST_SERIALIZATION_DECL void const *
-void_downcast(
-    extended_type_info const & derived,  
-    extended_type_info const & base, 
-    void const * const t
-);
-
-inline void *
-void_downcast(
-    extended_type_info const & derived,
-    extended_type_info const & base,
-    void * const t 
-){
-    return const_cast<void*>(void_downcast(
-        derived, 
-        base, 
-        const_cast<void const *>(t)
-    ));
-}
-
-namespace void_cast_detail {
-
-class BOOST_SYMBOL_VISIBLE void_caster :
-    private boost::noncopyable
-{
-    friend 
-    BOOST_SERIALIZATION_DECL void const *
-    boost::serialization::void_upcast(
-        extended_type_info const & derived,
-        extended_type_info const & base,
-        void const * const
-    );
-    friend 
-    BOOST_SERIALIZATION_DECL void const *
-    boost::serialization::void_downcast(
-        extended_type_info const & derived,
-        extended_type_info const & base,
-        void const * const
-    );
-protected:
-    BOOST_SERIALIZATION_DECL void recursive_register(bool includes_virtual_base = false) const;
-    BOOST_SERIALIZATION_DECL void recursive_unregister() const;
-    virtual bool has_virtual_base() const = 0;
-public:
-    // Data members
-    const extended_type_info * m_derived;
-    const extended_type_info * m_base;
-    /*const*/ std::ptrdiff_t m_difference;
-    void_caster const * const m_parent;
-
-    // note that void_casters are keyed on value of
-    // member extended type info records - NOT their
-    // addresses.  This is necessary in order for the
-    // void cast operations to work across dll and exe
-    // module boundries.
-    bool operator<(const void_caster & rhs) const;
-
-    const void_caster & operator*(){
-        return *this;
-    }
-    // each derived class must re-implement these;
-    virtual void const * upcast(void const * const t) const = 0;
-    virtual void const * downcast(void const * const t) const = 0;
-    // Constructor
-    void_caster(
-        extended_type_info const * derived,
-        extended_type_info const * base,
-        std::ptrdiff_t difference = 0,
-        void_caster const * const parent = 0
-    ) :
-        m_derived(derived),
-        m_base(base),
-        m_difference(difference),
-        m_parent(parent)
-    {}
-    virtual ~void_caster(){}
-};
-
-#ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable : 4251 4231 4660 4275 4511 4512)
-#endif
-
-template <class Derived, class Base>
-class BOOST_SYMBOL_VISIBLE void_caster_primitive :
-    public void_caster
-{
-    virtual void const * downcast(void const * const t) const {
-        const Derived * d = 
-            boost::serialization::smart_cast<const Derived *, const Base *>(
-                static_cast<const Base *>(t)
-            );
-        return d;
-    }
-    virtual void const * upcast(void const * const t) const {
-        const Base * b = 
-            boost::serialization::smart_cast<const Base *, const Derived *>(
-                static_cast<const Derived *>(t)
-            );
-        return b;
-    }
-    virtual bool has_virtual_base() const {
-        return false;
-    }
-public:
-    void_caster_primitive();
-    virtual ~void_caster_primitive();
-};
-
-template <class Derived, class Base>
-void_caster_primitive<Derived, Base>::void_caster_primitive() :
-    void_caster( 
-        & type_info_implementation<Derived>::type::get_const_instance(), 
-        & type_info_implementation<Base>::type::get_const_instance(),
-        // note:I wanted to displace from 0 here, but at least one compiler
-        // treated 0 by not shifting it at all.
-        reinterpret_cast<std::ptrdiff_t>(
-            static_cast<Derived *>(
-                reinterpret_cast<Base *>(8)
-            )
-        ) - 8
-    )
-{
-    recursive_register();
-}
-
-template <class Derived, class Base>
-void_caster_primitive<Derived, Base>::~void_caster_primitive(){
-    recursive_unregister();
-}
-
-template <class Derived, class Base>
-class BOOST_SYMBOL_VISIBLE void_caster_virtual_base :
-    public void_caster
-{
-    virtual bool has_virtual_base() const {
-        return true;
-    }
-public:
-    virtual void const * downcast(void const * const t) const {
-        const Derived * d = 
-            dynamic_cast<const Derived *>(
-                static_cast<const Base *>(t)
-            );
-        return d;
-    }
-    virtual void const * upcast(void const * const t) const {
-        const Base * b = 
-            dynamic_cast<const Base *>(
-                static_cast<const Derived *>(t)
-            );
-        return b;
-    }
-    void_caster_virtual_base();
-    virtual ~void_caster_virtual_base();
-};
-
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
-
-template <class Derived, class Base>
-void_caster_virtual_base<Derived,Base>::void_caster_virtual_base() :
-    void_caster( 
-        & (type_info_implementation<Derived>::type::get_const_instance()), 
-        & (type_info_implementation<Base>::type::get_const_instance())
-    )
-{
-    recursive_register(true);
-}
-
-template <class Derived, class Base>
-void_caster_virtual_base<Derived,Base>::~void_caster_virtual_base(){
-    recursive_unregister();
-}
-
-template <class Derived, class Base>
-struct BOOST_SYMBOL_VISIBLE void_caster_base :
-    public void_caster
-{
-    typedef
-        typename mpl::eval_if<boost::is_virtual_base_of<Base,Derived>,
-            mpl::identity<
-                void_cast_detail::void_caster_virtual_base<Derived, Base>
-            >
-        ,// else
-            mpl::identity<
-                void_cast_detail::void_caster_primitive<Derived, Base>
-            >
-        >::type type;
-};
-
-} // void_cast_detail 
-
-template<class Derived, class Base>
-BOOST_DLLEXPORT 
-inline const void_cast_detail::void_caster & void_cast_register(
-    Derived const * /* dnull = NULL */, 
-    Base const * /* bnull = NULL */
-){
-    typedef
-        typename mpl::eval_if<boost::is_virtual_base_of<Base,Derived>,
-            mpl::identity<
-                void_cast_detail::void_caster_virtual_base<Derived, Base>
-            >
-        ,// else
-            mpl::identity<
-                void_cast_detail::void_caster_primitive<Derived, Base>
-            >
-        >::type typex;
-    return singleton<typex>::get_const_instance();
-}
-
-template<class Derived, class Base>
-class BOOST_SYMBOL_VISIBLE void_caster :
-    public void_cast_detail::void_caster_base<Derived, Base>::type
-{
-};
-
-} // namespace serialization
-} // namespace boost
-
-#ifdef BOOST_MSVC  
-#  pragma warning(pop)  
-#endif
-
-#include <boost/config/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
-
-#endif // BOOST_SERIALIZATION_VOID_CAST_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/void_cast_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/void_cast_fwd.hpp
deleted file mode 100644
index def61d52bb7..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/void_cast_fwd.hpp
+++ /dev/null
@@ -1,37 +0,0 @@
-#ifndef  BOOST_SERIALIZATION_VOID_CAST_FWD_HPP
-#define BOOST_SERIALIZATION_VOID_CAST_FWD_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// void_cast_fwd.hpp:   interface for run-time casting of void pointers.
-
-// (C) Copyright 2005 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-// gennadiy.rozental@tfn.com
-
-//  See http://www.boost.org for updates, documentation, and revision history.
-
-#include <cstddef> // NULL
-#include <boost/serialization/force_include.hpp>
-
-namespace boost {
-namespace serialization {
-namespace void_cast_detail{
-class void_caster;
-} // namespace void_cast_detail
-template<class Derived, class Base>
-BOOST_DLLEXPORT 
-inline const void_cast_detail::void_caster & void_cast_register(
-    const Derived * dnull = NULL, 
-    const Base * bnull = NULL
-) BOOST_USED;
-} // namespace serialization
-} // namespace boost
-
-#endif // BOOST_SERIALIZATION_VOID_CAST_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/weak_ptr.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/weak_ptr.hpp
deleted file mode 100644
index 6952d24cb37..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/weak_ptr.hpp
+++ /dev/null
@@ -1,99 +0,0 @@
-#ifndef BOOST_SERIALIZATION_WEAK_PTR_HPP
-#define BOOST_SERIALIZATION_WEAK_PTR_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// weak_ptr.hpp: serialization for boost weak pointer
-
-// (C) Copyright 2004 Robert Ramey and Martin Ecker
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/weak_ptr.hpp>
-#include <boost/serialization/shared_ptr.hpp>
-
-namespace boost {
-namespace serialization{
-
-template<class Archive, class T>
-inline void save(
-    Archive & ar,
-    const boost::weak_ptr< T > &t,
-    const unsigned int /* file_version */
-){
-    const boost::shared_ptr< T > sp = t.lock();
-    ar << boost::serialization::make_nvp("weak_ptr", sp);
-}
-
-template<class Archive, class T>
-inline void load(
-    Archive & ar,
-    boost::weak_ptr< T > &t,
-    const unsigned int /* file_version */
-){
-    boost::shared_ptr< T > sp;
-    ar >> boost::serialization::make_nvp("weak_ptr", sp);
-    t = sp;
-}
-
-template<class Archive, class T>
-inline void serialize(
-    Archive & ar,
-    boost::weak_ptr< T > &t,
-    const unsigned int file_version
-){
-    boost::serialization::split_free(ar, t, file_version);
-}
-
-} // namespace serialization
-} // namespace boost
-
-#ifndef BOOST_NO_CXX11_SMART_PTR
-#include <memory>
-
-namespace boost {
-namespace serialization{
-
-template<class Archive, class T>
-inline void save(
-    Archive & ar,
-    const std::weak_ptr< T > &t,
-    const unsigned int /* file_version */
-){
-    const std::shared_ptr< T > sp = t.lock();
-    ar << boost::serialization::make_nvp("weak_ptr", sp);
-}
-
-template<class Archive, class T>
-inline void load(
-    Archive & ar,
-    std::weak_ptr< T > &t,
-    const unsigned int /* file_version */
-){
-    std::shared_ptr< T > sp;
-    ar >> boost::serialization::make_nvp("weak_ptr", sp);
-    t = sp;
-}
-
-template<class Archive, class T>
-inline void serialize(
-    Archive & ar,
-    std::weak_ptr< T > &t,
-    const unsigned int file_version
-){
-    boost::serialization::split_free(ar, t, file_version);
-}
-
-} // namespace serialization
-} // namespace boost
-
-#endif // BOOST_NO_CXX11_SMART_PTR
-
-#endif // BOOST_SERIALIZATION_WEAK_PTR_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/wrapper.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/wrapper.hpp
deleted file mode 100644
index 60d7910b17a..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/wrapper.hpp
+++ /dev/null
@@ -1,60 +0,0 @@
-#ifndef BOOST_SERIALIZATION_WRAPPER_HPP
-#define BOOST_SERIALIZATION_WRAPPER_HPP
-
-// (C) Copyright 2005-2006 Matthias Troyer
-// Use, modification and distribution is subject to the 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/serialization/traits.hpp>
-#include <boost/type_traits/is_base_and_derived.hpp>
-#include <boost/mpl/eval_if.hpp>
-#include <boost/mpl/bool_fwd.hpp>
-
-namespace boost { namespace serialization {
-
-/// the base class for serialization wrappers
-///
-/// wrappers need to be treated differently at various places in the serialization library,
-/// e.g. saving of non-const wrappers has to be possible. Since partial specialization
-// is not supported by all compilers, we derive all wrappers from wrapper_traits. 
-
-template<
-    class T, 
-    int Level = object_serializable, 
-    int Tracking = track_never,
-    unsigned int Version = 0,
-    class ETII = extended_type_info_impl< T >
->
-struct wrapper_traits : 
-    public traits<T,Level,Tracking,Version,ETII,mpl::true_> 
-{};
-
-template<class T>
-struct is_wrapper_impl :
-    boost::mpl::eval_if<
-      boost::is_base_and_derived<basic_traits,T>,
-      boost::mpl::true_,
-      boost::mpl::false_
-    >::type
-{};
-
-template<class T>
-struct is_wrapper {
-    typedef typename is_wrapper_impl<const T>::type type;
-};
-
-} // serialization
-} // boost
-
-// A macro to define that a class is a wrapper
-#define BOOST_CLASS_IS_WRAPPER(T)                       \
-namespace boost {                                       \
-namespace serialization {                               \
-template<>                                              \
-struct is_wrapper_impl<const T> : boost::mpl::true_ {}; \
-}                                                       \
-}                                                       \
-/**/
-
-#endif //BOOST_SERIALIZATION_WRAPPER_HPP
diff --git a/contrib/poco b/contrib/poco
new file mode 160000
index 00000000000..29439cf7fa3
--- /dev/null
+++ b/contrib/poco
@@ -0,0 +1 @@
+Subproject commit 29439cf7fa32c1a2d62d925bb6d6a3f14668a4a2
diff --git a/contrib/zlib-ng b/contrib/zlib-ng
new file mode 160000
index 00000000000..9173b89d467
--- /dev/null
+++ b/contrib/zlib-ng
@@ -0,0 +1 @@
+Subproject commit 9173b89d46799582d20a30578e0aa9788bc7d6e1
diff --git a/dbms/src/Storages/MergeTree/MergeTreeData.cpp b/dbms/src/Storages/MergeTree/MergeTreeData.cpp
index 08b4bb752e5..d9313ac8442 100644
--- a/dbms/src/Storages/MergeTree/MergeTreeData.cpp
+++ b/dbms/src/Storages/MergeTree/MergeTreeData.cpp
@@ -2266,8 +2266,6 @@ MergeTreeData::DataPartPtr MergeTreeData::getActiveContainingPart(
 {
     auto committed_parts_range = getDataPartsStateRange(state);
 
-    auto committed_parts_range = getDataPartsStateRange(DataPartState::Committed);
-
     /// The part can be covered only by the previous or the next one in data_parts.
     auto it = data_parts_by_state_and_info.lower_bound(DataPartStateAndInfo{state, part_info});
 
@@ -2600,7 +2598,6 @@ MergeTreeData::getDetachedParts() const
 
         part.prefix = dir_name.substr(0, first_separator);
     }
-
     return res;
 }
 

From 2930965938f595933fbd88080c8c7f4a593d1970 Mon Sep 17 00:00:00 2001
From: Vitaliy Zakaznikov <vzakaznikov@protonmail.com>
Date: Thu, 6 Jun 2019 21:10:56 -0400
Subject: [PATCH 027/107] * Renaming live_view_heartbeat_delay setting to
 live_view_heartbeat_interval   and making the setting to be in seconds
 instead of usec * Updated LIVE VIEW table to keep version consistent as long
 as the server is up * Removed calculation of hash in writeIntoLiveView method
 as it is recalculated   in the LiveViewBlockOutputStream * Changed to using
 values from the local context for live_view_heartbeat_interval and  
 temporary_live_view_timeout instead of the global context * Updated LIVE VIEW
 tests to match the changes

---
 dbms/src/Core/Defines.h                       |  2 +-
 dbms/src/Core/Settings.h                      |  2 +-
 .../DataStreams/LiveViewBlockInputStream.h    | 15 +++--
 .../LiveViewEventsBlockInputStream.h          | 13 ++--
 dbms/src/Storages/StorageLiveView.cpp         | 18 +++---
 dbms/src/Storages/StorageLiveView.h           | 62 +++++++++----------
 .../00956_live_view_watch_events.reference    |  4 +-
 .../00957_live_view_watch.reference           |  4 +-
 ...00959_create_temporary_live_view.reference |  2 +-
 .../00959_create_temporary_live_view.sql      |  5 +-
 .../00961_temporary_live_view_watch.reference |  4 +-
 ..._temporary_live_view_watch_live_timeout.py | 14 ++---
 .../00964_live_view_watch_events_heartbeat.py |  4 +-
 .../00965_live_view_watch_heartbeat.py        |  4 +-
 14 files changed, 82 insertions(+), 71 deletions(-)

diff --git a/dbms/src/Core/Defines.h b/dbms/src/Core/Defines.h
index 82e882d29f2..49d9d1e3a74 100644
--- a/dbms/src/Core/Defines.h
+++ b/dbms/src/Core/Defines.h
@@ -36,7 +36,7 @@
 #define DEFAULT_TEMPORARY_LIVE_CHANNEL_TIMEOUT_SEC 15
 #define DEFAULT_ALTER_LIVE_CHANNEL_WAIT_MS 10000
 #define SHOW_CHARS_ON_SYNTAX_ERROR ptrdiff_t(160)
-#define DEFAULT_HEARTBEAT_DELAY 15000000
+#define DEFAULT_LIVE_VIEW_HEARTBEAT_INTERVAL_SEC 15
 #define DBMS_DEFAULT_DISTRIBUTED_CONNECTIONS_POOL_SIZE 1024
 #define DBMS_CONNECTION_POOL_WITH_FAILOVER_DEFAULT_MAX_TRIES 3
 /// each period reduces the error counter by 2 times
diff --git a/dbms/src/Core/Settings.h b/dbms/src/Core/Settings.h
index ae7f891a17d..3d9a06e5984 100644
--- a/dbms/src/Core/Settings.h
+++ b/dbms/src/Core/Settings.h
@@ -326,7 +326,7 @@ struct Settings : public SettingsCollection<Settings>
     M(SettingBool, allow_simdjson, 1, "Allow using simdjson library in 'JSON*' functions if AVX2 instructions are available. If disabled rapidjson will be used.") \
     \
     M(SettingUInt64, max_partitions_per_insert_block, 100, "Limit maximum number of partitions in single INSERTed block. Zero means unlimited. Throw exception if the block contains too many partitions. This setting is a safety threshold, because using large number of partitions is a common misconception.") \
-    M(SettingUInt64, heartbeat_delay, DEFAULT_HEARTBEAT_DELAY, "The interval in microseconds to indicate live query is alive.") \
+    M(SettingSeconds, live_view_heartbeat_interval, DEFAULT_LIVE_VIEW_HEARTBEAT_INTERVAL_SEC, "The heartbeat interval in seconds to indicate live query is alive.") \
     M(SettingSeconds, temporary_live_view_timeout, DEFAULT_TEMPORARY_LIVE_VIEW_TIMEOUT_SEC, "Timeout after which temporary live view is deleted.") \
     M(SettingSeconds, temporary_live_channel_timeout, DEFAULT_TEMPORARY_LIVE_CHANNEL_TIMEOUT_SEC, "Timeout after which temporary live channel is deleted.") \
     M(SettingMilliseconds, alter_channel_wait_ms, DEFAULT_ALTER_LIVE_CHANNEL_WAIT_MS, "The wait time for alter channel request.")
diff --git a/dbms/src/DataStreams/LiveViewBlockInputStream.h b/dbms/src/DataStreams/LiveViewBlockInputStream.h
index a6c9c3533ee..93eae976177 100644
--- a/dbms/src/DataStreams/LiveViewBlockInputStream.h
+++ b/dbms/src/DataStreams/LiveViewBlockInputStream.h
@@ -37,15 +37,17 @@ public:
         /// Start storage no users thread
         /// if we are the last active user
         if (!storage.is_dropped && blocks_ptr.use_count() < 3)
-            storage.startNoUsersThread();
+            storage.startNoUsersThread(temporary_live_view_timeout);
     }
     /// length default -2 because we want LIMIT to specify number of updates so that LIMIT 1 waits for 1 update
     /// and LIMIT 0 just returns data without waiting for any updates
     LiveViewBlockInputStream(StorageLiveView & storage_, std::shared_ptr<BlocksPtr> blocks_ptr_,
         std::shared_ptr<BlocksMetadataPtr> blocks_metadata_ptr_,
         std::shared_ptr<bool> active_ptr_, Poco::Condition & condition_, Poco::FastMutex & mutex_,
-        int64_t length_, const UInt64 & heartbeat_delay_)
-        : storage(storage_), blocks_ptr(blocks_ptr_), blocks_metadata_ptr(blocks_metadata_ptr_), active_ptr(active_ptr_), condition(condition_), mutex(mutex_), length(length_ + 1), heartbeat_delay(heartbeat_delay_), blocks_hash("")
+        int64_t length_, const UInt64 & heartbeat_interval_,
+        const UInt64 & temporary_live_view_timeout_)
+        : storage(storage_), blocks_ptr(blocks_ptr_), blocks_metadata_ptr(blocks_metadata_ptr_), active_ptr(active_ptr_), condition(condition_), mutex(mutex_), length(length_ + 1), heartbeat_interval(heartbeat_interval_), temporary_live_view_timeout(temporary_live_view_timeout_),
+        blocks_hash("")
     {
         /// grab active pointer
         active = active_ptr.lock();
@@ -158,7 +160,9 @@ protected:
                     }
                     while (true)
                     {
-                        bool signaled = condition.tryWait(mutex, std::max((UInt64)0, heartbeat_delay - ((UInt64)timestamp.epochMicroseconds() - last_event_timestamp)) / 1000);
+                        bool signaled = condition.tryWait(mutex, 
+                            std::max((UInt64)0, (heartbeat_interval * 1000000) - 
+                            ((UInt64)timestamp.epochMicroseconds() - last_event_timestamp)) / 1000);
 
                         if (isCancelled() || storage.is_dropped)
                         {
@@ -211,7 +215,8 @@ private:
     /// Length specifies number of updates to send, default -1 (no limit)
     int64_t length;
     bool end_of_blocks{0};
-    UInt64 heartbeat_delay;
+    UInt64 heartbeat_interval;
+    UInt64 temporary_live_view_timeout;
     String blocks_hash;
     UInt64 last_event_timestamp{0};
     Poco::Timestamp timestamp;
diff --git a/dbms/src/DataStreams/LiveViewEventsBlockInputStream.h b/dbms/src/DataStreams/LiveViewEventsBlockInputStream.h
index 32290c3333b..d0f92806d74 100644
--- a/dbms/src/DataStreams/LiveViewEventsBlockInputStream.h
+++ b/dbms/src/DataStreams/LiveViewEventsBlockInputStream.h
@@ -41,13 +41,13 @@ public:
         /// Start storage no users thread
         /// if we are the last active user
         if (!storage.is_dropped && blocks_ptr.use_count() < 3)
-            storage.startNoUsersThread();
+            storage.startNoUsersThread(temporary_live_view_timeout);
     }
     /// length default -2 because we want LIMIT to specify number of updates so that LIMIT 1 waits for 1 update
     /// and LIMIT 0 just returns data without waiting for any updates
     LiveViewEventsBlockInputStream(StorageLiveView & storage_, std::shared_ptr<BlocksPtr> blocks_ptr_, std::shared_ptr<BlocksMetadataPtr> blocks_metadata_ptr_, std::shared_ptr<bool> active_ptr_, Poco::Condition & condition_, Poco::FastMutex & mutex_,
-        int64_t length_, const UInt64 & heartbeat_delay_)
-        : storage(storage_), blocks_ptr(blocks_ptr_), blocks_metadata_ptr(blocks_metadata_ptr_), active_ptr(active_ptr_), condition(condition_), mutex(mutex_), length(length_ + 1), heartbeat_delay(heartbeat_delay_)
+        int64_t length_, const UInt64 & heartbeat_interval_, const UInt64 & temporary_live_view_timeout_)
+        : storage(storage_), blocks_ptr(blocks_ptr_), blocks_metadata_ptr(blocks_metadata_ptr_), active_ptr(active_ptr_), condition(condition_), mutex(mutex_), length(length_ + 1), heartbeat_interval(heartbeat_interval_), temporary_live_view_timeout(temporary_live_view_timeout_)
     {
         /// grab active pointer
         active = active_ptr.lock();
@@ -188,7 +188,9 @@ protected:
                     }
                     while (true)
                     {
-                        bool signaled = condition.tryWait(mutex, std::max((UInt64)0, heartbeat_delay - ((UInt64)timestamp.epochMicroseconds() - last_event_timestamp)) / 1000);
+                        bool signaled = condition.tryWait(mutex, 
+                            std::max((UInt64)0, (heartbeat_interval * 1000000) - 
+			    ((UInt64)timestamp.epochMicroseconds() - last_event_timestamp)) / 1000);
 
                         if (isCancelled() || storage.is_dropped)
                         {
@@ -241,7 +243,8 @@ private:
     /// Length specifies number of updates to send, default -1 (no limit)
     int64_t length;
     bool end_of_blocks{0};
-    UInt64 heartbeat_delay;
+    UInt64 heartbeat_interval;
+    UInt64 temporary_live_view_timeout;
     UInt64 last_event_timestamp{0};
     Poco::Timestamp timestamp;
 };
diff --git a/dbms/src/Storages/StorageLiveView.cpp b/dbms/src/Storages/StorageLiveView.cpp
index 77578bc386d..108e146dc73 100644
--- a/dbms/src/Storages/StorageLiveView.cpp
+++ b/dbms/src/Storages/StorageLiveView.cpp
@@ -132,6 +132,7 @@ StorageLiveView::StorageLiveView(
         DatabaseAndTableName(database_name, table_name));
 
     is_temporary = query.temporary;
+    temporary_live_view_timeout = local_context.getSettingsRef().temporary_live_view_timeout.totalSeconds();
 
     blocks_ptr = std::make_shared<BlocksPtr>();
     blocks_metadata_ptr = std::make_shared<BlocksMetadataPtr>();
@@ -235,7 +236,7 @@ void StorageLiveView::checkTableCanBeDropped() const
     }
 }
 
-void StorageLiveView::noUsersThread()
+void StorageLiveView::noUsersThread(const UInt64 & timeout)
 {
     if (shutdown_called)
         return;
@@ -246,7 +247,8 @@ void StorageLiveView::noUsersThread()
         while (1)
         {
             Poco::FastMutex::ScopedLock lock(noUsersThreadMutex);
-            if (!noUsersThreadWakeUp && !noUsersThreadCondition.tryWait(noUsersThreadMutex, global_context.getSettingsRef().temporary_live_view_timeout.totalSeconds() * 1000))
+            if (!noUsersThreadWakeUp && !noUsersThreadCondition.tryWait(noUsersThreadMutex,
+                timeout * 1000))
             {
                 noUsersThreadWakeUp = false;
                 if (shutdown_called)
@@ -283,7 +285,7 @@ void StorageLiveView::noUsersThread()
     }
 }
 
-void StorageLiveView::startNoUsersThread()
+void StorageLiveView::startNoUsersThread(const UInt64 & timeout)
 {
     bool expected = false;
     if (!startnousersthread_called.compare_exchange_strong(expected, true))
@@ -308,14 +310,14 @@ void StorageLiveView::startNoUsersThread()
             noUsersThreadWakeUp = false;
         }
         if (!is_dropped)
-            no_users_thread = std::thread(&StorageLiveView::noUsersThread, this);
+            no_users_thread = std::thread(&StorageLiveView::noUsersThread, this, timeout);
     }
     startnousersthread_called = false;
 }
 
 void StorageLiveView::startup()
 {
-    startNoUsersThread();
+    startNoUsersThread(temporary_live_view_timeout);
 }
 
 void StorageLiveView::shutdown()
@@ -400,7 +402,8 @@ BlockInputStreams StorageLiveView::watch(
 
     if (query.is_watch_events)
     {
-        auto reader = std::make_shared<LiveViewEventsBlockInputStream>(*this, blocks_ptr, blocks_metadata_ptr, active_ptr, condition, mutex, length, context.getSettingsRef().heartbeat_delay);
+        auto reader = std::make_shared<LiveViewEventsBlockInputStream>(*this, blocks_ptr, blocks_metadata_ptr, active_ptr, condition, mutex, length, context.getSettingsRef().live_view_heartbeat_interval.totalSeconds(),
+        context.getSettingsRef().temporary_live_view_timeout.totalSeconds());
 
         if (no_users_thread.joinable())
         {
@@ -424,7 +427,8 @@ BlockInputStreams StorageLiveView::watch(
     }
     else
     {
-        auto reader = std::make_shared<LiveViewBlockInputStream>(*this, blocks_ptr, blocks_metadata_ptr, active_ptr, condition, mutex, length, context.getSettingsRef().heartbeat_delay);
+        auto reader = std::make_shared<LiveViewBlockInputStream>(*this, blocks_ptr, blocks_metadata_ptr, active_ptr, condition, mutex, length, context.getSettingsRef().live_view_heartbeat_interval.totalSeconds(),
+        context.getSettingsRef().temporary_live_view_timeout.totalSeconds());
 
         if (no_users_thread.joinable())
         {
diff --git a/dbms/src/Storages/StorageLiveView.h b/dbms/src/Storages/StorageLiveView.h
index bb4377fbed6..37faee4b266 100644
--- a/dbms/src/Storages/StorageLiveView.h
+++ b/dbms/src/Storages/StorageLiveView.h
@@ -84,7 +84,7 @@ public:
     }
     /// Background thread for temporary tables
     /// which drops this table if there are no users
-    void startNoUsersThread();
+    void startNoUsersThread(const UInt64 & timeout);
     Poco::FastMutex noUsersThreadMutex;
     bool noUsersThreadWakeUp{false};
     Poco::Condition noUsersThreadCondition;
@@ -110,7 +110,8 @@ public:
     void reset()
     {
         (*blocks_ptr).reset();
-        (*blocks_metadata_ptr).reset();
+        if (*blocks_metadata_ptr)
+            (*blocks_metadata_ptr)->hash.clear();
         mergeable_blocks.reset();
     }
 
@@ -163,8 +164,6 @@ public:
             }
         }
 
-        SipHash hash;
-        UInt128 key;
         BlockInputStreams from;
         BlocksPtr blocks = std::make_shared<Blocks>();
         BlocksPtrs mergeable_blocks;
@@ -234,22 +233,13 @@ public:
 
         while (Block this_block = data->read())
         {
-            this_block.updateHash(hash);
             blocks->push_back(this_block);
         }
-        /// get hash key
-        hash.get128(key.low, key.high);
-        /// Update blocks only if hash keys do not match
-        /// NOTE: hash could be different for the same result
-        ///       if blocks are not in the same order
-        if (live_view.getBlocksHashKey() != key.toHexString())
-        {
-            auto sample_block = blocks->front().cloneEmpty();
-            BlockInputStreamPtr new_data = std::make_shared<BlocksBlockInputStream>(std::make_shared<BlocksPtr>(blocks), sample_block);
-            {
-                copyData(*new_data, *output);
-            }
-        }
+
+        auto sample_block = blocks->front().cloneEmpty();
+        BlockInputStreamPtr new_data = std::make_shared<BlocksBlockInputStream>(std::make_shared<BlocksPtr>(blocks), sample_block);
+
+        copyData(*new_data, *output);
     }
 
 private:
@@ -272,10 +262,11 @@ private:
     BlocksMetadataPtr new_blocks_metadata;
     BlocksPtrs mergeable_blocks;
 
-    void noUsersThread();
+    void noUsersThread(const UInt64 & timeout);
     std::thread no_users_thread;
     std::atomic<bool> shutdown_called{false};
     std::atomic<bool> startnousersthread_called{false};
+    UInt64 temporary_live_view_timeout;
 
     StorageLiveView(
         const String & table_name_,
@@ -300,29 +291,36 @@ public:
 
     void writeSuffix() override
     {
-        Poco::FastMutex::ScopedLock lock(storage.mutex);
         UInt128 key;
+        String key_str;
 
         new_hash->get128(key.low, key.high);
-        new_blocks_metadata->hash = key.toHexString();
-        new_blocks_metadata->version = storage.getBlocksVersion() + 1;
+        key_str = key.toHexString();
 
-        for (auto & block : *new_blocks)
+        Poco::FastMutex::ScopedLock lock(storage.mutex);
+
+        if (storage.getBlocksHashKey() != key_str)
         {
-            block.insert({DataTypeUInt64().createColumnConst(
-                block.rows(), new_blocks_metadata->version)->convertToFullColumnIfConst(),
-                std::make_shared<DataTypeUInt64>(),
-                "_version"});
-        }
+            new_blocks_metadata->hash = key_str;
+            new_blocks_metadata->version = storage.getBlocksVersion() + 1;
 
-        (*storage.blocks_ptr) = new_blocks;
-        (*storage.blocks_metadata_ptr) = new_blocks_metadata;
+            for (auto & block : *new_blocks)
+            {
+                block.insert({DataTypeUInt64().createColumnConst(
+                    block.rows(), new_blocks_metadata->version)->convertToFullColumnIfConst(),
+                    std::make_shared<DataTypeUInt64>(),
+                    "_version"});
+            }
+
+            (*storage.blocks_ptr) = new_blocks;
+            (*storage.blocks_metadata_ptr) = new_blocks_metadata;
+
+            storage.condition.broadcast();
+        }
 
         new_blocks.reset();
         new_blocks_metadata.reset();
         new_hash.reset();
-
-        storage.condition.broadcast();
     }
 
     void write(const Block & block) override
diff --git a/dbms/tests/queries/0_stateless/00956_live_view_watch_events.reference b/dbms/tests/queries/0_stateless/00956_live_view_watch_events.reference
index 86a72083821..b67c49182e9 100644
--- a/dbms/tests/queries/0_stateless/00956_live_view_watch_events.reference
+++ b/dbms/tests/queries/0_stateless/00956_live_view_watch_events.reference
@@ -1,4 +1,4 @@
 lv
 1	c9d39b11cce79112219a73aaa319b475
-1	4cd0592103888d4682de9a32a23602e3
-1	2186dbea325ee4c56b67e9b792e993a3
+2	4cd0592103888d4682de9a32a23602e3
+3	2186dbea325ee4c56b67e9b792e993a3
diff --git a/dbms/tests/queries/0_stateless/00957_live_view_watch.reference b/dbms/tests/queries/0_stateless/00957_live_view_watch.reference
index 69a461b3fc4..65500578a69 100644
--- a/dbms/tests/queries/0_stateless/00957_live_view_watch.reference
+++ b/dbms/tests/queries/0_stateless/00957_live_view_watch.reference
@@ -1,4 +1,4 @@
 lv
 0	1
-6	1
-21	1
+6	2
+21	3
diff --git a/dbms/tests/queries/0_stateless/00959_create_temporary_live_view.reference b/dbms/tests/queries/0_stateless/00959_create_temporary_live_view.reference
index 4bd209d4424..49d86fc2fbf 100644
--- a/dbms/tests/queries/0_stateless/00959_create_temporary_live_view.reference
+++ b/dbms/tests/queries/0_stateless/00959_create_temporary_live_view.reference
@@ -1,4 +1,4 @@
 temporary_live_view_timeout	5
+live_view_heartbeat_interval	15
 lv
 0
-0
diff --git a/dbms/tests/queries/0_stateless/00959_create_temporary_live_view.sql b/dbms/tests/queries/0_stateless/00959_create_temporary_live_view.sql
index 4a4a7ae5eed..c0625324bb6 100644
--- a/dbms/tests/queries/0_stateless/00959_create_temporary_live_view.sql
+++ b/dbms/tests/queries/0_stateless/00959_create_temporary_live_view.sql
@@ -2,13 +2,14 @@ DROP TABLE IF EXISTS test.lv;
 DROP TABLE IF EXISTS test.mt;
 
 SELECT name, value from system.settings WHERE name = 'temporary_live_view_timeout';
+SELECT name, value from system.settings WHERE name = 'live_view_heartbeat_interval';
 
+SET temporary_live_view_timeout=1;
 CREATE TABLE test.mt (a Int32) Engine=MergeTree order by tuple();
 CREATE TEMPORARY LIVE VIEW test.lv AS SELECT sum(a) FROM test.mt;
 
 SHOW TABLES LIKE 'lv';
-SELECT sleep(3);
-SELECT sleep(2);
+SELECT sleep(1);
 SHOW TABLES LIKE 'lv';
 
 DROP TABLE test.mt;
diff --git a/dbms/tests/queries/0_stateless/00961_temporary_live_view_watch.reference b/dbms/tests/queries/0_stateless/00961_temporary_live_view_watch.reference
index 69a461b3fc4..65500578a69 100644
--- a/dbms/tests/queries/0_stateless/00961_temporary_live_view_watch.reference
+++ b/dbms/tests/queries/0_stateless/00961_temporary_live_view_watch.reference
@@ -1,4 +1,4 @@
 lv
 0	1
-6	1
-21	1
+6	2
+21	3
diff --git a/dbms/tests/queries/0_stateless/00963_temporary_live_view_watch_live_timeout.py b/dbms/tests/queries/0_stateless/00963_temporary_live_view_watch_live_timeout.py
index 43bf748dc2b..29ec01c724a 100755
--- a/dbms/tests/queries/0_stateless/00963_temporary_live_view_watch_live_timeout.py
+++ b/dbms/tests/queries/0_stateless/00963_temporary_live_view_watch_live_timeout.py
@@ -26,30 +26,26 @@ client2.expect(prompt)
 
 client1.send('DROP TABLE IF EXISTS test.lv')
 client1.expect(prompt)
-client1.send(' DROP TABLE IF EXISTS test.mt')
+client1.send('DROP TABLE IF EXISTS test.mt')
+client1.expect(prompt)
+client1.send('SET temporary_live_view_timeout=1')
 client1.expect(prompt)
 client1.send('CREATE TABLE test.mt (a Int32) Engine=MergeTree order by tuple()')
 client1.expect(prompt)
 client1.send('CREATE TEMPORARY LIVE VIEW test.lv AS SELECT sum(a) FROM test.mt')
 client1.expect(prompt)
-client1.send('SELECT 4')
-client1.expect(prompt, timeout=4)
 client1.send('WATCH test.lv')
 client2.send('INSERT INTO test.mt VALUES (1),(2),(3)')
 client2.expect(prompt)
 client1.expect(r'6.*2' + end_of_block)
-client2.send('SELECT sleep(3)')
-client2.expect(prompt, timeout=4)
 client2.send('INSERT INTO test.mt VALUES (4),(5),(6)')
 client2.expect(prompt)
 client1.expect(r'21.*3' + end_of_block)
 # send Ctrl-C
 os.kill(client1.process.pid,signal.SIGINT)
 client1.expect(prompt)
-client1.send('SELECT sleep(3)')
-client1.expect(prompt, timeout=4)
-client1.send('SELECT sleep(3)')
-client1.expect(prompt, timeout=4)
+client1.send('SELECT sleep(1)')
+client1.expect(prompt)
 client1.send('DROP TABLE test.lv')
 client1.expect('Table test.lv doesn\'t exist')
 client1.expect(prompt)
diff --git a/dbms/tests/queries/0_stateless/00964_live_view_watch_events_heartbeat.py b/dbms/tests/queries/0_stateless/00964_live_view_watch_events_heartbeat.py
index 9d4f1d0716c..cbb659f1292 100755
--- a/dbms/tests/queries/0_stateless/00964_live_view_watch_events_heartbeat.py
+++ b/dbms/tests/queries/0_stateless/00964_live_view_watch_events_heartbeat.py
@@ -28,6 +28,8 @@ client1.send('DROP TABLE IF EXISTS test.lv')
 client1.expect(prompt)
 client1.send(' DROP TABLE IF EXISTS test.mt')
 client1.expect(prompt)
+client1.send('SET live_view_heartbeat_interval=1')
+client1.expect(prompt)
 client1.send('CREATE TABLE test.mt (a Int32) Engine=MergeTree order by tuple()')
 client1.expect(prompt)
 client1.send('CREATE TEMPORARY LIVE VIEW test.lv AS SELECT sum(a) FROM test.mt')
@@ -37,7 +39,7 @@ client2.send('INSERT INTO test.mt VALUES (1),(2),(3)')
 client1.expect('2.*4cd0592103888d4682de9a32a23602e3' + end_of_block)
 client1.expect('Progress: 2.00 rows.*\)')
 # wait for heartbeat
-client1.expect('Progress: 2.00 rows.*\)', timeout=15)
+client1.expect('Progress: 2.00 rows.*\)')
 # send Ctrl-C
 os.kill(client1.process.pid,signal.SIGINT)
 client1.expect(prompt)
diff --git a/dbms/tests/queries/0_stateless/00965_live_view_watch_heartbeat.py b/dbms/tests/queries/0_stateless/00965_live_view_watch_heartbeat.py
index cafbcd833b1..c596d169e1c 100755
--- a/dbms/tests/queries/0_stateless/00965_live_view_watch_heartbeat.py
+++ b/dbms/tests/queries/0_stateless/00965_live_view_watch_heartbeat.py
@@ -28,6 +28,8 @@ client1.send('DROP TABLE IF EXISTS test.lv')
 client1.expect(prompt)
 client1.send(' DROP TABLE IF EXISTS test.mt')
 client1.expect(prompt)
+client1.send('SET live_view_heartbeat_interval=1')
+client1.expect(prompt)
 client1.send('CREATE TABLE test.mt (a Int32) Engine=MergeTree order by tuple()')
 client1.expect(prompt)
 client1.send('CREATE TEMPORARY LIVE VIEW test.lv AS SELECT sum(a) FROM test.mt')
@@ -37,7 +39,7 @@ client2.send('INSERT INTO test.mt VALUES (1),(2),(3)')
 client1.expect(r'6.*2' + end_of_block)
 client1.expect('Progress: 2.00 rows.*\)')
 # wait for heartbeat
-client1.expect('Progress: 2.00 rows.*\)', timeout=15)
+client1.expect('Progress: 2.00 rows.*\)')
 # send Ctrl-C
 os.kill(client1.process.pid,signal.SIGINT)
 client1.expect(prompt)

From aa3ef47aab0a3fa2546604da2dec6801b230d055 Mon Sep 17 00:00:00 2001
From: Vitaliy Zakaznikov <vzakaznikov@protonmail.com>
Date: Fri, 7 Jun 2019 09:05:14 -0400
Subject: [PATCH 028/107] * Adding JSONEachRowWithProgress format   that can be
 used with WATCH queries when HTTP connection is used   in this case progress
 events are used as a heartbeat * Adding new tests that use
 JSONEachRowWithProgress format * Adding tests for WATCH query heartbeats when
 HTTP connection is used * Small fixes to uexpect.py

---
 dbms/src/Formats/FormatFactory.cpp            |  2 +
 dbms/src/Formats/JSONEachRowRowOutputStream.h |  2 +-
 ...JSONEachRowWithProgressRowOutputStream.cpp | 47 +++++++++++++++
 .../JSONEachRowWithProgressRowOutputStream.h  | 27 +++++++++
 .../00959_create_temporary_live_view.sql      |  2 +-
 ...t_format_jsoneachrowwithprogress.reference |  5 ++
 ..._select_format_jsoneachrowwithprogress.sql | 14 +++++
 ...h_format_jsoneachrowwithprogress.reference |  7 +++
 ...w_watch_format_jsoneachrowwithprogress.sql | 20 +++++++
 ...70_live_view_watch_events_http_hearbeat.py | 57 +++++++++++++++++++
 ..._view_watch_events_http_hearbeat.reference |  0
 .../00971_live_view_watch_http_hearbeat.py    | 57 +++++++++++++++++++
 ...71_live_view_watch_http_hearbeat.reference |  0
 dbms/tests/queries/0_stateless/uexpect.py     | 10 +++-
 14 files changed, 245 insertions(+), 5 deletions(-)
 create mode 100644 dbms/src/Formats/JSONEachRowWithProgressRowOutputStream.cpp
 create mode 100644 dbms/src/Formats/JSONEachRowWithProgressRowOutputStream.h
 create mode 100644 dbms/tests/queries/0_stateless/00968_live_view_select_format_jsoneachrowwithprogress.reference
 create mode 100644 dbms/tests/queries/0_stateless/00968_live_view_select_format_jsoneachrowwithprogress.sql
 create mode 100644 dbms/tests/queries/0_stateless/00969_live_view_watch_format_jsoneachrowwithprogress.reference
 create mode 100644 dbms/tests/queries/0_stateless/00969_live_view_watch_format_jsoneachrowwithprogress.sql
 create mode 100755 dbms/tests/queries/0_stateless/00970_live_view_watch_events_http_hearbeat.py
 create mode 100644 dbms/tests/queries/0_stateless/00970_live_view_watch_events_http_hearbeat.reference
 create mode 100755 dbms/tests/queries/0_stateless/00971_live_view_watch_http_hearbeat.py
 create mode 100644 dbms/tests/queries/0_stateless/00971_live_view_watch_http_hearbeat.reference

diff --git a/dbms/src/Formats/FormatFactory.cpp b/dbms/src/Formats/FormatFactory.cpp
index d5718278554..4357b324ac7 100644
--- a/dbms/src/Formats/FormatFactory.cpp
+++ b/dbms/src/Formats/FormatFactory.cpp
@@ -113,6 +113,7 @@ void registerInputFormatTSKV(FormatFactory & factory);
 void registerOutputFormatTSKV(FormatFactory & factory);
 void registerInputFormatJSONEachRow(FormatFactory & factory);
 void registerOutputFormatJSONEachRow(FormatFactory & factory);
+void registerOutputFormatJSONEachRowWithProgress(FormatFactory & factory);
 void registerInputFormatParquet(FormatFactory & factory);
 void registerOutputFormatParquet(FormatFactory & factory);
 void registerInputFormatProtobuf(FormatFactory & factory);
@@ -153,6 +154,7 @@ FormatFactory::FormatFactory()
     registerOutputFormatTSKV(*this);
     registerInputFormatJSONEachRow(*this);
     registerOutputFormatJSONEachRow(*this);
+    registerOutputFormatJSONEachRowWithProgress(*this);
     registerInputFormatProtobuf(*this);
     registerOutputFormatProtobuf(*this);
     registerInputFormatCapnProto(*this);
diff --git a/dbms/src/Formats/JSONEachRowRowOutputStream.h b/dbms/src/Formats/JSONEachRowRowOutputStream.h
index 4f2dc690aed..7d0d410b219 100644
--- a/dbms/src/Formats/JSONEachRowRowOutputStream.h
+++ b/dbms/src/Formats/JSONEachRowRowOutputStream.h
@@ -27,7 +27,7 @@ public:
         ostr.next();
     }
 
-private:
+protected:
     WriteBuffer & ostr;
     size_t field_number = 0;
     Names fields;
diff --git a/dbms/src/Formats/JSONEachRowWithProgressRowOutputStream.cpp b/dbms/src/Formats/JSONEachRowWithProgressRowOutputStream.cpp
new file mode 100644
index 00000000000..4f59e99ff6d
--- /dev/null
+++ b/dbms/src/Formats/JSONEachRowWithProgressRowOutputStream.cpp
@@ -0,0 +1,47 @@
+#include <IO/WriteHelpers.h>
+#include <IO/WriteBufferValidUTF8.h>
+#include <Formats/JSONEachRowWithProgressRowOutputStream.h>
+#include <Formats/FormatFactory.h>
+#include <Formats/BlockOutputStreamFromRowOutputStream.h>
+
+
+namespace DB
+{
+
+
+void JSONEachRowWithProgressRowOutputStream::writeRowStartDelimiter()
+{
+    writeCString("{\"row\":{", ostr);
+}
+
+
+void JSONEachRowWithProgressRowOutputStream::writeRowEndDelimiter()
+{
+    writeCString("}}\n", ostr);
+    field_number = 0;
+}
+
+
+void JSONEachRowWithProgressRowOutputStream::onProgress(const Progress & value)
+{
+    progress.incrementPiecewiseAtomically(value);
+    writeCString("{\"progress\":", ostr);
+    progress.writeJSON(ostr);
+    writeCString("}\n", ostr);
+}
+
+
+void registerOutputFormatJSONEachRowWithProgress(FormatFactory & factory)
+{
+    factory.registerOutputFormat("JSONEachRowWithProgress", [](
+        WriteBuffer & buf,
+        const Block & sample,
+        const Context &,
+        const FormatSettings & format_settings)
+    {
+        return std::make_shared<BlockOutputStreamFromRowOutputStream>(
+            std::make_shared<JSONEachRowWithProgressRowOutputStream>(buf, sample, format_settings), sample);
+    });
+}
+
+}
diff --git a/dbms/src/Formats/JSONEachRowWithProgressRowOutputStream.h b/dbms/src/Formats/JSONEachRowWithProgressRowOutputStream.h
new file mode 100644
index 00000000000..e8cef8e147b
--- /dev/null
+++ b/dbms/src/Formats/JSONEachRowWithProgressRowOutputStream.h
@@ -0,0 +1,27 @@
+#pragma once
+
+#include <IO/Progress.h>
+#include <Formats/JSONEachRowRowOutputStream.h>
+
+
+namespace DB
+{
+
+/** The stream for outputting data in JSON format, by object per line
+  * that includes progress rows. Does not validate UTF-8.
+  */
+class JSONEachRowWithProgressRowOutputStream : public JSONEachRowRowOutputStream
+{
+public:
+    using JSONEachRowRowOutputStream::JSONEachRowRowOutputStream;
+
+    void writeRowStartDelimiter() override;
+    void writeRowEndDelimiter() override;
+    void onProgress(const Progress & value) override;
+
+private:
+    Progress progress;
+};
+
+}
+
diff --git a/dbms/tests/queries/0_stateless/00959_create_temporary_live_view.sql b/dbms/tests/queries/0_stateless/00959_create_temporary_live_view.sql
index c0625324bb6..8cd6ee06ace 100644
--- a/dbms/tests/queries/0_stateless/00959_create_temporary_live_view.sql
+++ b/dbms/tests/queries/0_stateless/00959_create_temporary_live_view.sql
@@ -9,7 +9,7 @@ CREATE TABLE test.mt (a Int32) Engine=MergeTree order by tuple();
 CREATE TEMPORARY LIVE VIEW test.lv AS SELECT sum(a) FROM test.mt;
 
 SHOW TABLES LIKE 'lv';
-SELECT sleep(1);
+SELECT sleep(2);
 SHOW TABLES LIKE 'lv';
 
 DROP TABLE test.mt;
diff --git a/dbms/tests/queries/0_stateless/00968_live_view_select_format_jsoneachrowwithprogress.reference b/dbms/tests/queries/0_stateless/00968_live_view_select_format_jsoneachrowwithprogress.reference
new file mode 100644
index 00000000000..0f6a0405cda
--- /dev/null
+++ b/dbms/tests/queries/0_stateless/00968_live_view_select_format_jsoneachrowwithprogress.reference
@@ -0,0 +1,5 @@
+lv
+{"row":{"a":1}}
+{"row":{"a":2}}
+{"row":{"a":3}}
+{"progress":{"read_rows":"3","read_bytes":"36","written_rows":"0","written_bytes":"0","total_rows_to_read":"0"}}
diff --git a/dbms/tests/queries/0_stateless/00968_live_view_select_format_jsoneachrowwithprogress.sql b/dbms/tests/queries/0_stateless/00968_live_view_select_format_jsoneachrowwithprogress.sql
new file mode 100644
index 00000000000..748d901b3bf
--- /dev/null
+++ b/dbms/tests/queries/0_stateless/00968_live_view_select_format_jsoneachrowwithprogress.sql
@@ -0,0 +1,14 @@
+DROP TABLE IF EXISTS test.lv;
+DROP TABLE IF EXISTS test.mt;
+
+CREATE TABLE test.mt (a Int32) Engine=MergeTree order by tuple();
+CREATE LIVE VIEW test.lv AS SELECT * FROM test.mt;
+
+SHOW TABLES LIKE 'lv';
+
+INSERT INTO test.mt VALUES (1),(2),(3);
+
+SELECT * FROM test.lv FORMAT JSONEachRowWithProgress;
+
+DROP TABLE test.lv;
+DROP TABLE test.mt;
diff --git a/dbms/tests/queries/0_stateless/00969_live_view_watch_format_jsoneachrowwithprogress.reference b/dbms/tests/queries/0_stateless/00969_live_view_watch_format_jsoneachrowwithprogress.reference
new file mode 100644
index 00000000000..8510bebad77
--- /dev/null
+++ b/dbms/tests/queries/0_stateless/00969_live_view_watch_format_jsoneachrowwithprogress.reference
@@ -0,0 +1,7 @@
+lv
+{"row":{"sum(a)":"0","_version":"1"}}
+{"progress":{"read_rows":"1","read_bytes":"16","written_rows":"0","written_bytes":"0","total_rows_to_read":"0"}}
+{"row":{"sum(a)":"6","_version":"2"}}
+{"progress":{"read_rows":"1","read_bytes":"16","written_rows":"0","written_bytes":"0","total_rows_to_read":"0"}}
+{"row":{"sum(a)":"21","_version":"3"}}
+{"progress":{"read_rows":"1","read_bytes":"16","written_rows":"0","written_bytes":"0","total_rows_to_read":"0"}}
diff --git a/dbms/tests/queries/0_stateless/00969_live_view_watch_format_jsoneachrowwithprogress.sql b/dbms/tests/queries/0_stateless/00969_live_view_watch_format_jsoneachrowwithprogress.sql
new file mode 100644
index 00000000000..9f2e0384dd8
--- /dev/null
+++ b/dbms/tests/queries/0_stateless/00969_live_view_watch_format_jsoneachrowwithprogress.sql
@@ -0,0 +1,20 @@
+DROP TABLE IF EXISTS test.lv;
+DROP TABLE IF EXISTS test.mt;
+
+CREATE TABLE test.mt (a Int32) Engine=MergeTree order by tuple();
+CREATE LIVE VIEW test.lv AS SELECT sum(a) FROM test.mt;
+
+SHOW TABLES LIKE 'lv';
+
+WATCH test.lv LIMIT 0 FORMAT JSONEachRowWithProgress;
+
+INSERT INTO test.mt VALUES (1),(2),(3);
+
+WATCH test.lv LIMIT 0 FORMAT JSONEachRowWithProgress;
+
+INSERT INTO test.mt VALUES (4),(5),(6);
+
+WATCH test.lv LIMIT 0 FORMAT JSONEachRowWithProgress;
+
+DROP TABLE test.lv;
+DROP TABLE test.mt;
diff --git a/dbms/tests/queries/0_stateless/00970_live_view_watch_events_http_hearbeat.py b/dbms/tests/queries/0_stateless/00970_live_view_watch_events_http_hearbeat.py
new file mode 100755
index 00000000000..1021edd7769
--- /dev/null
+++ b/dbms/tests/queries/0_stateless/00970_live_view_watch_events_http_hearbeat.py
@@ -0,0 +1,57 @@
+#!/usr/bin/env python
+import imp
+import os
+import sys
+import signal
+
+CURDIR = os.path.dirname(os.path.realpath(__file__))
+
+uexpect = imp.load_source('uexpect', os.path.join(CURDIR, 'uexpect.py'))
+
+def client(name='', command=None):
+    if command is None:
+        client = uexpect.spawn(os.environ.get('CLICKHOUSE_CLIENT'))
+    else:
+        client = uexpect.spawn(command)
+    client.eol('\r')
+    # Note: uncomment this line for debugging
+    #client.logger(sys.stdout, prefix=name)
+    client.timeout(2)
+    return client
+
+prompt = ':\) '
+end_of_block = r'.*\xe2\x94\x82\r\n.*\xe2\x94\x98\r\n'
+client1 = client('client1>')
+client1.expect(prompt)
+
+client1.send('DROP TABLE IF EXISTS test.lv')
+client1.expect(prompt)
+client1.send(' DROP TABLE IF EXISTS test.mt')
+client1.expect(prompt)
+client1.send('CREATE TABLE test.mt (a Int32) Engine=MergeTree order by tuple()')
+client1.expect(prompt)
+client1.send('CREATE LIVE VIEW test.lv AS SELECT sum(a) FROM test.mt')
+client1.expect(prompt)
+
+client2 = client('client2>', ['bash', '--noediting'])
+client2.expect('\$ ')
+client2.send('wget -O- -q "http://localhost:8123/?live_view_heartbeat_interval=1&query=WATCH test.lv EVENTS FORMAT JSONEachRowWithProgress"')
+client2.expect('{"progress":{"read_rows":"1","read_bytes":"49","written_rows":"0","written_bytes":"0","total_rows_to_read":"0"}}\r\n', escape=True)
+client2.expect('{"row":{"version":"1","hash":"c9d39b11cce79112219a73aaa319b475"}}', escape=True)
+client2.expect('{"progress":{"read_rows":"1","read_bytes":"49","written_rows":"0","written_bytes":"0","total_rows_to_read":"0"}}', escape=True)
+# heartbeat is provided by progress message
+client2.expect('{"progress":{"read_rows":"1","read_bytes":"49","written_rows":"0","written_bytes":"0","total_rows_to_read":"0"}}', escape=True)
+
+client1.send('INSERT INTO test.mt VALUES (1),(2),(3)')
+client1.expect(prompt)
+
+client2.expect('{"row":{"version":"2","hash":"4cd0592103888d4682de9a32a23602e3"}}\r\n', escape=True)
+
+client2.expect('.*2\t.*\r\n')
+## send Ctrl-C
+os.kill(client2.process.pid,signal.SIGINT)
+
+client1.send('DROP TABLE test.lv')
+client1.expect(prompt)
+client1.send('DROP TABLE test.mt')
+client1.expect(prompt)
diff --git a/dbms/tests/queries/0_stateless/00970_live_view_watch_events_http_hearbeat.reference b/dbms/tests/queries/0_stateless/00970_live_view_watch_events_http_hearbeat.reference
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/dbms/tests/queries/0_stateless/00971_live_view_watch_http_hearbeat.py b/dbms/tests/queries/0_stateless/00971_live_view_watch_http_hearbeat.py
new file mode 100755
index 00000000000..33c937de649
--- /dev/null
+++ b/dbms/tests/queries/0_stateless/00971_live_view_watch_http_hearbeat.py
@@ -0,0 +1,57 @@
+#!/usr/bin/env python
+import imp
+import os
+import sys
+import signal
+
+CURDIR = os.path.dirname(os.path.realpath(__file__))
+
+uexpect = imp.load_source('uexpect', os.path.join(CURDIR, 'uexpect.py'))
+
+def client(name='', command=None):
+    if command is None:
+        client = uexpect.spawn(os.environ.get('CLICKHOUSE_CLIENT'))
+    else:
+        client = uexpect.spawn(command)
+    client.eol('\r')
+    # Note: uncomment this line for debugging
+    #client.logger(sys.stdout, prefix=name)
+    client.timeout(2)
+    return client
+
+prompt = ':\) '
+end_of_block = r'.*\xe2\x94\x82\r\n.*\xe2\x94\x98\r\n'
+client1 = client('client1>')
+client1.expect(prompt)
+
+client1.send('DROP TABLE IF EXISTS test.lv')
+client1.expect(prompt)
+client1.send(' DROP TABLE IF EXISTS test.mt')
+client1.expect(prompt)
+client1.send('CREATE TABLE test.mt (a Int32) Engine=MergeTree order by tuple()')
+client1.expect(prompt)
+client1.send('CREATE LIVE VIEW test.lv AS SELECT sum(a) FROM test.mt')
+client1.expect(prompt)
+
+client2 = client('client2>', ['bash', '--noediting'])
+client2.expect('\$ ')
+client2.send('wget -O- -q "http://localhost:8123/?live_view_heartbeat_interval=1&query=WATCH test.lv FORMAT JSONEachRowWithProgress"')
+client2.expect('"progress".*',)
+client2.expect('{"row":{"sum(a)":"0","_version":"1"}}\r\n', escape=True)
+client2.expect('"progress".*\r\n')
+# heartbeat is provided by progress message
+client2.expect('"progress".*\r\n')
+
+client1.send('INSERT INTO test.mt VALUES (1),(2),(3)')
+client1.expect(prompt)
+
+client2.expect('"progress".*"read_rows":"2".*\r\n')
+client2.expect('{"row":{"sum(a)":"6","_version":"2"}}\r\n', escape=True)
+
+## send Ctrl-C
+os.kill(client2.process.pid,signal.SIGINT)
+
+client1.send('DROP TABLE test.lv')
+client1.expect(prompt)
+client1.send('DROP TABLE test.mt')
+client1.expect(prompt)
diff --git a/dbms/tests/queries/0_stateless/00971_live_view_watch_http_hearbeat.reference b/dbms/tests/queries/0_stateless/00971_live_view_watch_http_hearbeat.reference
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/dbms/tests/queries/0_stateless/uexpect.py b/dbms/tests/queries/0_stateless/uexpect.py
index 412facb8389..f94a97addcc 100644
--- a/dbms/tests/queries/0_stateless/uexpect.py
+++ b/dbms/tests/queries/0_stateless/uexpect.py
@@ -132,7 +132,7 @@ class IO(object):
                 self.buffer = self.buffer[self.match.end():]
                 break
         if self._logger:
-            self._logger.write(self.before + self.after)
+            self._logger.write((self.before or '') + (self.after or ''))
             self._logger.flush()
         return self.match
 
@@ -159,14 +159,18 @@ def spawn(command):
     os.close(slave)
 
     queue = Queue()
-    thread = Thread(target=reader, args=(master, queue))
+    thread = Thread(target=reader, args=(process, master, queue))
     thread.daemon = True
     thread.start()
 
     return IO(process, master, queue)
 
-def reader(out, queue):
+def reader(process, out, queue):
     while True:
+        if process.poll() is not None:
+            data = os.read(out)
+            queue.put(data)
+            break
         data = os.read(out, 65536)
         queue.put(data)
 

From 4b68ffb15b0714372666bb46e86306227db3c436 Mon Sep 17 00:00:00 2001
From: Vitaliy Zakaznikov <vzakaznikov@protonmail.com>
Date: Fri, 7 Jun 2019 12:43:37 -0400
Subject: [PATCH 029/107] * Fixing typos in test names

---
 ...hearbeat.py => 00970_live_view_watch_events_http_heartbeat.py} | 0
 ...ence => 00970_live_view_watch_events_http_heartbeat.reference} | 0
 ...h_http_hearbeat.py => 00971_live_view_watch_http_heartbeat.py} | 0
 ...t.reference => 00971_live_view_watch_http_heartbeat.reference} | 0
 4 files changed, 0 insertions(+), 0 deletions(-)
 rename dbms/tests/queries/0_stateless/{00970_live_view_watch_events_http_hearbeat.py => 00970_live_view_watch_events_http_heartbeat.py} (100%)
 rename dbms/tests/queries/0_stateless/{00970_live_view_watch_events_http_hearbeat.reference => 00970_live_view_watch_events_http_heartbeat.reference} (100%)
 rename dbms/tests/queries/0_stateless/{00971_live_view_watch_http_hearbeat.py => 00971_live_view_watch_http_heartbeat.py} (100%)
 rename dbms/tests/queries/0_stateless/{00971_live_view_watch_http_hearbeat.reference => 00971_live_view_watch_http_heartbeat.reference} (100%)

diff --git a/dbms/tests/queries/0_stateless/00970_live_view_watch_events_http_hearbeat.py b/dbms/tests/queries/0_stateless/00970_live_view_watch_events_http_heartbeat.py
similarity index 100%
rename from dbms/tests/queries/0_stateless/00970_live_view_watch_events_http_hearbeat.py
rename to dbms/tests/queries/0_stateless/00970_live_view_watch_events_http_heartbeat.py
diff --git a/dbms/tests/queries/0_stateless/00970_live_view_watch_events_http_hearbeat.reference b/dbms/tests/queries/0_stateless/00970_live_view_watch_events_http_heartbeat.reference
similarity index 100%
rename from dbms/tests/queries/0_stateless/00970_live_view_watch_events_http_hearbeat.reference
rename to dbms/tests/queries/0_stateless/00970_live_view_watch_events_http_heartbeat.reference
diff --git a/dbms/tests/queries/0_stateless/00971_live_view_watch_http_hearbeat.py b/dbms/tests/queries/0_stateless/00971_live_view_watch_http_heartbeat.py
similarity index 100%
rename from dbms/tests/queries/0_stateless/00971_live_view_watch_http_hearbeat.py
rename to dbms/tests/queries/0_stateless/00971_live_view_watch_http_heartbeat.py
diff --git a/dbms/tests/queries/0_stateless/00971_live_view_watch_http_hearbeat.reference b/dbms/tests/queries/0_stateless/00971_live_view_watch_http_heartbeat.reference
similarity index 100%
rename from dbms/tests/queries/0_stateless/00971_live_view_watch_http_hearbeat.reference
rename to dbms/tests/queries/0_stateless/00971_live_view_watch_http_heartbeat.reference

From 5079180595678bf5a92e35a16e292db99b80a285 Mon Sep 17 00:00:00 2001
From: Vitaliy Zakaznikov <vzakaznikov@protonmail.com>
Date: Sat, 8 Jun 2019 09:26:02 -0400
Subject: [PATCH 030/107] * Fixing a bug in LIVE VIEW tables. Before when a
 table   is created with "AS SELECT 1" the SELECT and WATCH queries would fail
 * Adding and updating LIVE VIEW tests to increase coverage

---
 dbms/src/Storages/IStorage.h                           |  4 ++--
 dbms/src/Storages/ProxyStorage.h                       |  2 ++
 .../0_stateless/00953_live_view_select.reference       |  7 ++++---
 .../queries/0_stateless/00953_live_view_select.sql     | 10 ++++++++--
 .../0_stateless/00972_live_view_select_1.reference     |  2 ++
 .../queries/0_stateless/00972_live_view_select_1.sql   |  5 +++++
 6 files changed, 23 insertions(+), 7 deletions(-)
 create mode 100644 dbms/tests/queries/0_stateless/00972_live_view_select_1.reference
 create mode 100644 dbms/tests/queries/0_stateless/00972_live_view_select_1.sql

diff --git a/dbms/src/Storages/IStorage.h b/dbms/src/Storages/IStorage.h
index 96b0dbd63ab..a617db6a8ad 100644
--- a/dbms/src/Storages/IStorage.h
+++ b/dbms/src/Storages/IStorage.h
@@ -82,8 +82,8 @@ public:
 
 
 public: /// thread-unsafe part. lockStructure must be acquired
-    const ColumnsDescription & getColumns() const;
-    void setColumns(ColumnsDescription columns_);
+    virtual const ColumnsDescription & getColumns() const;
+    virtual void setColumns(ColumnsDescription columns_);
 
     const IndicesDescription & getIndices() const;
     void setIndices(IndicesDescription indices_);
diff --git a/dbms/src/Storages/ProxyStorage.h b/dbms/src/Storages/ProxyStorage.h
index a4196b7d6f2..3e6926eb323 100644
--- a/dbms/src/Storages/ProxyStorage.h
+++ b/dbms/src/Storages/ProxyStorage.h
@@ -47,6 +47,8 @@ public:
     Names getColumnsRequiredForSampling() const override { return storage->getColumnsRequiredForSampling(); }
     Names getColumnsRequiredForFinal() const override { return storage->getColumnsRequiredForFinal(); }
 
+    const ColumnsDescription & getColumns() const override { return storage->getColumns(); }
+    void setColumns(ColumnsDescription columns_) override { return storage->setColumns(columns_); }
     NameAndTypePair getColumn(const String & column_name) const override { return storage->getColumn(column_name); }
     bool hasColumn(const String & column_name) const override { return storage->hasColumn(column_name); }
     static StoragePtr createProxyStorage(StoragePtr storage, BlockInputStreams streams, QueryProcessingStage::Enum to_stage)
diff --git a/dbms/tests/queries/0_stateless/00953_live_view_select.reference b/dbms/tests/queries/0_stateless/00953_live_view_select.reference
index 9c44fe02ff1..7beda18cd83 100644
--- a/dbms/tests/queries/0_stateless/00953_live_view_select.reference
+++ b/dbms/tests/queries/0_stateless/00953_live_view_select.reference
@@ -1,4 +1,5 @@
 lv
-1
-2
-3
+6	1
+6	1
+12	2
+12	2
diff --git a/dbms/tests/queries/0_stateless/00953_live_view_select.sql b/dbms/tests/queries/0_stateless/00953_live_view_select.sql
index a51dfb112c1..492fa265b7d 100644
--- a/dbms/tests/queries/0_stateless/00953_live_view_select.sql
+++ b/dbms/tests/queries/0_stateless/00953_live_view_select.sql
@@ -2,13 +2,19 @@ DROP TABLE IF EXISTS test.lv;
 DROP TABLE IF EXISTS test.mt;
 
 CREATE TABLE test.mt (a Int32) Engine=MergeTree order by tuple();
-CREATE LIVE VIEW test.lv AS SELECT * FROM test.mt;
+CREATE LIVE VIEW test.lv AS SELECT sum(a) FROM test.mt;
 
 SHOW TABLES LIKE 'lv';
 
 INSERT INTO test.mt VALUES (1),(2),(3);
 
-SELECT * FROM test.lv;
+SELECT *,_version FROM test.lv;
+SELECT *,_version FROM test.lv;
+
+INSERT INTO test.mt VALUES (1),(2),(3);
+
+SELECT *,_version FROM test.lv;
+SELECT *,_version FROM test.lv;
 
 DROP TABLE test.lv;
 DROP TABLE test.mt;
diff --git a/dbms/tests/queries/0_stateless/00972_live_view_select_1.reference b/dbms/tests/queries/0_stateless/00972_live_view_select_1.reference
new file mode 100644
index 00000000000..f2f8c69d020
--- /dev/null
+++ b/dbms/tests/queries/0_stateless/00972_live_view_select_1.reference
@@ -0,0 +1,2 @@
+lv
+1
diff --git a/dbms/tests/queries/0_stateless/00972_live_view_select_1.sql b/dbms/tests/queries/0_stateless/00972_live_view_select_1.sql
new file mode 100644
index 00000000000..01bfeb08fd5
--- /dev/null
+++ b/dbms/tests/queries/0_stateless/00972_live_view_select_1.sql
@@ -0,0 +1,5 @@
+DROP TABLE IF EXISTS test.lv;
+CREATE LIVE VIEW test.lv AS SELECT 1;
+SHOW TABLES LIKE 'lv';
+SELECT * FROM test.lv;
+DROP TABLE test.lv;

From 137f5127ac3fc83b1322dfbe7fd71d0a6f8c0465 Mon Sep 17 00:00:00 2001
From: Vitaliy Zakaznikov <vzakaznikov@protonmail.com>
Date: Sat, 8 Jun 2019 09:54:48 -0400
Subject: [PATCH 031/107] * Renaming 00953_live_view_select test to avoid test
 number conflict

---
 ...ive_view_select.reference => 00973_live_view_select.reference} | 0
 .../{00953_live_view_select.sql => 00973_live_view_select.sql}    | 0
 2 files changed, 0 insertions(+), 0 deletions(-)
 rename dbms/tests/queries/0_stateless/{00953_live_view_select.reference => 00973_live_view_select.reference} (100%)
 rename dbms/tests/queries/0_stateless/{00953_live_view_select.sql => 00973_live_view_select.sql} (100%)

diff --git a/dbms/tests/queries/0_stateless/00953_live_view_select.reference b/dbms/tests/queries/0_stateless/00973_live_view_select.reference
similarity index 100%
rename from dbms/tests/queries/0_stateless/00953_live_view_select.reference
rename to dbms/tests/queries/0_stateless/00973_live_view_select.reference
diff --git a/dbms/tests/queries/0_stateless/00953_live_view_select.sql b/dbms/tests/queries/0_stateless/00973_live_view_select.sql
similarity index 100%
rename from dbms/tests/queries/0_stateless/00953_live_view_select.sql
rename to dbms/tests/queries/0_stateless/00973_live_view_select.sql

From 87b58e4150b086c100b6baee099664a19b726ca1 Mon Sep 17 00:00:00 2001
From: Vitaliy Zakaznikov <vzakaznikov@protonmail.com>
Date: Mon, 10 Jun 2019 07:18:33 -0400
Subject: [PATCH 032/107] * Fixing clang errors * Fixing LIVE VIEW tests

---
 .../PushingToViewsBlockOutputStream.cpp       |  2 +-
 dbms/src/Storages/IStorage.h                  |  2 +-
 dbms/src/Storages/StorageLiveView.h           |  8 +++---
 .../00966_live_view_watch_events_http.py      |  2 +-
 .../0_stateless/00967_live_view_watch_http.py |  2 +-
 ...0_live_view_watch_events_http_heartbeat.py |  3 +--
 .../00971_live_view_watch_http_heartbeat.py   |  2 +-
 dbms/tests/queries/0_stateless/uexpect.py     | 25 +++++++++++++------
 8 files changed, 27 insertions(+), 19 deletions(-)

diff --git a/dbms/src/DataStreams/PushingToViewsBlockOutputStream.cpp b/dbms/src/DataStreams/PushingToViewsBlockOutputStream.cpp
index 06f9a1edacf..c023670d4e1 100644
--- a/dbms/src/DataStreams/PushingToViewsBlockOutputStream.cpp
+++ b/dbms/src/DataStreams/PushingToViewsBlockOutputStream.cpp
@@ -86,7 +86,7 @@ void PushingToViewsBlockOutputStream::write(const Block & block)
 
     if (auto * live_view = dynamic_cast<StorageLiveView *>(storage.get()))
     {
-        BlockOutputStreamPtr output = std::make_shared<LiveViewBlockOutputStream>(*live_view);
+        output = std::make_shared<LiveViewBlockOutputStream>(*live_view);
         StorageLiveView::writeIntoLiveView(*live_view, block, context, output);
     }
     else
diff --git a/dbms/src/Storages/IStorage.h b/dbms/src/Storages/IStorage.h
index a617db6a8ad..4a63c1ef34a 100644
--- a/dbms/src/Storages/IStorage.h
+++ b/dbms/src/Storages/IStorage.h
@@ -60,7 +60,7 @@ public:
 
     /// The name of the table.
     virtual std::string getTableName() const = 0;
-    virtual std::string getDatabaseName() const { return {}; }  // FIXME: should be an abstract method!
+    virtual std::string getDatabaseName() const { return {}; }
 
     /// Returns true if the storage receives data from a remote server or servers.
     virtual bool isRemote() const { return false; }
diff --git a/dbms/src/Storages/StorageLiveView.h b/dbms/src/Storages/StorageLiveView.h
index 37faee4b266..56b48fe1154 100644
--- a/dbms/src/Storages/StorageLiveView.h
+++ b/dbms/src/Storages/StorageLiveView.h
@@ -47,7 +47,7 @@ public:
     ~StorageLiveView() override;
     String getName() const override { return "LiveView"; }
     String getTableName() const override { return table_name; }
-    String getDatabaseName() const { return database_name; }
+    String getDatabaseName() const override { return database_name; }
     String getSelectDatabaseName() const { return select_database_name; }
     String getSelectTableName() const { return select_table_name; }
 
@@ -55,7 +55,7 @@ public:
     bool hasColumn(const String & column_name) const override;
 
     // const NamesAndTypesList & getColumnsListImpl() const override { return *columns; }
-    ASTPtr getInnerQuery() const { return inner_query->clone(); };
+    ASTPtr getInnerQuery() const { return inner_query->clone(); }
 
     /// It is passed inside the query and solved at its level.
     bool supportsSampling() const override { return true; }
@@ -218,10 +218,10 @@ public:
             mergeable_blocks->push_back(new_mergeable_blocks);
 
             /// Create from blocks streams
-            for (auto & blocks : *mergeable_blocks)
+            for (auto & blocks_ : *mergeable_blocks)
             {
                 auto sample_block = mergeable_blocks->front()->front().cloneEmpty();
-                BlockInputStreamPtr stream = std::make_shared<BlocksBlockInputStream>(std::make_shared<BlocksPtr>(blocks), sample_block);
+                BlockInputStreamPtr stream = std::make_shared<BlocksBlockInputStream>(std::make_shared<BlocksPtr>(blocks_), sample_block);
                 from.push_back(std::move(stream));
             }
         }
diff --git a/dbms/tests/queries/0_stateless/00966_live_view_watch_events_http.py b/dbms/tests/queries/0_stateless/00966_live_view_watch_events_http.py
index be1cd220679..904d5214d5b 100755
--- a/dbms/tests/queries/0_stateless/00966_live_view_watch_events_http.py
+++ b/dbms/tests/queries/0_stateless/00966_live_view_watch_events_http.py
@@ -34,7 +34,7 @@ client1.send('CREATE LIVE VIEW test.lv AS SELECT sum(a) FROM test.mt')
 client1.expect(prompt)
 
 client2 = client('client2>', ['bash', '--noediting'])
-client2.expect('\$ ')
+client2.expect('[\$#] ')
 client2.send('wget -O- -q "http://localhost:8123/?query=WATCH test.lv EVENTS"')
 client2.expect('.*1\tc9d39b11cce79112219a73aaa319b475\r\n')
 
diff --git a/dbms/tests/queries/0_stateless/00967_live_view_watch_http.py b/dbms/tests/queries/0_stateless/00967_live_view_watch_http.py
index 0a844579f5d..4363b453852 100755
--- a/dbms/tests/queries/0_stateless/00967_live_view_watch_http.py
+++ b/dbms/tests/queries/0_stateless/00967_live_view_watch_http.py
@@ -34,7 +34,7 @@ client1.send('CREATE LIVE VIEW test.lv AS SELECT sum(a) FROM test.mt')
 client1.expect(prompt)
 
 client2 = client('client2>', ['bash', '--noediting'])
-client2.expect('\$ ')
+client2.expect('[\$#] ')
 client2.send('wget -O- -q "http://localhost:8123/?query=WATCH test.lv"')
 client2.expect('.*0\t1\r\n')
 
diff --git a/dbms/tests/queries/0_stateless/00970_live_view_watch_events_http_heartbeat.py b/dbms/tests/queries/0_stateless/00970_live_view_watch_events_http_heartbeat.py
index 1021edd7769..f96cac1e1c7 100755
--- a/dbms/tests/queries/0_stateless/00970_live_view_watch_events_http_heartbeat.py
+++ b/dbms/tests/queries/0_stateless/00970_live_view_watch_events_http_heartbeat.py
@@ -34,7 +34,7 @@ client1.send('CREATE LIVE VIEW test.lv AS SELECT sum(a) FROM test.mt')
 client1.expect(prompt)
 
 client2 = client('client2>', ['bash', '--noediting'])
-client2.expect('\$ ')
+client2.expect('[\$#] ')
 client2.send('wget -O- -q "http://localhost:8123/?live_view_heartbeat_interval=1&query=WATCH test.lv EVENTS FORMAT JSONEachRowWithProgress"')
 client2.expect('{"progress":{"read_rows":"1","read_bytes":"49","written_rows":"0","written_bytes":"0","total_rows_to_read":"0"}}\r\n', escape=True)
 client2.expect('{"row":{"version":"1","hash":"c9d39b11cce79112219a73aaa319b475"}}', escape=True)
@@ -47,7 +47,6 @@ client1.expect(prompt)
 
 client2.expect('{"row":{"version":"2","hash":"4cd0592103888d4682de9a32a23602e3"}}\r\n', escape=True)
 
-client2.expect('.*2\t.*\r\n')
 ## send Ctrl-C
 os.kill(client2.process.pid,signal.SIGINT)
 
diff --git a/dbms/tests/queries/0_stateless/00971_live_view_watch_http_heartbeat.py b/dbms/tests/queries/0_stateless/00971_live_view_watch_http_heartbeat.py
index 33c937de649..cb8cf8f5582 100755
--- a/dbms/tests/queries/0_stateless/00971_live_view_watch_http_heartbeat.py
+++ b/dbms/tests/queries/0_stateless/00971_live_view_watch_http_heartbeat.py
@@ -34,7 +34,7 @@ client1.send('CREATE LIVE VIEW test.lv AS SELECT sum(a) FROM test.mt')
 client1.expect(prompt)
 
 client2 = client('client2>', ['bash', '--noediting'])
-client2.expect('\$ ')
+client2.expect('[\$#] ')
 client2.send('wget -O- -q "http://localhost:8123/?live_view_heartbeat_interval=1&query=WATCH test.lv FORMAT JSONEachRowWithProgress"')
 client2.expect('"progress".*',)
 client2.expect('{"row":{"sum(a)":"0","_version":"1"}}\r\n', escape=True)
diff --git a/dbms/tests/queries/0_stateless/uexpect.py b/dbms/tests/queries/0_stateless/uexpect.py
index f94a97addcc..dc77161d72f 100644
--- a/dbms/tests/queries/0_stateless/uexpect.py
+++ b/dbms/tests/queries/0_stateless/uexpect.py
@@ -37,8 +37,8 @@ class ExpectTimeoutError(Exception):
     def __str__(self):
         return ('Timeout %.3fs ' % float(self.timeout) +
             'for %s ' % repr(self.pattern.pattern) +
-            'buffer ends with %s ' % repr(self.buffer[-80:]) +
-            'or \'%s\'' % ','.join(['%x' % ord(c) for c in self.buffer[-80:]]))
+            'buffer %s ' % repr(self.buffer[:]) +
+            'or \'%s\'' % ','.join(['%x' % ord(c) for c in self.buffer[:]]))
 
 class IO(object):
     class EOF(object):
@@ -111,10 +111,11 @@ class IO(object):
         pattern = re.compile(pattern)
         if timeout is None:
             timeout = self._timeout
-        while timeout >= 0:
+        timeleft = timeout
+        while timeleft >= 0:
             start_time = time.time()
             try:
-                data = self.read(timeout=timeout, raise_exception=True)
+                data = self.read(timeout=timeleft, raise_exception=True)
             except TimeoutError:
                 if self._logger:
                     self._logger.write(self.buffer + '\n')
@@ -122,7 +123,7 @@ class IO(object):
                 exception = ExpectTimeoutError(pattern, timeout, self.buffer)
                 self.buffer = None
                 raise exception
-            timeout -= (time.time() - start_time)
+            timeleft -= (time.time() - start_time)
             if data:
                 self.buffer = self.buffer + data if self.buffer else data
             self.match = pattern.search(self.buffer, 0)
@@ -134,23 +135,31 @@ class IO(object):
         if self._logger:
             self._logger.write((self.before or '') + (self.after or ''))
             self._logger.flush()
+        if self.match is None:
+            exception = ExpectTimeoutError(pattern, timeout, self.buffer)
+            self.buffer = None
+            raise exception
         return self.match
 
     def read(self, timeout=0, raise_exception=False):
         data = ''
+        timeleft = timeout
         try:
-            while timeout >= 0 :
+            while timeleft >= 0 :
                 start_time = time.time()
-                data += self.queue.get(timeout=timeout)
+                data += self.queue.get(timeout=timeleft)
                 if data:
                     break
-                timeout -= (time.time() - start_time)
+                timeleft -= (time.time() - start_time)
         except Empty:
             if data:
                 return data
             if raise_exception:
                 raise TimeoutError(timeout)
             pass
+        if not data and raise_exception:
+            raise TimeoutError(timeout)
+
         return data
 
 def spawn(command):

From a68980ab385d61dcb1e744a855e3053581b9fb90 Mon Sep 17 00:00:00 2001
From: Vitaliy Zakaznikov <vzakaznikov@protonmail.com>
Date: Mon, 10 Jun 2019 07:41:33 -0400
Subject: [PATCH 033/107] * Style check fixes

---
 .../DataStreams/LiveViewBlockInputStream.h    |  7 +++----
 .../LiveViewEventsBlockInputStream.h          | 13 ++++++------
 .../Interpreters/InterpreterAlterQuery.cpp    | 20 +++++++++----------
 dbms/src/Parsers/ParserAlterQuery.cpp         |  4 +++-
 dbms/src/Storages/StorageLiveView.cpp         |  4 ++--
 dbms/src/Storages/StorageLiveView.h           |  3 ++-
 6 files changed, 27 insertions(+), 24 deletions(-)

diff --git a/dbms/src/DataStreams/LiveViewBlockInputStream.h b/dbms/src/DataStreams/LiveViewBlockInputStream.h
index 93eae976177..6129c836597 100644
--- a/dbms/src/DataStreams/LiveViewBlockInputStream.h
+++ b/dbms/src/DataStreams/LiveViewBlockInputStream.h
@@ -46,7 +46,7 @@ public:
         std::shared_ptr<bool> active_ptr_, Poco::Condition & condition_, Poco::FastMutex & mutex_,
         int64_t length_, const UInt64 & heartbeat_interval_,
         const UInt64 & temporary_live_view_timeout_)
-        : storage(storage_), blocks_ptr(blocks_ptr_), blocks_metadata_ptr(blocks_metadata_ptr_), active_ptr(active_ptr_), condition(condition_), mutex(mutex_), length(length_ + 1), heartbeat_interval(heartbeat_interval_), temporary_live_view_timeout(temporary_live_view_timeout_),
+        : storage(storage_), blocks_ptr(blocks_ptr_), blocks_metadata_ptr(blocks_metadata_ptr_), active_ptr(active_ptr_), condition(condition_), mutex(mutex_), length(length_ + 1), heartbeat_interval(heartbeat_interval_ * 1000000), temporary_live_view_timeout(temporary_live_view_timeout_),
         blocks_hash("")
     {
         /// grab active pointer
@@ -160,9 +160,8 @@ protected:
                     }
                     while (true)
                     {
-                        bool signaled = condition.tryWait(mutex, 
-                            std::max((UInt64)0, (heartbeat_interval * 1000000) - 
-                            ((UInt64)timestamp.epochMicroseconds() - last_event_timestamp)) / 1000);
+                        UInt64 timestamp_usec = (UInt64)timestamp.epochMicroseconds();
+                        bool signaled = condition.tryWait(mutex, std::max((UInt64)0, heartbeat_interval - (timestamp_usec - last_event_timestamp)) / 1000);
 
                         if (isCancelled() || storage.is_dropped)
                         {
diff --git a/dbms/src/DataStreams/LiveViewEventsBlockInputStream.h b/dbms/src/DataStreams/LiveViewEventsBlockInputStream.h
index d0f92806d74..35d2545419b 100644
--- a/dbms/src/DataStreams/LiveViewEventsBlockInputStream.h
+++ b/dbms/src/DataStreams/LiveViewEventsBlockInputStream.h
@@ -47,7 +47,7 @@ public:
     /// and LIMIT 0 just returns data without waiting for any updates
     LiveViewEventsBlockInputStream(StorageLiveView & storage_, std::shared_ptr<BlocksPtr> blocks_ptr_, std::shared_ptr<BlocksMetadataPtr> blocks_metadata_ptr_, std::shared_ptr<bool> active_ptr_, Poco::Condition & condition_, Poco::FastMutex & mutex_,
         int64_t length_, const UInt64 & heartbeat_interval_, const UInt64 & temporary_live_view_timeout_)
-        : storage(storage_), blocks_ptr(blocks_ptr_), blocks_metadata_ptr(blocks_metadata_ptr_), active_ptr(active_ptr_), condition(condition_), mutex(mutex_), length(length_ + 1), heartbeat_interval(heartbeat_interval_), temporary_live_view_timeout(temporary_live_view_timeout_)
+        : storage(storage_), blocks_ptr(blocks_ptr_), blocks_metadata_ptr(blocks_metadata_ptr_), active_ptr(active_ptr_), condition(condition_), mutex(mutex_), length(length_ + 1), heartbeat_interval(heartbeat_interval_ * 1000000), temporary_live_view_timeout(temporary_live_view_timeout_)
     {
         /// grab active pointer
         active = active_ptr.lock();
@@ -64,7 +64,8 @@ public:
         condition.broadcast();
     }
 
-    Block getHeader() const override {
+    Block getHeader() const override 
+    {
         return {
             ColumnWithTypeAndName(
                 ColumnUInt64::create(),
@@ -92,7 +93,8 @@ public:
     {
         active = active_ptr.lock();
         {
-            if (!blocks || blocks.get() != (*blocks_ptr).get()) {
+            if (!blocks || blocks.get() != (*blocks_ptr).get()) 
+            {
                 blocks = (*blocks_ptr);
                 blocks_metadata = (*blocks_metadata_ptr);
             }
@@ -188,9 +190,8 @@ protected:
                     }
                     while (true)
                     {
-                        bool signaled = condition.tryWait(mutex, 
-                            std::max((UInt64)0, (heartbeat_interval * 1000000) - 
-			    ((UInt64)timestamp.epochMicroseconds() - last_event_timestamp)) / 1000);
+                        UInt64 timestamp_usec = (UInt64)timestamp.epochMicroseconds();
+                        bool signaled = condition.tryWait(mutex, std::max((UInt64)0, heartbeat_interval - (timestamp_usec - last_event_timestamp)) / 1000);
 
                         if (isCancelled() || storage.is_dropped)
                         {
diff --git a/dbms/src/Interpreters/InterpreterAlterQuery.cpp b/dbms/src/Interpreters/InterpreterAlterQuery.cpp
index 6d2fc61f080..e8f3e4f4553 100644
--- a/dbms/src/Interpreters/InterpreterAlterQuery.cpp
+++ b/dbms/src/Interpreters/InterpreterAlterQuery.cpp
@@ -79,17 +79,17 @@ BlockIO InterpreterAlterQuery::execute()
 
     if (!live_view_commands.empty())
     {
-	    live_view_commands.validate(*table);
-	    for (const LiveViewCommand & command : live_view_commands)
-	    {
-		auto live_view = std::dynamic_pointer_cast<StorageLiveView>(table);
-		switch (command.type)
-		{
-		    case LiveViewCommand::REFRESH:
-		        live_view->refresh(context);
-		        break;
-                }
+        live_view_commands.validate(*table);
+	for (const LiveViewCommand & command : live_view_commands)
+        {
+            auto live_view = std::dynamic_pointer_cast<StorageLiveView>(table);
+            switch (command.type)
+            {
+                case LiveViewCommand::REFRESH:
+                    live_view->refresh(context);
+                    break;
             }
+        }
     }
 
     if (!alter_commands.empty())
diff --git a/dbms/src/Parsers/ParserAlterQuery.cpp b/dbms/src/Parsers/ParserAlterQuery.cpp
index f8803cc3bc8..58a3b3a388b 100644
--- a/dbms/src/Parsers/ParserAlterQuery.cpp
+++ b/dbms/src/Parsers/ParserAlterQuery.cpp
@@ -446,10 +446,12 @@ bool ParserAlterQuery::parseImpl(Pos & pos, ASTPtr & node, Expected & expected)
     if (!s_alter_table.ignore(pos, expected))
     {
         if (!s_alter_live_view.ignore(pos, expected))
-	        if (!s_alter_live_channel.ignore(pos, expected))
+        {
+            if (!s_alter_live_channel.ignore(pos, expected))
                 return false;
             else
                 is_live_channel = true;
+        }
         else
             is_live_view = true;
     }
diff --git a/dbms/src/Storages/StorageLiveView.cpp b/dbms/src/Storages/StorageLiveView.cpp
index 108e146dc73..dd6e0179410 100644
--- a/dbms/src/Storages/StorageLiveView.cpp
+++ b/dbms/src/Storages/StorageLiveView.cpp
@@ -141,7 +141,7 @@ StorageLiveView::StorageLiveView(
 
 NameAndTypePair StorageLiveView::getColumn(const String & column_name) const
 {
-    if ( column_name == "_version" )
+    if (column_name == "_version")
         return NameAndTypePair("_version", std::make_shared<DataTypeUInt64>());
 
     return IStorage::getColumn(column_name);
@@ -149,7 +149,7 @@ NameAndTypePair StorageLiveView::getColumn(const String & column_name) const
 
 bool StorageLiveView::hasColumn(const String & column_name) const
 {
-    if ( column_name == "_version" )
+    if (column_name == "_version")
         return true;
 
     return IStorage::hasColumn(column_name);
diff --git a/dbms/src/Storages/StorageLiveView.h b/dbms/src/Storages/StorageLiveView.h
index 56b48fe1154..fb250aec859 100644
--- a/dbms/src/Storages/StorageLiveView.h
+++ b/dbms/src/Storages/StorageLiveView.h
@@ -30,7 +30,8 @@ namespace DB
 class IAST;
 using ASTPtr = std::shared_ptr<IAST>;
 
-struct BlocksMetadata {
+struct BlocksMetadata 
+{
     String hash;
     UInt64 version;
 };

From fc4ea55b98ebd1f4c9a2d6fb0f1fed5a00deade6 Mon Sep 17 00:00:00 2001
From: Vitaliy Zakaznikov <vzakaznikov@protonmail.com>
Date: Mon, 10 Jun 2019 08:11:43 -0400
Subject: [PATCH 034/107] * Fixing bug in
 dbms/src/DataStreams/PushingToViewsBlockOutputStream.cpp   that was
 introduced when trying to fix a clang error.

---
 dbms/src/DataStreams/PushingToViewsBlockOutputStream.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/dbms/src/DataStreams/PushingToViewsBlockOutputStream.cpp b/dbms/src/DataStreams/PushingToViewsBlockOutputStream.cpp
index c023670d4e1..f361420de95 100644
--- a/dbms/src/DataStreams/PushingToViewsBlockOutputStream.cpp
+++ b/dbms/src/DataStreams/PushingToViewsBlockOutputStream.cpp
@@ -86,8 +86,8 @@ void PushingToViewsBlockOutputStream::write(const Block & block)
 
     if (auto * live_view = dynamic_cast<StorageLiveView *>(storage.get()))
     {
-        output = std::make_shared<LiveViewBlockOutputStream>(*live_view);
-        StorageLiveView::writeIntoLiveView(*live_view, block, context, output);
+        BlockOutputStreamPtr output_ = std::make_shared<LiveViewBlockOutputStream>(*live_view);
+        StorageLiveView::writeIntoLiveView(*live_view, block, context, output_);
     }
     else
     {

From 1ebe3047ffc6719b4f817a25ea66a8d2f9ee47ac Mon Sep 17 00:00:00 2001
From: Vitaliy Zakaznikov <vzakaznikov@protonmail.com>
Date: Mon, 10 Jun 2019 18:12:06 -0400
Subject: [PATCH 035/107] * Moving uexpect.py to dbms/tests/integration/helpers
 folder * Updating uexpect.py to support close() method and   context manager
 for proper resource cleanup * Updating tests to use uexpect context manager

---
 .../helpers}/uexpect.py                       | 10 +++
 .../0_stateless/00958_live_view_watch_live.py | 49 +++++++--------
 .../00960_live_view_watch_events_live.py      | 49 +++++++--------
 .../00962_temporary_live_view_watch_live.py   | 49 +++++++--------
 ..._temporary_live_view_watch_live_timeout.py | 63 +++++++++----------
 .../00964_live_view_watch_events_heartbeat.py | 55 ++++++++--------
 .../00965_live_view_watch_heartbeat.py        | 55 ++++++++--------
 .../00966_live_view_watch_events_http.py      | 48 +++++++-------
 .../0_stateless/00967_live_view_watch_http.py | 48 +++++++-------
 ...0_live_view_watch_events_http_heartbeat.py | 56 ++++++++---------
 .../00971_live_view_watch_http_heartbeat.py   | 58 ++++++++---------
 11 files changed, 272 insertions(+), 268 deletions(-)
 rename dbms/tests/{queries/0_stateless => integration/helpers}/uexpect.py (95%)

diff --git a/dbms/tests/queries/0_stateless/uexpect.py b/dbms/tests/integration/helpers/uexpect.py
similarity index 95%
rename from dbms/tests/queries/0_stateless/uexpect.py
rename to dbms/tests/integration/helpers/uexpect.py
index dc77161d72f..58be8f60ff8 100644
--- a/dbms/tests/queries/0_stateless/uexpect.py
+++ b/dbms/tests/integration/helpers/uexpect.py
@@ -74,6 +74,12 @@ class IO(object):
         self._logger = None
         self._eol = ''
 
+    def __enter__(self):
+        return self
+
+    def __exit__(self, type, value, traceback):
+        self.close()
+
     def logger(self, logger=None, prefix=''):
         if logger:
             self._logger = self.Logger(logger, prefix=prefix)
@@ -90,6 +96,8 @@ class IO(object):
         return self._eol
 
     def close(self):
+        self.process.terminate()
+        os.close(self.master)
         if self._logger:
             self._logger.write('\n')
             self._logger.flush()
@@ -155,9 +163,11 @@ class IO(object):
             if data:
                 return data
             if raise_exception:
+                print 'DEBUG...', timeleft, repr(data),
                 raise TimeoutError(timeout)
             pass
         if not data and raise_exception:
+            print 'DEBUG.... here'
             raise TimeoutError(timeout)
 
         return data
diff --git a/dbms/tests/queries/0_stateless/00958_live_view_watch_live.py b/dbms/tests/queries/0_stateless/00958_live_view_watch_live.py
index 9fb58cb556c..b60e82299f7 100755
--- a/dbms/tests/queries/0_stateless/00958_live_view_watch_live.py
+++ b/dbms/tests/queries/0_stateless/00958_live_view_watch_live.py
@@ -6,7 +6,7 @@ import signal
 
 CURDIR = os.path.dirname(os.path.realpath(__file__))
 
-uexpect = imp.load_source('uexpect', os.path.join(CURDIR, 'uexpect.py'))
+uexpect = imp.load_source('uexpect', os.path.join(CURDIR, '..', '..', 'integration', 'helpers', 'uexpect.py'))
 
 def client(name=''):
     client = uexpect.spawn(os.environ.get('CLICKHOUSE_CLIENT'))
@@ -18,29 +18,28 @@ def client(name=''):
 
 prompt = ':\) '
 end_of_block = r'.*\xe2\x94\x82\r\n.*\xe2\x94\x98\r\n'
-client1 = client('client1>')
-client2 = client('client2>')
 
-client1.expect(prompt)
-client2.expect(prompt)
+with client('client1>') as client1, client('client2>') as client2:
+    client1.expect(prompt)
+    client2.expect(prompt)
 
-client1.send('DROP TABLE IF EXISTS test.lv')
-client1.expect(prompt)
-client1.send(' DROP TABLE IF EXISTS test.mt')
-client1.expect(prompt)
-client1.send('CREATE TABLE test.mt (a Int32) Engine=MergeTree order by tuple()')
-client1.expect(prompt)
-client1.send('CREATE LIVE VIEW test.lv AS SELECT sum(a) FROM test.mt')
-client1.expect(prompt)
-client1.send('WATCH test.lv')
-client2.send('INSERT INTO test.mt VALUES (1),(2),(3)')
-client1.expect(r'6.*2' + end_of_block)
-client2.send('INSERT INTO test.mt VALUES (4),(5),(6)')
-client1.expect(r'21.*3' + end_of_block)
-# send Ctrl-C
-os.kill(client1.process.pid,signal.SIGINT)
-client1.expect(prompt)
-client1.send('DROP TABLE test.lv')
-client1.expect(prompt)
-client1.send('DROP TABLE test.mt')
-client1.expect(prompt)
+    client1.send('DROP TABLE IF EXISTS test.lv')
+    client1.expect(prompt)
+    client1.send(' DROP TABLE IF EXISTS test.mt')
+    client1.expect(prompt)
+    client1.send('CREATE TABLE test.mt (a Int32) Engine=MergeTree order by tuple()')
+    client1.expect(prompt)
+    client1.send('CREATE LIVE VIEW test.lv AS SELECT sum(a) FROM test.mt')
+    client1.expect(prompt)
+    client1.send('WATCH test.lv')
+    client2.send('INSERT INTO test.mt VALUES (1),(2),(3)')
+    client1.expect(r'6.*2' + end_of_block)
+    client2.send('INSERT INTO test.mt VALUES (4),(5),(6)')
+    client1.expect(r'21.*3' + end_of_block)
+    # send Ctrl-C
+    os.kill(client1.process.pid,signal.SIGINT)
+    client1.expect(prompt)
+    client1.send('DROP TABLE test.lv')
+    client1.expect(prompt)
+    client1.send('DROP TABLE test.mt')
+    client1.expect(prompt)
diff --git a/dbms/tests/queries/0_stateless/00960_live_view_watch_events_live.py b/dbms/tests/queries/0_stateless/00960_live_view_watch_events_live.py
index fa96331e3fb..9fdabd499d0 100755
--- a/dbms/tests/queries/0_stateless/00960_live_view_watch_events_live.py
+++ b/dbms/tests/queries/0_stateless/00960_live_view_watch_events_live.py
@@ -6,7 +6,7 @@ import signal
 
 CURDIR = os.path.dirname(os.path.realpath(__file__))
 
-uexpect = imp.load_source('uexpect', os.path.join(CURDIR, 'uexpect.py'))
+uexpect = imp.load_source('uexpect', os.path.join(CURDIR, '..', '..', 'integration', 'helpers', 'uexpect.py'))
 
 def client(name=''):
     client = uexpect.spawn(os.environ.get('CLICKHOUSE_CLIENT'))
@@ -18,29 +18,28 @@ def client(name=''):
 
 prompt = ':\) '
 end_of_block = r'.*\xe2\x94\x82\r\n.*\xe2\x94\x98\r\n'
-client1 = client('client1>')
-client2 = client('client2>')
 
-client1.expect(prompt)
-client2.expect(prompt)
+with client('client1>') as client1, client('client2>') as client2:
+    client1.expect(prompt)
+    client2.expect(prompt)
 
-client1.send('DROP TABLE IF EXISTS test.lv')
-client1.expect(prompt)
-client1.send(' DROP TABLE IF EXISTS test.mt')
-client1.expect(prompt)
-client1.send('CREATE TABLE test.mt (a Int32) Engine=MergeTree order by tuple()')
-client1.expect(prompt)
-client1.send('CREATE LIVE VIEW test.lv AS SELECT sum(a) FROM test.mt')
-client1.expect(prompt)
-client1.send('WATCH test.lv EVENTS')
-client2.send('INSERT INTO test.mt VALUES (1),(2),(3)')
-client1.expect('2.*4cd0592103888d4682de9a32a23602e3' + end_of_block)
-client2.send('INSERT INTO test.mt VALUES (4),(5),(6)')
-client1.expect('3.*2186dbea325ee4c56b67e9b792e993a3' + end_of_block)
-# send Ctrl-C
-os.kill(client1.process.pid,signal.SIGINT)
-client1.expect(prompt)
-client1.send('DROP TABLE test.lv')
-client1.expect(prompt)
-client1.send('DROP TABLE test.mt')
-client1.expect(prompt)
+    client1.send('DROP TABLE IF EXISTS test.lv')
+    client1.expect(prompt)
+    client1.send(' DROP TABLE IF EXISTS test.mt')
+    client1.expect(prompt)
+    client1.send('CREATE TABLE test.mt (a Int32) Engine=MergeTree order by tuple()')
+    client1.expect(prompt)
+    client1.send('CREATE LIVE VIEW test.lv AS SELECT sum(a) FROM test.mt')
+    client1.expect(prompt)
+    client1.send('WATCH test.lv EVENTS')
+    client2.send('INSERT INTO test.mt VALUES (1),(2),(3)')
+    client1.expect('2.*4cd0592103888d4682de9a32a23602e3' + end_of_block)
+    client2.send('INSERT INTO test.mt VALUES (4),(5),(6)')
+    client1.expect('3.*2186dbea325ee4c56b67e9b792e993a3' + end_of_block)
+    # send Ctrl-C
+    os.kill(client1.process.pid,signal.SIGINT)
+    client1.expect(prompt)
+    client1.send('DROP TABLE test.lv')
+    client1.expect(prompt)
+    client1.send('DROP TABLE test.mt')
+    client1.expect(prompt)
diff --git a/dbms/tests/queries/0_stateless/00962_temporary_live_view_watch_live.py b/dbms/tests/queries/0_stateless/00962_temporary_live_view_watch_live.py
index 0b0260adeed..0e7c3c43254 100755
--- a/dbms/tests/queries/0_stateless/00962_temporary_live_view_watch_live.py
+++ b/dbms/tests/queries/0_stateless/00962_temporary_live_view_watch_live.py
@@ -6,7 +6,7 @@ import signal
 
 CURDIR = os.path.dirname(os.path.realpath(__file__))
 
-uexpect = imp.load_source('uexpect', os.path.join(CURDIR, 'uexpect.py'))
+uexpect = imp.load_source('uexpect', os.path.join(CURDIR, '..', '..', 'integration', 'helpers', 'uexpect.py'))
 
 def client(name=''):
     client = uexpect.spawn(os.environ.get('CLICKHOUSE_CLIENT'))
@@ -18,29 +18,28 @@ def client(name=''):
 
 prompt = ':\) '
 end_of_block = r'.*\xe2\x94\x82\r\n.*\xe2\x94\x98\r\n'
-client1 = client('client1>')
-client2 = client('client2>')
 
-client1.expect(prompt)
-client2.expect(prompt)
+with client('client1>') as client1, client('client2>') as client2:
+    client1.expect(prompt)
+    client2.expect(prompt)
 
-client1.send('DROP TABLE IF EXISTS test.lv')
-client1.expect(prompt)
-client1.send(' DROP TABLE IF EXISTS test.mt')
-client1.expect(prompt)
-client1.send('CREATE TABLE test.mt (a Int32) Engine=MergeTree order by tuple()')
-client1.expect(prompt)
-client1.send('CREATE TEMPORARY LIVE VIEW test.lv AS SELECT sum(a) FROM test.mt')
-client1.expect(prompt)
-client1.send('WATCH test.lv')
-client2.send('INSERT INTO test.mt VALUES (1),(2),(3)')
-client1.expect(r'6.*2' + end_of_block)
-client2.send('INSERT INTO test.mt VALUES (4),(5),(6)')
-client1.expect(r'21.*3' + end_of_block)
-# send Ctrl-C
-os.kill(client1.process.pid,signal.SIGINT)
-client1.expect(prompt)
-client1.send('DROP TABLE test.lv')
-client1.expect(prompt)
-client1.send('DROP TABLE test.mt')
-client1.expect(prompt)
+    client1.send('DROP TABLE IF EXISTS test.lv')
+    client1.expect(prompt)
+    client1.send(' DROP TABLE IF EXISTS test.mt')
+    client1.expect(prompt)
+    client1.send('CREATE TABLE test.mt (a Int32) Engine=MergeTree order by tuple()')
+    client1.expect(prompt)
+    client1.send('CREATE TEMPORARY LIVE VIEW test.lv AS SELECT sum(a) FROM test.mt')
+    client1.expect(prompt)
+    client1.send('WATCH test.lv')
+    client2.send('INSERT INTO test.mt VALUES (1),(2),(3)')
+    client1.expect(r'6.*2' + end_of_block)
+    client2.send('INSERT INTO test.mt VALUES (4),(5),(6)')
+    client1.expect(r'21.*3' + end_of_block)
+    # send Ctrl-C
+    os.kill(client1.process.pid,signal.SIGINT)
+    client1.expect(prompt)
+    client1.send('DROP TABLE test.lv')
+    client1.expect(prompt)
+    client1.send('DROP TABLE test.mt')
+    client1.expect(prompt)
diff --git a/dbms/tests/queries/0_stateless/00963_temporary_live_view_watch_live_timeout.py b/dbms/tests/queries/0_stateless/00963_temporary_live_view_watch_live_timeout.py
index 29ec01c724a..b3f6809ded0 100755
--- a/dbms/tests/queries/0_stateless/00963_temporary_live_view_watch_live_timeout.py
+++ b/dbms/tests/queries/0_stateless/00963_temporary_live_view_watch_live_timeout.py
@@ -6,7 +6,7 @@ import signal
 
 CURDIR = os.path.dirname(os.path.realpath(__file__))
 
-uexpect = imp.load_source('uexpect', os.path.join(CURDIR, 'uexpect.py'))
+uexpect = imp.load_source('uexpect', os.path.join(CURDIR, '..', '..', 'integration', 'helpers', 'uexpect.py'))
 
 def client(name=''):
     client = uexpect.spawn(os.environ.get('CLICKHOUSE_CLIENT'))
@@ -18,36 +18,35 @@ def client(name=''):
 
 prompt = ':\) '
 end_of_block = r'.*\xe2\x94\x82\r\n.*\xe2\x94\x98\r\n'
-client1 = client('client1>')
-client2 = client('client2>')
 
-client1.expect(prompt)
-client2.expect(prompt)
+with client('client1>') as client1, client('client2>') as client2:
+    client1.expect(prompt)
+    client2.expect(prompt)
 
-client1.send('DROP TABLE IF EXISTS test.lv')
-client1.expect(prompt)
-client1.send('DROP TABLE IF EXISTS test.mt')
-client1.expect(prompt)
-client1.send('SET temporary_live_view_timeout=1')
-client1.expect(prompt)
-client1.send('CREATE TABLE test.mt (a Int32) Engine=MergeTree order by tuple()')
-client1.expect(prompt)
-client1.send('CREATE TEMPORARY LIVE VIEW test.lv AS SELECT sum(a) FROM test.mt')
-client1.expect(prompt)
-client1.send('WATCH test.lv')
-client2.send('INSERT INTO test.mt VALUES (1),(2),(3)')
-client2.expect(prompt)
-client1.expect(r'6.*2' + end_of_block)
-client2.send('INSERT INTO test.mt VALUES (4),(5),(6)')
-client2.expect(prompt)
-client1.expect(r'21.*3' + end_of_block)
-# send Ctrl-C
-os.kill(client1.process.pid,signal.SIGINT)
-client1.expect(prompt)
-client1.send('SELECT sleep(1)')
-client1.expect(prompt)
-client1.send('DROP TABLE test.lv')
-client1.expect('Table test.lv doesn\'t exist')
-client1.expect(prompt)
-client1.send('DROP TABLE test.mt')
-client1.expect(prompt)
+    client1.send('DROP TABLE IF EXISTS test.lv')
+    client1.expect(prompt)
+    client1.send('DROP TABLE IF EXISTS test.mt')
+    client1.expect(prompt)
+    client1.send('SET temporary_live_view_timeout=1')
+    client1.expect(prompt)
+    client1.send('CREATE TABLE test.mt (a Int32) Engine=MergeTree order by tuple()')
+    client1.expect(prompt)
+    client1.send('CREATE TEMPORARY LIVE VIEW test.lv AS SELECT sum(a) FROM test.mt')
+    client1.expect(prompt)
+    client1.send('WATCH test.lv')
+    client2.send('INSERT INTO test.mt VALUES (1),(2),(3)')
+    client2.expect(prompt)
+    client1.expect(r'6.*2' + end_of_block)
+    client2.send('INSERT INTO test.mt VALUES (4),(5),(6)')
+    client2.expect(prompt)
+    client1.expect(r'21.*3' + end_of_block)
+    # send Ctrl-C
+    os.kill(client1.process.pid,signal.SIGINT)
+    client1.expect(prompt, timeout=5)
+    client1.send('SELECT sleep(1)')
+    client1.expect(prompt)
+    client1.send('DROP TABLE test.lv')
+    client1.expect('Table test.lv doesn\'t exist')
+    client1.expect(prompt)
+    client1.send('DROP TABLE test.mt')
+    client1.expect(prompt)
diff --git a/dbms/tests/queries/0_stateless/00964_live_view_watch_events_heartbeat.py b/dbms/tests/queries/0_stateless/00964_live_view_watch_events_heartbeat.py
index cbb659f1292..1e66daef953 100755
--- a/dbms/tests/queries/0_stateless/00964_live_view_watch_events_heartbeat.py
+++ b/dbms/tests/queries/0_stateless/00964_live_view_watch_events_heartbeat.py
@@ -6,7 +6,7 @@ import signal
 
 CURDIR = os.path.dirname(os.path.realpath(__file__))
 
-uexpect = imp.load_source('uexpect', os.path.join(CURDIR, 'uexpect.py'))
+uexpect = imp.load_source('uexpect', os.path.join(CURDIR, '..', '..', 'integration', 'helpers', 'uexpect.py'))
 
 def client(name=''):
     client = uexpect.spawn(os.environ.get('CLICKHOUSE_CLIENT'))
@@ -18,32 +18,31 @@ def client(name=''):
 
 prompt = ':\) '
 end_of_block = r'.*\xe2\x94\x82\r\n.*\xe2\x94\x98\r\n'
-client1 = client('client1>')
-client2 = client('client2>')
 
-client1.expect(prompt)
-client2.expect(prompt)
+with client('client1>') as client1, client('client2>') as client2:
+    client1.expect(prompt)
+    client2.expect(prompt)
 
-client1.send('DROP TABLE IF EXISTS test.lv')
-client1.expect(prompt)
-client1.send(' DROP TABLE IF EXISTS test.mt')
-client1.expect(prompt)
-client1.send('SET live_view_heartbeat_interval=1')
-client1.expect(prompt)
-client1.send('CREATE TABLE test.mt (a Int32) Engine=MergeTree order by tuple()')
-client1.expect(prompt)
-client1.send('CREATE TEMPORARY LIVE VIEW test.lv AS SELECT sum(a) FROM test.mt')
-client1.expect(prompt)
-client1.send('WATCH test.lv EVENTS')
-client2.send('INSERT INTO test.mt VALUES (1),(2),(3)')
-client1.expect('2.*4cd0592103888d4682de9a32a23602e3' + end_of_block)
-client1.expect('Progress: 2.00 rows.*\)')
-# wait for heartbeat
-client1.expect('Progress: 2.00 rows.*\)')
-# send Ctrl-C
-os.kill(client1.process.pid,signal.SIGINT)
-client1.expect(prompt)
-client1.send('DROP TABLE test.lv')
-client1.expect(prompt)
-client1.send('DROP TABLE test.mt')
-client1.expect(prompt)
+    client1.send('DROP TABLE IF EXISTS test.lv')
+    client1.expect(prompt)
+    client1.send(' DROP TABLE IF EXISTS test.mt')
+    client1.expect(prompt)
+    client1.send('SET live_view_heartbeat_interval=1')
+    client1.expect(prompt)
+    client1.send('CREATE TABLE test.mt (a Int32) Engine=MergeTree order by tuple()')
+    client1.expect(prompt)
+    client1.send('CREATE TEMPORARY LIVE VIEW test.lv AS SELECT sum(a) FROM test.mt')
+    client1.expect(prompt)
+    client1.send('WATCH test.lv EVENTS')
+    client2.send('INSERT INTO test.mt VALUES (1),(2),(3)')
+    client1.expect('2.*4cd0592103888d4682de9a32a23602e3' + end_of_block)
+    client1.expect('Progress: 2.00 rows.*\)')
+    # wait for heartbeat
+    client1.expect('Progress: 2.00 rows.*\)')
+    # send Ctrl-C
+    os.kill(client1.process.pid,signal.SIGINT)
+    client1.expect(prompt)
+    client1.send('DROP TABLE test.lv')
+    client1.expect(prompt)
+    client1.send('DROP TABLE test.mt')
+    client1.expect(prompt)
diff --git a/dbms/tests/queries/0_stateless/00965_live_view_watch_heartbeat.py b/dbms/tests/queries/0_stateless/00965_live_view_watch_heartbeat.py
index c596d169e1c..7f8ed6036ac 100755
--- a/dbms/tests/queries/0_stateless/00965_live_view_watch_heartbeat.py
+++ b/dbms/tests/queries/0_stateless/00965_live_view_watch_heartbeat.py
@@ -6,7 +6,7 @@ import signal
 
 CURDIR = os.path.dirname(os.path.realpath(__file__))
 
-uexpect = imp.load_source('uexpect', os.path.join(CURDIR, 'uexpect.py'))
+uexpect = imp.load_source('uexpect', os.path.join(CURDIR, '..', '..', 'integration', 'helpers', 'uexpect.py'))
 
 def client(name=''):
     client = uexpect.spawn(os.environ.get('CLICKHOUSE_CLIENT'))
@@ -18,32 +18,31 @@ def client(name=''):
 
 prompt = ':\) '
 end_of_block = r'.*\xe2\x94\x82\r\n.*\xe2\x94\x98\r\n'
-client1 = client('client1>')
-client2 = client('client2>')
 
-client1.expect(prompt)
-client2.expect(prompt)
+with client('client1>') as client1, client('client2>') as client2:
+    client1.expect(prompt)
+    client2.expect(prompt)
 
-client1.send('DROP TABLE IF EXISTS test.lv')
-client1.expect(prompt)
-client1.send(' DROP TABLE IF EXISTS test.mt')
-client1.expect(prompt)
-client1.send('SET live_view_heartbeat_interval=1')
-client1.expect(prompt)
-client1.send('CREATE TABLE test.mt (a Int32) Engine=MergeTree order by tuple()')
-client1.expect(prompt)
-client1.send('CREATE TEMPORARY LIVE VIEW test.lv AS SELECT sum(a) FROM test.mt')
-client1.expect(prompt)
-client1.send('WATCH test.lv')
-client2.send('INSERT INTO test.mt VALUES (1),(2),(3)')
-client1.expect(r'6.*2' + end_of_block)
-client1.expect('Progress: 2.00 rows.*\)')
-# wait for heartbeat
-client1.expect('Progress: 2.00 rows.*\)')
-# send Ctrl-C
-os.kill(client1.process.pid,signal.SIGINT)
-client1.expect(prompt)
-client1.send('DROP TABLE test.lv')
-client1.expect(prompt)
-client1.send('DROP TABLE test.mt')
-client1.expect(prompt)
+    client1.send('DROP TABLE IF EXISTS test.lv')
+    client1.expect(prompt)
+    client1.send(' DROP TABLE IF EXISTS test.mt')
+    client1.expect(prompt)
+    client1.send('SET live_view_heartbeat_interval=1')
+    client1.expect(prompt)
+    client1.send('CREATE TABLE test.mt (a Int32) Engine=MergeTree order by tuple()')
+    client1.expect(prompt)
+    client1.send('CREATE TEMPORARY LIVE VIEW test.lv AS SELECT sum(a) FROM test.mt')
+    client1.expect(prompt)
+    client1.send('WATCH test.lv')
+    client2.send('INSERT INTO test.mt VALUES (1),(2),(3)')
+    client1.expect(r'6.*2' + end_of_block)
+    client1.expect('Progress: 2.00 rows.*\)')
+    # wait for heartbeat
+    client1.expect('Progress: 2.00 rows.*\)')
+    # send Ctrl-C
+    os.kill(client1.process.pid,signal.SIGINT)
+    client1.expect(prompt)
+    client1.send('DROP TABLE test.lv')
+    client1.expect(prompt)
+    client1.send('DROP TABLE test.mt')
+    client1.expect(prompt)
diff --git a/dbms/tests/queries/0_stateless/00966_live_view_watch_events_http.py b/dbms/tests/queries/0_stateless/00966_live_view_watch_events_http.py
index 904d5214d5b..e7dc54ee4c0 100755
--- a/dbms/tests/queries/0_stateless/00966_live_view_watch_events_http.py
+++ b/dbms/tests/queries/0_stateless/00966_live_view_watch_events_http.py
@@ -6,7 +6,7 @@ import signal
 
 CURDIR = os.path.dirname(os.path.realpath(__file__))
 
-uexpect = imp.load_source('uexpect', os.path.join(CURDIR, 'uexpect.py'))
+uexpect = imp.load_source('uexpect', os.path.join(CURDIR, '..', '..', 'integration', 'helpers', 'uexpect.py'))
 
 def client(name='', command=None):
     if command is None:
@@ -21,31 +21,31 @@ def client(name='', command=None):
 
 prompt = ':\) '
 end_of_block = r'.*\xe2\x94\x82\r\n.*\xe2\x94\x98\r\n'
-client1 = client('client1>')
-client1.expect(prompt)
 
-client1.send('DROP TABLE IF EXISTS test.lv')
-client1.expect(prompt)
-client1.send(' DROP TABLE IF EXISTS test.mt')
-client1.expect(prompt)
-client1.send('CREATE TABLE test.mt (a Int32) Engine=MergeTree order by tuple()')
-client1.expect(prompt)
-client1.send('CREATE LIVE VIEW test.lv AS SELECT sum(a) FROM test.mt')
-client1.expect(prompt)
+with client('client1>') as client1, client('client2>', ['bash', '--noediting']) as client2:
+    client1.expect(prompt)
 
-client2 = client('client2>', ['bash', '--noediting'])
-client2.expect('[\$#] ')
-client2.send('wget -O- -q "http://localhost:8123/?query=WATCH test.lv EVENTS"')
-client2.expect('.*1\tc9d39b11cce79112219a73aaa319b475\r\n')
+    client1.send('DROP TABLE IF EXISTS test.lv')
+    client1.expect(prompt)
+    client1.send(' DROP TABLE IF EXISTS test.mt')
+    client1.expect(prompt)
+    client1.send('CREATE TABLE test.mt (a Int32) Engine=MergeTree order by tuple()')
+    client1.expect(prompt)
+    client1.send('CREATE LIVE VIEW test.lv AS SELECT sum(a) FROM test.mt')
+    client1.expect(prompt)
 
-client1.send('INSERT INTO test.mt VALUES (1),(2),(3)')
-client1.expect(prompt)
+    client2.expect('[\$#] ')
+    client2.send('wget -O- -q "http://localhost:8123/?query=WATCH test.lv EVENTS"')
+    client2.expect('.*1\tc9d39b11cce79112219a73aaa319b475\r\n')
 
-client2.expect('.*2\t.*\r\n')
-## send Ctrl-C
-os.kill(client2.process.pid,signal.SIGINT)
+    client1.send('INSERT INTO test.mt VALUES (1),(2),(3)')
+    client1.expect(prompt)
 
-client1.send('DROP TABLE test.lv')
-client1.expect(prompt)
-client1.send('DROP TABLE test.mt')
-client1.expect(prompt)
+    client2.expect('.*2\t.*\r\n')
+    ## send Ctrl-C
+    os.kill(client2.process.pid,signal.SIGINT)
+
+    client1.send('DROP TABLE test.lv')
+    client1.expect(prompt)
+    client1.send('DROP TABLE test.mt')
+    client1.expect(prompt)
diff --git a/dbms/tests/queries/0_stateless/00967_live_view_watch_http.py b/dbms/tests/queries/0_stateless/00967_live_view_watch_http.py
index 4363b453852..6874ae376a3 100755
--- a/dbms/tests/queries/0_stateless/00967_live_view_watch_http.py
+++ b/dbms/tests/queries/0_stateless/00967_live_view_watch_http.py
@@ -6,7 +6,7 @@ import signal
 
 CURDIR = os.path.dirname(os.path.realpath(__file__))
 
-uexpect = imp.load_source('uexpect', os.path.join(CURDIR, 'uexpect.py'))
+uexpect = imp.load_source('uexpect', os.path.join(CURDIR, '..', '..', 'integration', 'helpers', 'uexpect.py'))
 
 def client(name='', command=None):
     if command is None:
@@ -21,31 +21,31 @@ def client(name='', command=None):
 
 prompt = ':\) '
 end_of_block = r'.*\xe2\x94\x82\r\n.*\xe2\x94\x98\r\n'
-client1 = client('client1>')
-client1.expect(prompt)
 
-client1.send('DROP TABLE IF EXISTS test.lv')
-client1.expect(prompt)
-client1.send(' DROP TABLE IF EXISTS test.mt')
-client1.expect(prompt)
-client1.send('CREATE TABLE test.mt (a Int32) Engine=MergeTree order by tuple()')
-client1.expect(prompt)
-client1.send('CREATE LIVE VIEW test.lv AS SELECT sum(a) FROM test.mt')
-client1.expect(prompt)
+with client('client1>') as client1, client('client2>', ['bash', '--noediting']) as client2:
+    client1.expect(prompt)
 
-client2 = client('client2>', ['bash', '--noediting'])
-client2.expect('[\$#] ')
-client2.send('wget -O- -q "http://localhost:8123/?query=WATCH test.lv"')
-client2.expect('.*0\t1\r\n')
+    client1.send('DROP TABLE IF EXISTS test.lv')
+    client1.expect(prompt)
+    client1.send(' DROP TABLE IF EXISTS test.mt')
+    client1.expect(prompt)
+    client1.send('CREATE TABLE test.mt (a Int32) Engine=MergeTree order by tuple()')
+    client1.expect(prompt)
+    client1.send('CREATE LIVE VIEW test.lv AS SELECT sum(a) FROM test.mt')
+    client1.expect(prompt)
 
-client1.send('INSERT INTO test.mt VALUES (1),(2),(3)')
-client1.expect(prompt)
+    client2.expect('[\$#] ')
+    client2.send('wget -O- -q "http://localhost:8123/?query=WATCH test.lv"')
+    client2.expect('.*0\t1\r\n')
 
-client2.expect('.*6\t2\r\n')
-## send Ctrl-C
-os.kill(client2.process.pid,signal.SIGINT)
+    client1.send('INSERT INTO test.mt VALUES (1),(2),(3)')
+    client1.expect(prompt)
 
-client1.send('DROP TABLE test.lv')
-client1.expect(prompt)
-client1.send('DROP TABLE test.mt')
-client1.expect(prompt)
+    client2.expect('.*6\t2\r\n')
+    ## send Ctrl-C
+    os.kill(client2.process.pid,signal.SIGINT)
+
+    client1.send('DROP TABLE test.lv')
+    client1.expect(prompt)
+    client1.send('DROP TABLE test.mt')
+    client1.expect(prompt)
diff --git a/dbms/tests/queries/0_stateless/00970_live_view_watch_events_http_heartbeat.py b/dbms/tests/queries/0_stateless/00970_live_view_watch_events_http_heartbeat.py
index f96cac1e1c7..4730caf5f57 100755
--- a/dbms/tests/queries/0_stateless/00970_live_view_watch_events_http_heartbeat.py
+++ b/dbms/tests/queries/0_stateless/00970_live_view_watch_events_http_heartbeat.py
@@ -6,7 +6,7 @@ import signal
 
 CURDIR = os.path.dirname(os.path.realpath(__file__))
 
-uexpect = imp.load_source('uexpect', os.path.join(CURDIR, 'uexpect.py'))
+uexpect = imp.load_source('uexpect', os.path.join(CURDIR, '..', '..', 'integration', 'helpers', 'uexpect.py'))
 
 def client(name='', command=None):
     if command is None:
@@ -21,36 +21,36 @@ def client(name='', command=None):
 
 prompt = ':\) '
 end_of_block = r'.*\xe2\x94\x82\r\n.*\xe2\x94\x98\r\n'
-client1 = client('client1>')
-client1.expect(prompt)
 
-client1.send('DROP TABLE IF EXISTS test.lv')
-client1.expect(prompt)
-client1.send(' DROP TABLE IF EXISTS test.mt')
-client1.expect(prompt)
-client1.send('CREATE TABLE test.mt (a Int32) Engine=MergeTree order by tuple()')
-client1.expect(prompt)
-client1.send('CREATE LIVE VIEW test.lv AS SELECT sum(a) FROM test.mt')
-client1.expect(prompt)
+with client('client1>') as client1, client('client2>', ['bash', '--noediting']) as client2:
+    client1.expect(prompt)
 
-client2 = client('client2>', ['bash', '--noediting'])
-client2.expect('[\$#] ')
-client2.send('wget -O- -q "http://localhost:8123/?live_view_heartbeat_interval=1&query=WATCH test.lv EVENTS FORMAT JSONEachRowWithProgress"')
-client2.expect('{"progress":{"read_rows":"1","read_bytes":"49","written_rows":"0","written_bytes":"0","total_rows_to_read":"0"}}\r\n', escape=True)
-client2.expect('{"row":{"version":"1","hash":"c9d39b11cce79112219a73aaa319b475"}}', escape=True)
-client2.expect('{"progress":{"read_rows":"1","read_bytes":"49","written_rows":"0","written_bytes":"0","total_rows_to_read":"0"}}', escape=True)
-# heartbeat is provided by progress message
-client2.expect('{"progress":{"read_rows":"1","read_bytes":"49","written_rows":"0","written_bytes":"0","total_rows_to_read":"0"}}', escape=True)
+    client1.send('DROP TABLE IF EXISTS test.lv')
+    client1.expect(prompt)
+    client1.send(' DROP TABLE IF EXISTS test.mt')
+    client1.expect(prompt)
+    client1.send('CREATE TABLE test.mt (a Int32) Engine=MergeTree order by tuple()')
+    client1.expect(prompt)
+    client1.send('CREATE LIVE VIEW test.lv AS SELECT sum(a) FROM test.mt')
+    client1.expect(prompt)
 
-client1.send('INSERT INTO test.mt VALUES (1),(2),(3)')
-client1.expect(prompt)
+    client2.expect('[\$#] ')
+    client2.send('wget -O- -q "http://localhost:8123/?live_view_heartbeat_interval=1&query=WATCH test.lv EVENTS FORMAT JSONEachRowWithProgress"')
+    client2.expect('{"progress":{"read_rows":"1","read_bytes":"49","written_rows":"0","written_bytes":"0","total_rows_to_read":"0"}}\r\n', escape=True)
+    client2.expect('{"row":{"version":"1","hash":"c9d39b11cce79112219a73aaa319b475"}}', escape=True)
+    client2.expect('{"progress":{"read_rows":"1","read_bytes":"49","written_rows":"0","written_bytes":"0","total_rows_to_read":"0"}}', escape=True)
+    # heartbeat is provided by progress message
+    client2.expect('{"progress":{"read_rows":"1","read_bytes":"49","written_rows":"0","written_bytes":"0","total_rows_to_read":"0"}}', escape=True)
 
-client2.expect('{"row":{"version":"2","hash":"4cd0592103888d4682de9a32a23602e3"}}\r\n', escape=True)
+    client1.send('INSERT INTO test.mt VALUES (1),(2),(3)')
+    client1.expect(prompt)
 
-## send Ctrl-C
-os.kill(client2.process.pid,signal.SIGINT)
+    client2.expect('{"row":{"version":"2","hash":"4cd0592103888d4682de9a32a23602e3"}}\r\n', escape=True)
 
-client1.send('DROP TABLE test.lv')
-client1.expect(prompt)
-client1.send('DROP TABLE test.mt')
-client1.expect(prompt)
+    ## send Ctrl-C
+    os.kill(client2.process.pid,signal.SIGINT)
+
+    client1.send('DROP TABLE test.lv')
+    client1.expect(prompt)
+    client1.send('DROP TABLE test.mt')
+    client1.expect(prompt)
diff --git a/dbms/tests/queries/0_stateless/00971_live_view_watch_http_heartbeat.py b/dbms/tests/queries/0_stateless/00971_live_view_watch_http_heartbeat.py
index cb8cf8f5582..5884bc1e2a5 100755
--- a/dbms/tests/queries/0_stateless/00971_live_view_watch_http_heartbeat.py
+++ b/dbms/tests/queries/0_stateless/00971_live_view_watch_http_heartbeat.py
@@ -6,7 +6,7 @@ import signal
 
 CURDIR = os.path.dirname(os.path.realpath(__file__))
 
-uexpect = imp.load_source('uexpect', os.path.join(CURDIR, 'uexpect.py'))
+uexpect = imp.load_source('uexpect', os.path.join(CURDIR, '..', '..', 'integration', 'helpers', 'uexpect.py'))
 
 def client(name='', command=None):
     if command is None:
@@ -21,37 +21,37 @@ def client(name='', command=None):
 
 prompt = ':\) '
 end_of_block = r'.*\xe2\x94\x82\r\n.*\xe2\x94\x98\r\n'
-client1 = client('client1>')
-client1.expect(prompt)
 
-client1.send('DROP TABLE IF EXISTS test.lv')
-client1.expect(prompt)
-client1.send(' DROP TABLE IF EXISTS test.mt')
-client1.expect(prompt)
-client1.send('CREATE TABLE test.mt (a Int32) Engine=MergeTree order by tuple()')
-client1.expect(prompt)
-client1.send('CREATE LIVE VIEW test.lv AS SELECT sum(a) FROM test.mt')
-client1.expect(prompt)
+with client('client1>') as client1, client('client2>', ['bash', '--noediting']) as client2:
+    client1.expect(prompt)
 
-client2 = client('client2>', ['bash', '--noediting'])
-client2.expect('[\$#] ')
-client2.send('wget -O- -q "http://localhost:8123/?live_view_heartbeat_interval=1&query=WATCH test.lv FORMAT JSONEachRowWithProgress"')
-client2.expect('"progress".*',)
-client2.expect('{"row":{"sum(a)":"0","_version":"1"}}\r\n', escape=True)
-client2.expect('"progress".*\r\n')
-# heartbeat is provided by progress message
-client2.expect('"progress".*\r\n')
+    client1.send('DROP TABLE IF EXISTS test.lv')
+    client1.expect(prompt)
+    client1.send(' DROP TABLE IF EXISTS test.mt')
+    client1.expect(prompt)
+    client1.send('CREATE TABLE test.mt (a Int32) Engine=MergeTree order by tuple()')
+    client1.expect(prompt)
+    client1.send('CREATE LIVE VIEW test.lv AS SELECT sum(a) FROM test.mt')
+    client1.expect(prompt)
 
-client1.send('INSERT INTO test.mt VALUES (1),(2),(3)')
-client1.expect(prompt)
+    client2.expect('[\$#] ')
+    client2.send('wget -O- -q "http://localhost:8123/?live_view_heartbeat_interval=1&query=WATCH test.lv FORMAT JSONEachRowWithProgress"')
+    client2.expect('"progress".*',)
+    client2.expect('{"row":{"sum(a)":"0","_version":"1"}}\r\n', escape=True)
+    client2.expect('"progress".*\r\n')
+    # heartbeat is provided by progress message
+    client2.expect('"progress".*\r\n')
 
-client2.expect('"progress".*"read_rows":"2".*\r\n')
-client2.expect('{"row":{"sum(a)":"6","_version":"2"}}\r\n', escape=True)
+    client1.send('INSERT INTO test.mt VALUES (1),(2),(3)')
+    client1.expect(prompt)
 
-## send Ctrl-C
-os.kill(client2.process.pid,signal.SIGINT)
+    client2.expect('"progress".*"read_rows":"2".*\r\n')
+    client2.expect('{"row":{"sum(a)":"6","_version":"2"}}\r\n', escape=True)
 
-client1.send('DROP TABLE test.lv')
-client1.expect(prompt)
-client1.send('DROP TABLE test.mt')
-client1.expect(prompt)
+    ## send Ctrl-C
+    os.kill(client2.process.pid,signal.SIGINT)
+
+    client1.send('DROP TABLE test.lv')
+    client1.expect(prompt)
+    client1.send('DROP TABLE test.mt')
+    client1.expect(prompt)

From 79989a766c54e6e316fa1cff39739d26f9021309 Mon Sep 17 00:00:00 2001
From: Vitaliy Zakaznikov <vzakaznikov@protonmail.com>
Date: Mon, 10 Jun 2019 19:56:12 -0400
Subject: [PATCH 036/107] * Fixing uexpect.py close() method and forcing to
 close the process   by default * Updating tests to be more robust

---
 dbms/tests/integration/helpers/uexpect.py     | 38 ++++++++++---------
 .../0_stateless/00958_live_view_watch_live.py |  2 +-
 .../00960_live_view_watch_events_live.py      |  2 +-
 .../00962_temporary_live_view_watch_live.py   |  2 +-
 ..._temporary_live_view_watch_live_timeout.py |  2 +-
 .../00964_live_view_watch_events_heartbeat.py |  2 +-
 .../00965_live_view_watch_heartbeat.py        |  2 +-
 .../00966_live_view_watch_events_http.py      |  2 +-
 .../0_stateless/00967_live_view_watch_http.py |  2 +-
 ...0_live_view_watch_events_http_heartbeat.py |  2 +-
 .../00971_live_view_watch_http_heartbeat.py   |  4 +-
 11 files changed, 32 insertions(+), 28 deletions(-)

diff --git a/dbms/tests/integration/helpers/uexpect.py b/dbms/tests/integration/helpers/uexpect.py
index 58be8f60ff8..2a42b8a5de0 100644
--- a/dbms/tests/integration/helpers/uexpect.py
+++ b/dbms/tests/integration/helpers/uexpect.py
@@ -17,7 +17,7 @@ import time
 import sys
 import re
 
-from threading import Thread
+from threading import Thread, Event
 from subprocess import Popen
 from Queue import Queue, Empty
 
@@ -61,7 +61,7 @@ class IO(object):
         def flush(self):
             self._logger.flush()
 
-    def __init__(self, process, master, queue):
+    def __init__(self, process, master, queue, reader):
         self.process = process
         self.master = master
         self.queue = queue
@@ -70,6 +70,7 @@ class IO(object):
         self.after = None
         self.match = None
         self.pattern = None
+        self.reader = reader
         self._timeout = None
         self._logger = None
         self._eol = ''
@@ -95,8 +96,12 @@ class IO(object):
             self._eol = eol
         return self._eol
 
-    def close(self):
-        self.process.terminate()
+    def close(self, force=True):
+        self.reader['kill_event'].set()
+        if force:
+            self.process.kill()
+        else:
+            self.process.terminate()
         os.close(self.master)
         if self._logger:
             self._logger.write('\n')
@@ -133,9 +138,9 @@ class IO(object):
                 raise exception
             timeleft -= (time.time() - start_time)
             if data:
-                self.buffer = self.buffer + data if self.buffer else data
+                self.buffer = (self.buffer + data) if self.buffer else data
             self.match = pattern.search(self.buffer, 0)
-            if self.match:
+            if self.match is not None:
                 self.after = self.buffer[self.match.start():self.match.end()]
                 self.before = self.buffer[:self.match.start()]
                 self.buffer = self.buffer[self.match.end():]
@@ -163,11 +168,9 @@ class IO(object):
             if data:
                 return data
             if raise_exception:
-                print 'DEBUG...', timeleft, repr(data),
                 raise TimeoutError(timeout)
             pass
         if not data and raise_exception:
-            print 'DEBUG.... here'
             raise TimeoutError(timeout)
 
         return data
@@ -178,20 +181,21 @@ def spawn(command):
     os.close(slave)
 
     queue = Queue()
-    thread = Thread(target=reader, args=(process, master, queue))
-    thread.daemon = True
+    reader_kill_event = Event()
+    thread = Thread(target=reader, args=(process, master, queue, reader_kill_event))
     thread.start()
 
-    return IO(process, master, queue)
+    return IO(process, master, queue, reader={'thread':thread, 'kill_event':reader_kill_event})
 
-def reader(process, out, queue):
+def reader(process, out, queue, kill_event):
     while True:
-        if process.poll() is not None:
-            data = os.read(out)
+        try:
+            data = os.read(out, 65536)
             queue.put(data)
-            break
-        data = os.read(out, 65536)
-        queue.put(data)
+        except OSError, e:
+            if e.errno == 5 and kill_event.is_set():
+                break
+            raise
 
 if __name__ == '__main__':
    io = spawn(['/bin/bash','--noediting'])
diff --git a/dbms/tests/queries/0_stateless/00958_live_view_watch_live.py b/dbms/tests/queries/0_stateless/00958_live_view_watch_live.py
index b60e82299f7..51bdca1a9b6 100755
--- a/dbms/tests/queries/0_stateless/00958_live_view_watch_live.py
+++ b/dbms/tests/queries/0_stateless/00958_live_view_watch_live.py
@@ -17,7 +17,7 @@ def client(name=''):
     return client
 
 prompt = ':\) '
-end_of_block = r'.*\xe2\x94\x82\r\n.*\xe2\x94\x98\r\n'
+end_of_block = r'.*\r\n.*\r\n'
 
 with client('client1>') as client1, client('client2>') as client2:
     client1.expect(prompt)
diff --git a/dbms/tests/queries/0_stateless/00960_live_view_watch_events_live.py b/dbms/tests/queries/0_stateless/00960_live_view_watch_events_live.py
index 9fdabd499d0..0b441b72805 100755
--- a/dbms/tests/queries/0_stateless/00960_live_view_watch_events_live.py
+++ b/dbms/tests/queries/0_stateless/00960_live_view_watch_events_live.py
@@ -17,7 +17,7 @@ def client(name=''):
     return client
 
 prompt = ':\) '
-end_of_block = r'.*\xe2\x94\x82\r\n.*\xe2\x94\x98\r\n'
+end_of_block = r'.*\r\n.*\r\n'
 
 with client('client1>') as client1, client('client2>') as client2:
     client1.expect(prompt)
diff --git a/dbms/tests/queries/0_stateless/00962_temporary_live_view_watch_live.py b/dbms/tests/queries/0_stateless/00962_temporary_live_view_watch_live.py
index 0e7c3c43254..5dfa6ac841e 100755
--- a/dbms/tests/queries/0_stateless/00962_temporary_live_view_watch_live.py
+++ b/dbms/tests/queries/0_stateless/00962_temporary_live_view_watch_live.py
@@ -17,7 +17,7 @@ def client(name=''):
     return client
 
 prompt = ':\) '
-end_of_block = r'.*\xe2\x94\x82\r\n.*\xe2\x94\x98\r\n'
+end_of_block = r'.*\r\n.*\r\n'
 
 with client('client1>') as client1, client('client2>') as client2:
     client1.expect(prompt)
diff --git a/dbms/tests/queries/0_stateless/00963_temporary_live_view_watch_live_timeout.py b/dbms/tests/queries/0_stateless/00963_temporary_live_view_watch_live_timeout.py
index b3f6809ded0..09301aa6d59 100755
--- a/dbms/tests/queries/0_stateless/00963_temporary_live_view_watch_live_timeout.py
+++ b/dbms/tests/queries/0_stateless/00963_temporary_live_view_watch_live_timeout.py
@@ -17,7 +17,7 @@ def client(name=''):
     return client
 
 prompt = ':\) '
-end_of_block = r'.*\xe2\x94\x82\r\n.*\xe2\x94\x98\r\n'
+end_of_block = r'.*\r\n.*\r\n'
 
 with client('client1>') as client1, client('client2>') as client2:
     client1.expect(prompt)
diff --git a/dbms/tests/queries/0_stateless/00964_live_view_watch_events_heartbeat.py b/dbms/tests/queries/0_stateless/00964_live_view_watch_events_heartbeat.py
index 1e66daef953..f3e5b1ee435 100755
--- a/dbms/tests/queries/0_stateless/00964_live_view_watch_events_heartbeat.py
+++ b/dbms/tests/queries/0_stateless/00964_live_view_watch_events_heartbeat.py
@@ -17,7 +17,7 @@ def client(name=''):
     return client
 
 prompt = ':\) '
-end_of_block = r'.*\xe2\x94\x82\r\n.*\xe2\x94\x98\r\n'
+end_of_block = r'.*\r\n.*\r\n'
 
 with client('client1>') as client1, client('client2>') as client2:
     client1.expect(prompt)
diff --git a/dbms/tests/queries/0_stateless/00965_live_view_watch_heartbeat.py b/dbms/tests/queries/0_stateless/00965_live_view_watch_heartbeat.py
index 7f8ed6036ac..9f8a3c84af0 100755
--- a/dbms/tests/queries/0_stateless/00965_live_view_watch_heartbeat.py
+++ b/dbms/tests/queries/0_stateless/00965_live_view_watch_heartbeat.py
@@ -17,7 +17,7 @@ def client(name=''):
     return client
 
 prompt = ':\) '
-end_of_block = r'.*\xe2\x94\x82\r\n.*\xe2\x94\x98\r\n'
+end_of_block = r'.*\r\n.*\r\n'
 
 with client('client1>') as client1, client('client2>') as client2:
     client1.expect(prompt)
diff --git a/dbms/tests/queries/0_stateless/00966_live_view_watch_events_http.py b/dbms/tests/queries/0_stateless/00966_live_view_watch_events_http.py
index e7dc54ee4c0..65999f4c55f 100755
--- a/dbms/tests/queries/0_stateless/00966_live_view_watch_events_http.py
+++ b/dbms/tests/queries/0_stateless/00966_live_view_watch_events_http.py
@@ -20,7 +20,7 @@ def client(name='', command=None):
     return client
 
 prompt = ':\) '
-end_of_block = r'.*\xe2\x94\x82\r\n.*\xe2\x94\x98\r\n'
+end_of_block = r'.*\r\n.*\r\n'
 
 with client('client1>') as client1, client('client2>', ['bash', '--noediting']) as client2:
     client1.expect(prompt)
diff --git a/dbms/tests/queries/0_stateless/00967_live_view_watch_http.py b/dbms/tests/queries/0_stateless/00967_live_view_watch_http.py
index 6874ae376a3..a79d6882aa9 100755
--- a/dbms/tests/queries/0_stateless/00967_live_view_watch_http.py
+++ b/dbms/tests/queries/0_stateless/00967_live_view_watch_http.py
@@ -20,7 +20,7 @@ def client(name='', command=None):
     return client
 
 prompt = ':\) '
-end_of_block = r'.*\xe2\x94\x82\r\n.*\xe2\x94\x98\r\n'
+end_of_block = r'.*\r\n.*\r\n'
 
 with client('client1>') as client1, client('client2>', ['bash', '--noediting']) as client2:
     client1.expect(prompt)
diff --git a/dbms/tests/queries/0_stateless/00970_live_view_watch_events_http_heartbeat.py b/dbms/tests/queries/0_stateless/00970_live_view_watch_events_http_heartbeat.py
index 4730caf5f57..95587ba9355 100755
--- a/dbms/tests/queries/0_stateless/00970_live_view_watch_events_http_heartbeat.py
+++ b/dbms/tests/queries/0_stateless/00970_live_view_watch_events_http_heartbeat.py
@@ -20,7 +20,7 @@ def client(name='', command=None):
     return client
 
 prompt = ':\) '
-end_of_block = r'.*\xe2\x94\x82\r\n.*\xe2\x94\x98\r\n'
+end_of_block = r'.*\r\n.*\r\n'
 
 with client('client1>') as client1, client('client2>', ['bash', '--noediting']) as client2:
     client1.expect(prompt)
diff --git a/dbms/tests/queries/0_stateless/00971_live_view_watch_http_heartbeat.py b/dbms/tests/queries/0_stateless/00971_live_view_watch_http_heartbeat.py
index 5884bc1e2a5..8c40fc6d39d 100755
--- a/dbms/tests/queries/0_stateless/00971_live_view_watch_http_heartbeat.py
+++ b/dbms/tests/queries/0_stateless/00971_live_view_watch_http_heartbeat.py
@@ -20,7 +20,7 @@ def client(name='', command=None):
     return client
 
 prompt = ':\) '
-end_of_block = r'.*\xe2\x94\x82\r\n.*\xe2\x94\x98\r\n'
+end_of_block = r'.*\r\n.*\r\n'
 
 with client('client1>') as client1, client('client2>', ['bash', '--noediting']) as client2:
     client1.expect(prompt)
@@ -49,7 +49,7 @@ with client('client1>') as client1, client('client2>', ['bash', '--noediting'])
     client2.expect('{"row":{"sum(a)":"6","_version":"2"}}\r\n', escape=True)
 
     ## send Ctrl-C
-    os.kill(client2.process.pid,signal.SIGINT)
+    os.kill(client2.process.pid, signal.SIGINT)
 
     client1.send('DROP TABLE test.lv')
     client1.expect(prompt)

From a467e7c1054217d6b3751009cb03b850ae6e459c Mon Sep 17 00:00:00 2001
From: Vitaliy Zakaznikov <vzakaznikov@protonmail.com>
Date: Mon, 10 Jun 2019 22:22:53 -0400
Subject: [PATCH 037/107] * Moving uexpect.py so that it can be found * Trying
 to fix failed style checks * Trying to fix clang build fail

---
 .../DataStreams/LiveViewEventsBlockInputStream.h  | 15 +++++----------
 dbms/src/Interpreters/InterpreterAlterQuery.cpp   |  2 +-
 dbms/src/Parsers/ASTWatchQuery.h                  |  2 +-
 dbms/src/Storages/StorageLiveView.h               |  2 +-
 .../0_stateless/00958_live_view_watch_live.py     |  2 +-
 .../00960_live_view_watch_events_live.py          |  2 +-
 .../00962_temporary_live_view_watch_live.py       |  2 +-
 ...0963_temporary_live_view_watch_live_timeout.py |  2 +-
 .../00964_live_view_watch_events_heartbeat.py     |  2 +-
 .../00965_live_view_watch_heartbeat.py            |  2 +-
 .../00966_live_view_watch_events_http.py          |  2 +-
 .../0_stateless/00967_live_view_watch_http.py     |  2 +-
 ...00970_live_view_watch_events_http_heartbeat.py |  2 +-
 .../00971_live_view_watch_http_heartbeat.py       |  2 +-
 .../0_stateless}/helpers/uexpect.py               |  0
 15 files changed, 18 insertions(+), 23 deletions(-)
 rename dbms/tests/{integration => queries/0_stateless}/helpers/uexpect.py (100%)

diff --git a/dbms/src/DataStreams/LiveViewEventsBlockInputStream.h b/dbms/src/DataStreams/LiveViewEventsBlockInputStream.h
index 35d2545419b..be21c5c71f6 100644
--- a/dbms/src/DataStreams/LiveViewEventsBlockInputStream.h
+++ b/dbms/src/DataStreams/LiveViewEventsBlockInputStream.h
@@ -66,15 +66,10 @@ public:
 
     Block getHeader() const override 
     {
-        return {
-            ColumnWithTypeAndName(
-                ColumnUInt64::create(),
-                std::make_shared<DataTypeUInt64>(),
-                "version"),
-            ColumnWithTypeAndName(
-                ColumnString::create(),
-                std::make_shared<DataTypeString>(),
-                "hash")
+        return 
+        { 
+            ColumnWithTypeAndName(ColumnUInt64::create(), std::make_shared<DataTypeUInt64>(), "version"), 
+            ColumnWithTypeAndName(ColumnString::create(), std::make_shared<DataTypeString>(), "hash")
         };
     }
 
@@ -93,7 +88,7 @@ public:
     {
         active = active_ptr.lock();
         {
-            if (!blocks || blocks.get() != (*blocks_ptr).get()) 
+            if (!blocks || (blocks.get() != (*blocks_ptr).get())) 
             {
                 blocks = (*blocks_ptr);
                 blocks_metadata = (*blocks_metadata_ptr);
diff --git a/dbms/src/Interpreters/InterpreterAlterQuery.cpp b/dbms/src/Interpreters/InterpreterAlterQuery.cpp
index e8f3e4f4553..507b7a873d2 100644
--- a/dbms/src/Interpreters/InterpreterAlterQuery.cpp
+++ b/dbms/src/Interpreters/InterpreterAlterQuery.cpp
@@ -80,7 +80,7 @@ BlockIO InterpreterAlterQuery::execute()
     if (!live_view_commands.empty())
     {
         live_view_commands.validate(*table);
-	for (const LiveViewCommand & command : live_view_commands)
+        for (const LiveViewCommand & command : live_view_commands)
         {
             auto live_view = std::dynamic_pointer_cast<StorageLiveView>(table);
             switch (command.type)
diff --git a/dbms/src/Parsers/ASTWatchQuery.h b/dbms/src/Parsers/ASTWatchQuery.h
index 7e75d62a629..06d1460f038 100644
--- a/dbms/src/Parsers/ASTWatchQuery.h
+++ b/dbms/src/Parsers/ASTWatchQuery.h
@@ -25,7 +25,7 @@ public:
     bool is_watch_events;
 
     ASTWatchQuery() = default;
-    String getID(char) const override { return "WatchQuery_" + database + "_" + table; };
+    String getID(char) const override { return "WatchQuery_" + database + "_" + table; }
 
     ASTPtr clone() const override
     {
diff --git a/dbms/src/Storages/StorageLiveView.h b/dbms/src/Storages/StorageLiveView.h
index fb250aec859..1114da7049d 100644
--- a/dbms/src/Storages/StorageLiveView.h
+++ b/dbms/src/Storages/StorageLiveView.h
@@ -28,7 +28,6 @@ namespace DB
 {
 
 class IAST;
-using ASTPtr = std::shared_ptr<IAST>;
 
 struct BlocksMetadata 
 {
@@ -36,6 +35,7 @@ struct BlocksMetadata
     UInt64 version;
 };
 
+using ASTPtr = std::shared_ptr<IAST>;
 using BlocksMetadataPtr = std::shared_ptr<BlocksMetadata>;
 using SipHashPtr = std::shared_ptr<SipHash>;
 
diff --git a/dbms/tests/queries/0_stateless/00958_live_view_watch_live.py b/dbms/tests/queries/0_stateless/00958_live_view_watch_live.py
index 51bdca1a9b6..96537d0d5c1 100755
--- a/dbms/tests/queries/0_stateless/00958_live_view_watch_live.py
+++ b/dbms/tests/queries/0_stateless/00958_live_view_watch_live.py
@@ -6,7 +6,7 @@ import signal
 
 CURDIR = os.path.dirname(os.path.realpath(__file__))
 
-uexpect = imp.load_source('uexpect', os.path.join(CURDIR, '..', '..', 'integration', 'helpers', 'uexpect.py'))
+uexpect = imp.load_source('uexpect', os.path.join(CURDIR, 'helpers', 'uexpect.py'))
 
 def client(name=''):
     client = uexpect.spawn(os.environ.get('CLICKHOUSE_CLIENT'))
diff --git a/dbms/tests/queries/0_stateless/00960_live_view_watch_events_live.py b/dbms/tests/queries/0_stateless/00960_live_view_watch_events_live.py
index 0b441b72805..a775854de9e 100755
--- a/dbms/tests/queries/0_stateless/00960_live_view_watch_events_live.py
+++ b/dbms/tests/queries/0_stateless/00960_live_view_watch_events_live.py
@@ -6,7 +6,7 @@ import signal
 
 CURDIR = os.path.dirname(os.path.realpath(__file__))
 
-uexpect = imp.load_source('uexpect', os.path.join(CURDIR, '..', '..', 'integration', 'helpers', 'uexpect.py'))
+uexpect = imp.load_source('uexpect', os.path.join(CURDIR, 'helpers', 'uexpect.py'))
 
 def client(name=''):
     client = uexpect.spawn(os.environ.get('CLICKHOUSE_CLIENT'))
diff --git a/dbms/tests/queries/0_stateless/00962_temporary_live_view_watch_live.py b/dbms/tests/queries/0_stateless/00962_temporary_live_view_watch_live.py
index 5dfa6ac841e..fb75134fc4c 100755
--- a/dbms/tests/queries/0_stateless/00962_temporary_live_view_watch_live.py
+++ b/dbms/tests/queries/0_stateless/00962_temporary_live_view_watch_live.py
@@ -6,7 +6,7 @@ import signal
 
 CURDIR = os.path.dirname(os.path.realpath(__file__))
 
-uexpect = imp.load_source('uexpect', os.path.join(CURDIR, '..', '..', 'integration', 'helpers', 'uexpect.py'))
+uexpect = imp.load_source('uexpect', os.path.join(CURDIR, 'helpers', 'uexpect.py'))
 
 def client(name=''):
     client = uexpect.spawn(os.environ.get('CLICKHOUSE_CLIENT'))
diff --git a/dbms/tests/queries/0_stateless/00963_temporary_live_view_watch_live_timeout.py b/dbms/tests/queries/0_stateless/00963_temporary_live_view_watch_live_timeout.py
index 09301aa6d59..4e12cd2234b 100755
--- a/dbms/tests/queries/0_stateless/00963_temporary_live_view_watch_live_timeout.py
+++ b/dbms/tests/queries/0_stateless/00963_temporary_live_view_watch_live_timeout.py
@@ -6,7 +6,7 @@ import signal
 
 CURDIR = os.path.dirname(os.path.realpath(__file__))
 
-uexpect = imp.load_source('uexpect', os.path.join(CURDIR, '..', '..', 'integration', 'helpers', 'uexpect.py'))
+uexpect = imp.load_source('uexpect', os.path.join(CURDIR, 'helpers', 'uexpect.py'))
 
 def client(name=''):
     client = uexpect.spawn(os.environ.get('CLICKHOUSE_CLIENT'))
diff --git a/dbms/tests/queries/0_stateless/00964_live_view_watch_events_heartbeat.py b/dbms/tests/queries/0_stateless/00964_live_view_watch_events_heartbeat.py
index f3e5b1ee435..c7b2b1a6906 100755
--- a/dbms/tests/queries/0_stateless/00964_live_view_watch_events_heartbeat.py
+++ b/dbms/tests/queries/0_stateless/00964_live_view_watch_events_heartbeat.py
@@ -6,7 +6,7 @@ import signal
 
 CURDIR = os.path.dirname(os.path.realpath(__file__))
 
-uexpect = imp.load_source('uexpect', os.path.join(CURDIR, '..', '..', 'integration', 'helpers', 'uexpect.py'))
+uexpect = imp.load_source('uexpect', os.path.join(CURDIR, 'helpers', 'uexpect.py'))
 
 def client(name=''):
     client = uexpect.spawn(os.environ.get('CLICKHOUSE_CLIENT'))
diff --git a/dbms/tests/queries/0_stateless/00965_live_view_watch_heartbeat.py b/dbms/tests/queries/0_stateless/00965_live_view_watch_heartbeat.py
index 9f8a3c84af0..b501c6e5889 100755
--- a/dbms/tests/queries/0_stateless/00965_live_view_watch_heartbeat.py
+++ b/dbms/tests/queries/0_stateless/00965_live_view_watch_heartbeat.py
@@ -6,7 +6,7 @@ import signal
 
 CURDIR = os.path.dirname(os.path.realpath(__file__))
 
-uexpect = imp.load_source('uexpect', os.path.join(CURDIR, '..', '..', 'integration', 'helpers', 'uexpect.py'))
+uexpect = imp.load_source('uexpect', os.path.join(CURDIR, 'helpers', 'uexpect.py'))
 
 def client(name=''):
     client = uexpect.spawn(os.environ.get('CLICKHOUSE_CLIENT'))
diff --git a/dbms/tests/queries/0_stateless/00966_live_view_watch_events_http.py b/dbms/tests/queries/0_stateless/00966_live_view_watch_events_http.py
index 65999f4c55f..4424bac3e54 100755
--- a/dbms/tests/queries/0_stateless/00966_live_view_watch_events_http.py
+++ b/dbms/tests/queries/0_stateless/00966_live_view_watch_events_http.py
@@ -6,7 +6,7 @@ import signal
 
 CURDIR = os.path.dirname(os.path.realpath(__file__))
 
-uexpect = imp.load_source('uexpect', os.path.join(CURDIR, '..', '..', 'integration', 'helpers', 'uexpect.py'))
+uexpect = imp.load_source('uexpect', os.path.join(CURDIR, 'helpers', 'uexpect.py'))
 
 def client(name='', command=None):
     if command is None:
diff --git a/dbms/tests/queries/0_stateless/00967_live_view_watch_http.py b/dbms/tests/queries/0_stateless/00967_live_view_watch_http.py
index a79d6882aa9..3c7e8cdd489 100755
--- a/dbms/tests/queries/0_stateless/00967_live_view_watch_http.py
+++ b/dbms/tests/queries/0_stateless/00967_live_view_watch_http.py
@@ -6,7 +6,7 @@ import signal
 
 CURDIR = os.path.dirname(os.path.realpath(__file__))
 
-uexpect = imp.load_source('uexpect', os.path.join(CURDIR, '..', '..', 'integration', 'helpers', 'uexpect.py'))
+uexpect = imp.load_source('uexpect', os.path.join(CURDIR, 'helpers', 'uexpect.py'))
 
 def client(name='', command=None):
     if command is None:
diff --git a/dbms/tests/queries/0_stateless/00970_live_view_watch_events_http_heartbeat.py b/dbms/tests/queries/0_stateless/00970_live_view_watch_events_http_heartbeat.py
index 95587ba9355..b7ab164c67a 100755
--- a/dbms/tests/queries/0_stateless/00970_live_view_watch_events_http_heartbeat.py
+++ b/dbms/tests/queries/0_stateless/00970_live_view_watch_events_http_heartbeat.py
@@ -6,7 +6,7 @@ import signal
 
 CURDIR = os.path.dirname(os.path.realpath(__file__))
 
-uexpect = imp.load_source('uexpect', os.path.join(CURDIR, '..', '..', 'integration', 'helpers', 'uexpect.py'))
+uexpect = imp.load_source('uexpect', os.path.join(CURDIR, 'helpers', 'uexpect.py'))
 
 def client(name='', command=None):
     if command is None:
diff --git a/dbms/tests/queries/0_stateless/00971_live_view_watch_http_heartbeat.py b/dbms/tests/queries/0_stateless/00971_live_view_watch_http_heartbeat.py
index 8c40fc6d39d..2102b890132 100755
--- a/dbms/tests/queries/0_stateless/00971_live_view_watch_http_heartbeat.py
+++ b/dbms/tests/queries/0_stateless/00971_live_view_watch_http_heartbeat.py
@@ -6,7 +6,7 @@ import signal
 
 CURDIR = os.path.dirname(os.path.realpath(__file__))
 
-uexpect = imp.load_source('uexpect', os.path.join(CURDIR, '..', '..', 'integration', 'helpers', 'uexpect.py'))
+uexpect = imp.load_source('uexpect', os.path.join(CURDIR, 'helpers', 'uexpect.py'))
 
 def client(name='', command=None):
     if command is None:
diff --git a/dbms/tests/integration/helpers/uexpect.py b/dbms/tests/queries/0_stateless/helpers/uexpect.py
similarity index 100%
rename from dbms/tests/integration/helpers/uexpect.py
rename to dbms/tests/queries/0_stateless/helpers/uexpect.py

From b6efd8599fee992e1f54337fe376918f123b3520 Mon Sep 17 00:00:00 2001
From: Vitaliy Zakaznikov <vzakaznikov@protonmail.com>
Date: Tue, 11 Jun 2019 06:30:57 -0400
Subject: [PATCH 038/107] * Trying again to fix style checks. Now running
 ./utils/check-style/check-style reports no errors.

---
 dbms/src/DataStreams/LiveViewEventsBlockInputStream.h | 11 ++++-------
 dbms/src/Storages/StorageLiveView.h                   |  2 +-
 2 files changed, 5 insertions(+), 8 deletions(-)

diff --git a/dbms/src/DataStreams/LiveViewEventsBlockInputStream.h b/dbms/src/DataStreams/LiveViewEventsBlockInputStream.h
index be21c5c71f6..7841550b5cb 100644
--- a/dbms/src/DataStreams/LiveViewEventsBlockInputStream.h
+++ b/dbms/src/DataStreams/LiveViewEventsBlockInputStream.h
@@ -64,13 +64,10 @@ public:
         condition.broadcast();
     }
 
-    Block getHeader() const override 
+    Block getHeader() const override
     {
-        return 
-        { 
-            ColumnWithTypeAndName(ColumnUInt64::create(), std::make_shared<DataTypeUInt64>(), "version"), 
-            ColumnWithTypeAndName(ColumnString::create(), std::make_shared<DataTypeString>(), "hash")
-        };
+        Block header(ColumnWithTypeAndName(ColumnUInt64::create(), std::make_shared<DataTypeUInt64>(), "version"), ColumnWithTypeAndName(ColumnString::create(), std::make_shared<DataTypeString>(), "hash"));
+        return header;
     }
 
     void refresh()
@@ -88,7 +85,7 @@ public:
     {
         active = active_ptr.lock();
         {
-            if (!blocks || (blocks.get() != (*blocks_ptr).get())) 
+            if (!blocks || blocks.get() != (*blocks_ptr).get())
             {
                 blocks = (*blocks_ptr);
                 blocks_metadata = (*blocks_metadata_ptr);
diff --git a/dbms/src/Storages/StorageLiveView.h b/dbms/src/Storages/StorageLiveView.h
index 1114da7049d..6899067c9f9 100644
--- a/dbms/src/Storages/StorageLiveView.h
+++ b/dbms/src/Storages/StorageLiveView.h
@@ -29,7 +29,7 @@ namespace DB
 
 class IAST;
 
-struct BlocksMetadata 
+struct BlocksMetadata
 {
     String hash;
     UInt64 version;

From 12060d887973daea23821c8ab8bc8d76f48549b6 Mon Sep 17 00:00:00 2001
From: Vitaliy Zakaznikov <vzakaznikov@protonmail.com>
Date: Tue, 11 Jun 2019 08:27:47 -0400
Subject: [PATCH 039/107] * Fixing errors that prevented clang build.

---
 dbms/src/DataStreams/LiveViewBlockInputStream.h       |  8 ++++----
 dbms/src/DataStreams/LiveViewEventsBlockInputStream.h | 11 +++++------
 dbms/src/Parsers/ParserCreateQuery.cpp                |  1 -
 dbms/src/Storages/StorageLiveView.cpp                 |  3 +--
 dbms/src/Storages/StorageLiveView.h                   |  2 --
 5 files changed, 10 insertions(+), 15 deletions(-)

diff --git a/dbms/src/DataStreams/LiveViewBlockInputStream.h b/dbms/src/DataStreams/LiveViewBlockInputStream.h
index 6129c836597..9de503fd6f7 100644
--- a/dbms/src/DataStreams/LiveViewBlockInputStream.h
+++ b/dbms/src/DataStreams/LiveViewBlockInputStream.h
@@ -160,8 +160,8 @@ protected:
                     }
                     while (true)
                     {
-                        UInt64 timestamp_usec = (UInt64)timestamp.epochMicroseconds();
-                        bool signaled = condition.tryWait(mutex, std::max((UInt64)0, heartbeat_interval - (timestamp_usec - last_event_timestamp)) / 1000);
+                        UInt64 timestamp_usec = static_cast<UInt64>(timestamp.epochMicroseconds());
+                        bool signaled = condition.tryWait(mutex, std::max(static_cast<UInt64>(0), heartbeat_interval - (timestamp_usec - last_event_timestamp)) / 1000);
 
                         if (isCancelled() || storage.is_dropped)
                         {
@@ -174,7 +174,7 @@ protected:
                         else
                         {
                             // heartbeat
-                            last_event_timestamp = (UInt64)timestamp.epochMicroseconds();
+                            last_event_timestamp = static_cast<UInt64>(timestamp.epochMicroseconds());
                             return { getHeader(), true };
                         }
                     }
@@ -194,7 +194,7 @@ protected:
                 --length;
         }
 
-        last_event_timestamp = (UInt64)timestamp.epochMicroseconds();
+        last_event_timestamp = static_cast<UInt64>(timestamp.epochMicroseconds());
         return { res, true };
     }
 
diff --git a/dbms/src/DataStreams/LiveViewEventsBlockInputStream.h b/dbms/src/DataStreams/LiveViewEventsBlockInputStream.h
index 7841550b5cb..215d5a17380 100644
--- a/dbms/src/DataStreams/LiveViewEventsBlockInputStream.h
+++ b/dbms/src/DataStreams/LiveViewEventsBlockInputStream.h
@@ -66,8 +66,7 @@ public:
 
     Block getHeader() const override
     {
-        Block header(ColumnWithTypeAndName(ColumnUInt64::create(), std::make_shared<DataTypeUInt64>(), "version"), ColumnWithTypeAndName(ColumnString::create(), std::make_shared<DataTypeString>(), "hash"));
-        return header;
+        return {ColumnWithTypeAndName(ColumnUInt64::create(), std::make_shared<DataTypeUInt64>(), "version"), ColumnWithTypeAndName(ColumnString::create(), std::make_shared<DataTypeString>(), "hash")};
     }
 
     void refresh()
@@ -182,8 +181,8 @@ protected:
                     }
                     while (true)
                     {
-                        UInt64 timestamp_usec = (UInt64)timestamp.epochMicroseconds();
-                        bool signaled = condition.tryWait(mutex, std::max((UInt64)0, heartbeat_interval - (timestamp_usec - last_event_timestamp)) / 1000);
+                        UInt64 timestamp_usec = static_cast<UInt64>(timestamp.epochMicroseconds());
+                        bool signaled = condition.tryWait(mutex, std::max(static_cast<UInt64>(0), heartbeat_interval - (timestamp_usec - last_event_timestamp)) / 1000);
 
                         if (isCancelled() || storage.is_dropped)
                         {
@@ -196,7 +195,7 @@ protected:
                         else
                         {
                             // repeat the event block as a heartbeat
-                            last_event_timestamp = (UInt64)timestamp.epochMicroseconds();
+                            last_event_timestamp = static_cast<UInt64>(timestamp.epochMicroseconds());
                             return { getHeader(), true };
                         }
                     }
@@ -215,7 +214,7 @@ protected:
                 --length;
         }
 
-        last_event_timestamp = (UInt64)timestamp.epochMicroseconds();
+        last_event_timestamp = static_cast<UInt64>(timestamp.epochMicroseconds());
 
         return { getEventBlock(), true };
     }
diff --git a/dbms/src/Parsers/ParserCreateQuery.cpp b/dbms/src/Parsers/ParserCreateQuery.cpp
index 4064dde5213..c8341f81770 100644
--- a/dbms/src/Parsers/ParserCreateQuery.cpp
+++ b/dbms/src/Parsers/ParserCreateQuery.cpp
@@ -509,7 +509,6 @@ bool ParserCreateQuery::parseImpl(Pos & pos, ASTPtr & node, Expected & expected)
             if (!s_as.ignore(pos, expected))
                 return false;
 
-            ParserSelectWithUnionQuery select_p;
             if (!select_p.parse(pos, select, expected))
                 return false;
         }
diff --git a/dbms/src/Storages/StorageLiveView.cpp b/dbms/src/Storages/StorageLiveView.cpp
index dd6e0179410..28e6717611f 100644
--- a/dbms/src/Storages/StorageLiveView.cpp
+++ b/dbms/src/Storages/StorageLiveView.cpp
@@ -172,7 +172,6 @@ Block StorageLiveView::getHeader() const
 
 bool StorageLiveView::getNewBlocks()
 {
-    Block block;
     SipHash hash;
     UInt128 key;
     BlocksPtr new_blocks = std::make_shared<Blocks>();
@@ -398,7 +397,7 @@ BlockInputStreams StorageLiveView::watch(
     int64_t length = -2;
 
     if (query.limit_length)
-        length = (int64_t)safeGet<UInt64>(typeid_cast<ASTLiteral &>(*query.limit_length).value);
+        length = static_cast<int64_t>(safeGet<UInt64>(typeid_cast<ASTLiteral &>(*query.limit_length).value));
 
     if (query.is_watch_events)
     {
diff --git a/dbms/src/Storages/StorageLiveView.h b/dbms/src/Storages/StorageLiveView.h
index 6899067c9f9..01dd82ff1fd 100644
--- a/dbms/src/Storages/StorageLiveView.h
+++ b/dbms/src/Storages/StorageLiveView.h
@@ -257,10 +257,8 @@ private:
     std::shared_ptr<bool> active_ptr;
     /// Current data blocks that store query result
     std::shared_ptr<BlocksPtr> blocks_ptr;
-    BlocksPtr new_blocks;
     /// Current data blocks metadata
     std::shared_ptr<BlocksMetadataPtr> blocks_metadata_ptr;
-    BlocksMetadataPtr new_blocks_metadata;
     BlocksPtrs mergeable_blocks;
 
     void noUsersThread(const UInt64 & timeout);

From 536bdb588da53bc90f89933783dc94f04e1c307a Mon Sep 17 00:00:00 2001
From: Vitaliy Zakaznikov <vzakaznikov@protonmail.com>
Date: Tue, 11 Jun 2019 21:28:20 -0400
Subject: [PATCH 040/107] * Fixing and reorganazing LIVE VIEW tests

---
 .../0_stateless/00958_live_view_watch_live.py | 20 ++---
 .../00960_live_view_watch_events_live.py      | 20 ++---
 .../00962_temporary_live_view_watch_live.py   | 20 ++---
 ..._temporary_live_view_watch_live_timeout.py | 20 ++---
 .../00964_live_view_watch_events_heartbeat.py | 19 ++---
 .../00965_live_view_watch_heartbeat.py        | 20 ++---
 .../00966_live_view_watch_events_http.py      | 38 +++-------
 .../0_stateless/00967_live_view_watch_http.py | 38 +++-------
 ...0_live_view_watch_events_http_heartbeat.py | 45 ++++--------
 .../00971_live_view_watch_http_heartbeat.py   | 48 +++++-------
 .../queries/0_stateless/helpers/client.py     | 21 ++++++
 .../queries/0_stateless/helpers/httpclient.py | 14 ++++
 .../queries/0_stateless/helpers/httpexpect.py | 73 +++++++++++++++++++
 .../queries/0_stateless/helpers/uexpect.py    | 30 +++++---
 14 files changed, 224 insertions(+), 202 deletions(-)
 create mode 100644 dbms/tests/queries/0_stateless/helpers/client.py
 create mode 100644 dbms/tests/queries/0_stateless/helpers/httpclient.py
 create mode 100644 dbms/tests/queries/0_stateless/helpers/httpexpect.py

diff --git a/dbms/tests/queries/0_stateless/00958_live_view_watch_live.py b/dbms/tests/queries/0_stateless/00958_live_view_watch_live.py
index 96537d0d5c1..cb6f1e95f7e 100755
--- a/dbms/tests/queries/0_stateless/00958_live_view_watch_live.py
+++ b/dbms/tests/queries/0_stateless/00958_live_view_watch_live.py
@@ -1,25 +1,18 @@
 #!/usr/bin/env python
-import imp
 import os
 import sys
 import signal
 
 CURDIR = os.path.dirname(os.path.realpath(__file__))
+sys.path.insert(0, os.path.join(CURDIR, 'helpers'))
 
-uexpect = imp.load_source('uexpect', os.path.join(CURDIR, 'helpers', 'uexpect.py'))
+from client import client, prompt, end_of_block
 
-def client(name=''):
-    client = uexpect.spawn(os.environ.get('CLICKHOUSE_CLIENT'))
-    client.eol('\r')
-    # Note: uncomment this line for debugging
-    #client.logger(sys.stdout, prefix=name)
-    client.timeout(2)
-    return client
+log = None
+# uncomment the line below for debugging
+#log=sys.stdout
 
-prompt = ':\) '
-end_of_block = r'.*\r\n.*\r\n'
-
-with client('client1>') as client1, client('client2>') as client2:
+with client(name='client1>', log=log) as client1, client(name='client2>', log=log) as client2:
     client1.expect(prompt)
     client2.expect(prompt)
 
@@ -32,6 +25,7 @@ with client('client1>') as client1, client('client2>') as client2:
     client1.send('CREATE LIVE VIEW test.lv AS SELECT sum(a) FROM test.mt')
     client1.expect(prompt)
     client1.send('WATCH test.lv')
+    client1.expect(r'0.*1' + end_of_block)
     client2.send('INSERT INTO test.mt VALUES (1),(2),(3)')
     client1.expect(r'6.*2' + end_of_block)
     client2.send('INSERT INTO test.mt VALUES (4),(5),(6)')
diff --git a/dbms/tests/queries/0_stateless/00960_live_view_watch_events_live.py b/dbms/tests/queries/0_stateless/00960_live_view_watch_events_live.py
index a775854de9e..414f9c1ad96 100755
--- a/dbms/tests/queries/0_stateless/00960_live_view_watch_events_live.py
+++ b/dbms/tests/queries/0_stateless/00960_live_view_watch_events_live.py
@@ -1,25 +1,18 @@
 #!/usr/bin/env python
-import imp
 import os
 import sys
 import signal
 
 CURDIR = os.path.dirname(os.path.realpath(__file__))
+sys.path.insert(0, os.path.join(CURDIR, 'helpers'))
 
-uexpect = imp.load_source('uexpect', os.path.join(CURDIR, 'helpers', 'uexpect.py'))
+from client import client, prompt, end_of_block
 
-def client(name=''):
-    client = uexpect.spawn(os.environ.get('CLICKHOUSE_CLIENT'))
-    client.eol('\r')
-    # Note: uncomment this line for debugging
-    #client.logger(sys.stdout, prefix=name)
-    client.timeout(2)
-    return client
+log = None
+# uncomment the line below for debugging
+#log=sys.stdout
 
-prompt = ':\) '
-end_of_block = r'.*\r\n.*\r\n'
-
-with client('client1>') as client1, client('client2>') as client2:
+with client(name='client1>', log=log) as client1, client(name='client2>', log=log) as client2:
     client1.expect(prompt)
     client2.expect(prompt)
 
@@ -32,6 +25,7 @@ with client('client1>') as client1, client('client2>') as client2:
     client1.send('CREATE LIVE VIEW test.lv AS SELECT sum(a) FROM test.mt')
     client1.expect(prompt)
     client1.send('WATCH test.lv EVENTS')
+    client1.expect('1.*' + end_of_block)
     client2.send('INSERT INTO test.mt VALUES (1),(2),(3)')
     client1.expect('2.*4cd0592103888d4682de9a32a23602e3' + end_of_block)
     client2.send('INSERT INTO test.mt VALUES (4),(5),(6)')
diff --git a/dbms/tests/queries/0_stateless/00962_temporary_live_view_watch_live.py b/dbms/tests/queries/0_stateless/00962_temporary_live_view_watch_live.py
index fb75134fc4c..48311d890c5 100755
--- a/dbms/tests/queries/0_stateless/00962_temporary_live_view_watch_live.py
+++ b/dbms/tests/queries/0_stateless/00962_temporary_live_view_watch_live.py
@@ -1,25 +1,18 @@
 #!/usr/bin/env python
-import imp
 import os
 import sys
 import signal
 
 CURDIR = os.path.dirname(os.path.realpath(__file__))
+sys.path.insert(0, os.path.join(CURDIR, 'helpers'))
 
-uexpect = imp.load_source('uexpect', os.path.join(CURDIR, 'helpers', 'uexpect.py'))
+from client import client, prompt, end_of_block
 
-def client(name=''):
-    client = uexpect.spawn(os.environ.get('CLICKHOUSE_CLIENT'))
-    client.eol('\r')
-    # Note: uncomment this line for debugging
-    #client.logger(sys.stdout, prefix=name)
-    client.timeout(2)
-    return client
+log = None
+# uncomment the line below for debugging
+#log=sys.stdout
 
-prompt = ':\) '
-end_of_block = r'.*\r\n.*\r\n'
-
-with client('client1>') as client1, client('client2>') as client2:
+with client(name='client1>', log=log) as client1, client(name='client2>', log=log) as client2:
     client1.expect(prompt)
     client2.expect(prompt)
 
@@ -32,6 +25,7 @@ with client('client1>') as client1, client('client2>') as client2:
     client1.send('CREATE TEMPORARY LIVE VIEW test.lv AS SELECT sum(a) FROM test.mt')
     client1.expect(prompt)
     client1.send('WATCH test.lv')
+    client1.expect(r'0.*1' + end_of_block)
     client2.send('INSERT INTO test.mt VALUES (1),(2),(3)')
     client1.expect(r'6.*2' + end_of_block)
     client2.send('INSERT INTO test.mt VALUES (4),(5),(6)')
diff --git a/dbms/tests/queries/0_stateless/00963_temporary_live_view_watch_live_timeout.py b/dbms/tests/queries/0_stateless/00963_temporary_live_view_watch_live_timeout.py
index 4e12cd2234b..581363cd796 100755
--- a/dbms/tests/queries/0_stateless/00963_temporary_live_view_watch_live_timeout.py
+++ b/dbms/tests/queries/0_stateless/00963_temporary_live_view_watch_live_timeout.py
@@ -1,25 +1,18 @@
 #!/usr/bin/env python
-import imp
 import os
 import sys
 import signal
 
 CURDIR = os.path.dirname(os.path.realpath(__file__))
+sys.path.insert(0, os.path.join(CURDIR, 'helpers'))
 
-uexpect = imp.load_source('uexpect', os.path.join(CURDIR, 'helpers', 'uexpect.py'))
+from client import client, prompt, end_of_block
 
-def client(name=''):
-    client = uexpect.spawn(os.environ.get('CLICKHOUSE_CLIENT'))
-    client.eol('\r')
-    # Note: uncomment this line for debugging
-    #client.logger(sys.stdout, prefix=name)
-    client.timeout(2)
-    return client
+log = None
+# uncomment the line below for debugging
+#log=sys.stdout
 
-prompt = ':\) '
-end_of_block = r'.*\r\n.*\r\n'
-
-with client('client1>') as client1, client('client2>') as client2:
+with client(name='client1>', log=log) as client1, client(name='client2>', log=log) as client2:
     client1.expect(prompt)
     client2.expect(prompt)
 
@@ -34,6 +27,7 @@ with client('client1>') as client1, client('client2>') as client2:
     client1.send('CREATE TEMPORARY LIVE VIEW test.lv AS SELECT sum(a) FROM test.mt')
     client1.expect(prompt)
     client1.send('WATCH test.lv')
+    client1.expect(r'0.*1' + end_of_block)
     client2.send('INSERT INTO test.mt VALUES (1),(2),(3)')
     client2.expect(prompt)
     client1.expect(r'6.*2' + end_of_block)
diff --git a/dbms/tests/queries/0_stateless/00964_live_view_watch_events_heartbeat.py b/dbms/tests/queries/0_stateless/00964_live_view_watch_events_heartbeat.py
index c7b2b1a6906..b624e0b7080 100755
--- a/dbms/tests/queries/0_stateless/00964_live_view_watch_events_heartbeat.py
+++ b/dbms/tests/queries/0_stateless/00964_live_view_watch_events_heartbeat.py
@@ -1,25 +1,18 @@
 #!/usr/bin/env python
-import imp
 import os
 import sys
 import signal
 
 CURDIR = os.path.dirname(os.path.realpath(__file__))
+sys.path.insert(0, os.path.join(CURDIR, 'helpers'))
 
-uexpect = imp.load_source('uexpect', os.path.join(CURDIR, 'helpers', 'uexpect.py'))
+from client import client, prompt, end_of_block
 
-def client(name=''):
-    client = uexpect.spawn(os.environ.get('CLICKHOUSE_CLIENT'))
-    client.eol('\r')
-    # Note: uncomment this line for debugging
-    #client.logger(sys.stdout, prefix=name)
-    client.timeout(2)
-    return client
+log = None
+# uncomment the line below for debugging
+#log=sys.stdout
 
-prompt = ':\) '
-end_of_block = r'.*\r\n.*\r\n'
-
-with client('client1>') as client1, client('client2>') as client2:
+with client(name='client1>', log=log) as client1, client(name='client2>', log=log) as client2:
     client1.expect(prompt)
     client2.expect(prompt)
 
diff --git a/dbms/tests/queries/0_stateless/00965_live_view_watch_heartbeat.py b/dbms/tests/queries/0_stateless/00965_live_view_watch_heartbeat.py
index b501c6e5889..dfb46273f7c 100755
--- a/dbms/tests/queries/0_stateless/00965_live_view_watch_heartbeat.py
+++ b/dbms/tests/queries/0_stateless/00965_live_view_watch_heartbeat.py
@@ -1,25 +1,18 @@
 #!/usr/bin/env python
-import imp
 import os
 import sys
 import signal
 
 CURDIR = os.path.dirname(os.path.realpath(__file__))
+sys.path.insert(0, os.path.join(CURDIR, 'helpers'))
 
-uexpect = imp.load_source('uexpect', os.path.join(CURDIR, 'helpers', 'uexpect.py'))
+from client import client, prompt, end_of_block
 
-def client(name=''):
-    client = uexpect.spawn(os.environ.get('CLICKHOUSE_CLIENT'))
-    client.eol('\r')
-    # Note: uncomment this line for debugging
-    #client.logger(sys.stdout, prefix=name)
-    client.timeout(2)
-    return client
+log = None
+# uncomment the line below for debugging
+#log=sys.stdout
 
-prompt = ':\) '
-end_of_block = r'.*\r\n.*\r\n'
-
-with client('client1>') as client1, client('client2>') as client2:
+with client(name='client1>', log=log) as client1, client(name='client2>', log=log) as client2:
     client1.expect(prompt)
     client2.expect(prompt)
 
@@ -34,6 +27,7 @@ with client('client1>') as client1, client('client2>') as client2:
     client1.send('CREATE TEMPORARY LIVE VIEW test.lv AS SELECT sum(a) FROM test.mt')
     client1.expect(prompt)
     client1.send('WATCH test.lv')
+    client1.expect(r'0.*1' + end_of_block)
     client2.send('INSERT INTO test.mt VALUES (1),(2),(3)')
     client1.expect(r'6.*2' + end_of_block)
     client1.expect('Progress: 2.00 rows.*\)')
diff --git a/dbms/tests/queries/0_stateless/00966_live_view_watch_events_http.py b/dbms/tests/queries/0_stateless/00966_live_view_watch_events_http.py
index 4424bac3e54..a1b6f2418ea 100755
--- a/dbms/tests/queries/0_stateless/00966_live_view_watch_events_http.py
+++ b/dbms/tests/queries/0_stateless/00966_live_view_watch_events_http.py
@@ -1,28 +1,18 @@
 #!/usr/bin/env python
-import imp
 import os
 import sys
-import signal
 
 CURDIR = os.path.dirname(os.path.realpath(__file__))
+sys.path.insert(0, os.path.join(CURDIR, 'helpers'))
 
-uexpect = imp.load_source('uexpect', os.path.join(CURDIR, 'helpers', 'uexpect.py'))
+from client import client, prompt, end_of_block
+from httpclient import client as http_client
 
-def client(name='', command=None):
-    if command is None:
-        client = uexpect.spawn(os.environ.get('CLICKHOUSE_CLIENT'))
-    else:
-        client = uexpect.spawn(command)
-    client.eol('\r')
-    # Note: uncomment this line for debugging
-    #client.logger(sys.stdout, prefix=name)
-    client.timeout(2)
-    return client
+log = None
+# uncomment the line below for debugging
+#log=sys.stdout
 
-prompt = ':\) '
-end_of_block = r'.*\r\n.*\r\n'
-
-with client('client1>') as client1, client('client2>', ['bash', '--noediting']) as client2:
+with client(name='client1>', log=log) as client1:
     client1.expect(prompt)
 
     client1.send('DROP TABLE IF EXISTS test.lv')
@@ -34,16 +24,12 @@ with client('client1>') as client1, client('client2>', ['bash', '--noediting'])
     client1.send('CREATE LIVE VIEW test.lv AS SELECT sum(a) FROM test.mt')
     client1.expect(prompt)
 
-    client2.expect('[\$#] ')
-    client2.send('wget -O- -q "http://localhost:8123/?query=WATCH test.lv EVENTS"')
-    client2.expect('.*1\tc9d39b11cce79112219a73aaa319b475\r\n')
 
-    client1.send('INSERT INTO test.mt VALUES (1),(2),(3)')
-    client1.expect(prompt)
-
-    client2.expect('.*2\t.*\r\n')
-    ## send Ctrl-C
-    os.kill(client2.process.pid,signal.SIGINT)
+    with http_client({'method':'GET', 'url': '/?query=WATCH%20test.lv%20EVENTS'}, name='client2>', log=log) as client2:
+        client2.expect('.*1\tc9d39b11cce79112219a73aaa319b475\n')
+        client1.send('INSERT INTO test.mt VALUES (1),(2),(3)')
+        client1.expect(prompt)
+        client2.expect('.*2\t.*\n')
 
     client1.send('DROP TABLE test.lv')
     client1.expect(prompt)
diff --git a/dbms/tests/queries/0_stateless/00967_live_view_watch_http.py b/dbms/tests/queries/0_stateless/00967_live_view_watch_http.py
index 3c7e8cdd489..d3439431eb3 100755
--- a/dbms/tests/queries/0_stateless/00967_live_view_watch_http.py
+++ b/dbms/tests/queries/0_stateless/00967_live_view_watch_http.py
@@ -1,28 +1,18 @@
 #!/usr/bin/env python
-import imp
 import os
 import sys
-import signal
 
 CURDIR = os.path.dirname(os.path.realpath(__file__))
+sys.path.insert(0, os.path.join(CURDIR, 'helpers'))
 
-uexpect = imp.load_source('uexpect', os.path.join(CURDIR, 'helpers', 'uexpect.py'))
+from client import client, prompt, end_of_block
+from httpclient import client as http_client
 
-def client(name='', command=None):
-    if command is None:
-        client = uexpect.spawn(os.environ.get('CLICKHOUSE_CLIENT'))
-    else:
-        client = uexpect.spawn(command)
-    client.eol('\r')
-    # Note: uncomment this line for debugging
-    #client.logger(sys.stdout, prefix=name)
-    client.timeout(2)
-    return client
+log = None
+# uncomment the line below for debugging
+#log=sys.stdout
 
-prompt = ':\) '
-end_of_block = r'.*\r\n.*\r\n'
-
-with client('client1>') as client1, client('client2>', ['bash', '--noediting']) as client2:
+with client(name='client1>', log=log) as client1:
     client1.expect(prompt)
 
     client1.send('DROP TABLE IF EXISTS test.lv')
@@ -34,16 +24,12 @@ with client('client1>') as client1, client('client2>', ['bash', '--noediting'])
     client1.send('CREATE LIVE VIEW test.lv AS SELECT sum(a) FROM test.mt')
     client1.expect(prompt)
 
-    client2.expect('[\$#] ')
-    client2.send('wget -O- -q "http://localhost:8123/?query=WATCH test.lv"')
-    client2.expect('.*0\t1\r\n')
 
-    client1.send('INSERT INTO test.mt VALUES (1),(2),(3)')
-    client1.expect(prompt)
-
-    client2.expect('.*6\t2\r\n')
-    ## send Ctrl-C
-    os.kill(client2.process.pid,signal.SIGINT)
+    with http_client({'method':'GET', 'url':'/?query=WATCH%20test.lv'}, name='client2>', log=log) as client2:
+        client2.expect('.*0\t1\n')
+        client1.send('INSERT INTO test.mt VALUES (1),(2),(3)')
+        client1.expect(prompt)
+        client2.expect('.*6\t2\n')
 
     client1.send('DROP TABLE test.lv')
     client1.expect(prompt)
diff --git a/dbms/tests/queries/0_stateless/00970_live_view_watch_events_http_heartbeat.py b/dbms/tests/queries/0_stateless/00970_live_view_watch_events_http_heartbeat.py
index b7ab164c67a..29ea2142d5c 100755
--- a/dbms/tests/queries/0_stateless/00970_live_view_watch_events_http_heartbeat.py
+++ b/dbms/tests/queries/0_stateless/00970_live_view_watch_events_http_heartbeat.py
@@ -1,28 +1,18 @@
 #!/usr/bin/env python
-import imp
 import os
 import sys
-import signal
 
 CURDIR = os.path.dirname(os.path.realpath(__file__))
+sys.path.insert(0, os.path.join(CURDIR, 'helpers'))
 
-uexpect = imp.load_source('uexpect', os.path.join(CURDIR, 'helpers', 'uexpect.py'))
+from client import client, prompt, end_of_block
+from httpclient import client as http_client
 
-def client(name='', command=None):
-    if command is None:
-        client = uexpect.spawn(os.environ.get('CLICKHOUSE_CLIENT'))
-    else:
-        client = uexpect.spawn(command)
-    client.eol('\r')
-    # Note: uncomment this line for debugging
-    #client.logger(sys.stdout, prefix=name)
-    client.timeout(2)
-    return client
+log = None
+# uncomment the line below for debugging
+#log=sys.stdout
 
-prompt = ':\) '
-end_of_block = r'.*\r\n.*\r\n'
-
-with client('client1>') as client1, client('client2>', ['bash', '--noediting']) as client2:
+with client(name='client1>', log=log) as client1:
     client1.expect(prompt)
 
     client1.send('DROP TABLE IF EXISTS test.lv')
@@ -34,21 +24,18 @@ with client('client1>') as client1, client('client2>', ['bash', '--noediting'])
     client1.send('CREATE LIVE VIEW test.lv AS SELECT sum(a) FROM test.mt')
     client1.expect(prompt)
 
-    client2.expect('[\$#] ')
-    client2.send('wget -O- -q "http://localhost:8123/?live_view_heartbeat_interval=1&query=WATCH test.lv EVENTS FORMAT JSONEachRowWithProgress"')
-    client2.expect('{"progress":{"read_rows":"1","read_bytes":"49","written_rows":"0","written_bytes":"0","total_rows_to_read":"0"}}\r\n', escape=True)
-    client2.expect('{"row":{"version":"1","hash":"c9d39b11cce79112219a73aaa319b475"}}', escape=True)
-    client2.expect('{"progress":{"read_rows":"1","read_bytes":"49","written_rows":"0","written_bytes":"0","total_rows_to_read":"0"}}', escape=True)
-    # heartbeat is provided by progress message
-    client2.expect('{"progress":{"read_rows":"1","read_bytes":"49","written_rows":"0","written_bytes":"0","total_rows_to_read":"0"}}', escape=True)
 
-    client1.send('INSERT INTO test.mt VALUES (1),(2),(3)')
-    client1.expect(prompt)
+    with http_client({'method':'GET', 'url': '/?live_view_heartbeat_interval=1&query=WATCH%20test.lv%20EVENTS%20FORMAT%20JSONEachRowWithProgress'}, name='client2>', log=log) as client2:
+        client2.expect('{"progress":{"read_rows":"1","read_bytes":"49","written_rows":"0","written_bytes":"0","total_rows_to_read":"0"}}\n', escape=True)
+        client2.expect('{"row":{"version":"1","hash":"c9d39b11cce79112219a73aaa319b475"}}', escape=True)
+        client2.expect('{"progress":{"read_rows":"1","read_bytes":"49","written_rows":"0","written_bytes":"0","total_rows_to_read":"0"}}', escape=True)
+        # heartbeat is provided by progress message
+        client2.expect('{"progress":{"read_rows":"1","read_bytes":"49","written_rows":"0","written_bytes":"0","total_rows_to_read":"0"}}', escape=True)
 
-    client2.expect('{"row":{"version":"2","hash":"4cd0592103888d4682de9a32a23602e3"}}\r\n', escape=True)
+        client1.send('INSERT INTO test.mt VALUES (1),(2),(3)')
+        client1.expect(prompt)
 
-    ## send Ctrl-C
-    os.kill(client2.process.pid,signal.SIGINT)
+        client2.expect('{"row":{"version":"2","hash":"4cd0592103888d4682de9a32a23602e3"}}\n', escape=True)
 
     client1.send('DROP TABLE test.lv')
     client1.expect(prompt)
diff --git a/dbms/tests/queries/0_stateless/00971_live_view_watch_http_heartbeat.py b/dbms/tests/queries/0_stateless/00971_live_view_watch_http_heartbeat.py
index 2102b890132..7bdb47b7caa 100755
--- a/dbms/tests/queries/0_stateless/00971_live_view_watch_http_heartbeat.py
+++ b/dbms/tests/queries/0_stateless/00971_live_view_watch_http_heartbeat.py
@@ -1,28 +1,18 @@
 #!/usr/bin/env python
-import imp
 import os
 import sys
-import signal
 
 CURDIR = os.path.dirname(os.path.realpath(__file__))
+sys.path.insert(0, os.path.join(CURDIR, 'helpers'))
 
-uexpect = imp.load_source('uexpect', os.path.join(CURDIR, 'helpers', 'uexpect.py'))
+from client import client, prompt, end_of_block
+from httpclient import client as http_client
 
-def client(name='', command=None):
-    if command is None:
-        client = uexpect.spawn(os.environ.get('CLICKHOUSE_CLIENT'))
-    else:
-        client = uexpect.spawn(command)
-    client.eol('\r')
-    # Note: uncomment this line for debugging
-    #client.logger(sys.stdout, prefix=name)
-    client.timeout(2)
-    return client
+log = None
+# uncomment the line below for debugging
+#log=sys.stdout
 
-prompt = ':\) '
-end_of_block = r'.*\r\n.*\r\n'
-
-with client('client1>') as client1, client('client2>', ['bash', '--noediting']) as client2:
+with client(name='client1>', log=log) as client1:
     client1.expect(prompt)
 
     client1.send('DROP TABLE IF EXISTS test.lv')
@@ -34,22 +24,18 @@ with client('client1>') as client1, client('client2>', ['bash', '--noediting'])
     client1.send('CREATE LIVE VIEW test.lv AS SELECT sum(a) FROM test.mt')
     client1.expect(prompt)
 
-    client2.expect('[\$#] ')
-    client2.send('wget -O- -q "http://localhost:8123/?live_view_heartbeat_interval=1&query=WATCH test.lv FORMAT JSONEachRowWithProgress"')
-    client2.expect('"progress".*',)
-    client2.expect('{"row":{"sum(a)":"0","_version":"1"}}\r\n', escape=True)
-    client2.expect('"progress".*\r\n')
-    # heartbeat is provided by progress message
-    client2.expect('"progress".*\r\n')
+    with http_client({'method':'GET', 'url':'/?live_view_heartbeat_interval=1&query=WATCH%20test.lv%20FORMAT%20JSONEachRowWithProgress'}, name='client2>', log=log) as client2:
+        client2.expect('"progress".*',)
+        client2.expect('{"row":{"sum(a)":"0","_version":"1"}}\n', escape=True)
+        client2.expect('"progress".*\n')
+        # heartbeat is provided by progress message
+        client2.expect('"progress".*\n')
 
-    client1.send('INSERT INTO test.mt VALUES (1),(2),(3)')
-    client1.expect(prompt)
+        client1.send('INSERT INTO test.mt VALUES (1),(2),(3)')
+        client1.expect(prompt)
 
-    client2.expect('"progress".*"read_rows":"2".*\r\n')
-    client2.expect('{"row":{"sum(a)":"6","_version":"2"}}\r\n', escape=True)
-
-    ## send Ctrl-C
-    os.kill(client2.process.pid, signal.SIGINT)
+        client2.expect('"progress".*"read_rows":"2".*\n')
+        client2.expect('{"row":{"sum(a)":"6","_version":"2"}}\n', escape=True)
 
     client1.send('DROP TABLE test.lv')
     client1.expect(prompt)
diff --git a/dbms/tests/queries/0_stateless/helpers/client.py b/dbms/tests/queries/0_stateless/helpers/client.py
new file mode 100644
index 00000000000..b509a321cee
--- /dev/null
+++ b/dbms/tests/queries/0_stateless/helpers/client.py
@@ -0,0 +1,21 @@
+import os
+import sys
+
+CURDIR = os.path.dirname(os.path.realpath(__file__))
+
+sys.path.insert(0, os.path.join(CURDIR))
+
+import uexpect
+
+prompt = ':\) '
+end_of_block = r'.*\r\n.*\r\n'
+
+def client(command=None, name='', log=None):
+    if command is None:
+        client = uexpect.spawn(os.environ.get('CLICKHOUSE_CLIENT'))
+    else:
+        client = uexpect.spawn(command)
+    client.eol('\r')
+    client.logger(log, prefix=name)
+    client.timeout(2)
+    return client
diff --git a/dbms/tests/queries/0_stateless/helpers/httpclient.py b/dbms/tests/queries/0_stateless/helpers/httpclient.py
new file mode 100644
index 00000000000..111841ba708
--- /dev/null
+++ b/dbms/tests/queries/0_stateless/helpers/httpclient.py
@@ -0,0 +1,14 @@
+import os
+import sys
+
+CURDIR = os.path.dirname(os.path.realpath(__file__))
+
+sys.path.insert(0, os.path.join(CURDIR))
+
+import httpexpect
+
+def client(request, name='', log=None):
+    client = httpexpect.spawn({'host':'localhost','port':8123}, request)
+    client.logger(log, prefix=name)
+    client.timeout(2)
+    return client
diff --git a/dbms/tests/queries/0_stateless/helpers/httpexpect.py b/dbms/tests/queries/0_stateless/helpers/httpexpect.py
new file mode 100644
index 00000000000..e440dafce4e
--- /dev/null
+++ b/dbms/tests/queries/0_stateless/helpers/httpexpect.py
@@ -0,0 +1,73 @@
+# Copyright (c) 2019 Vitaliy Zakaznikov
+#
+# 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.
+import os
+import sys
+import httplib
+
+CURDIR = os.path.dirname(os.path.realpath(__file__))
+sys.path.insert(0, CURDIR)
+
+import uexpect
+
+from threading import Thread, Event
+from Queue import Queue, Empty
+
+class IO(uexpect.IO):
+    def __init__(self, connection, response, queue, reader):
+        self.connection = connection
+        self.response = response
+        super(IO, self).__init__(None, None, queue, reader)
+
+    def write(self, data):
+        raise NotImplementedError
+
+    def close(self, force=True):
+        self.reader['kill_event'].set()
+        self.connection.close()
+        if self._logger:
+            self._logger.write('\n')
+            self._logger.flush()
+
+
+def reader(response, queue, kill_event):
+    while True:
+        try:
+            if kill_event.is_set():
+                break
+            data = response.read(1)
+            queue.put(data)
+        except Exception, e:
+            if kill_event.is_set():
+                break
+            raise
+
+def spawn(connection, request):
+    connection = httplib.HTTPConnection(**connection)
+    connection.request(**request)
+    response = connection.getresponse()
+
+    queue = Queue()
+    reader_kill_event = Event()
+    thread = Thread(target=reader, args=(response, queue, reader_kill_event))
+    thread.daemon = True
+    thread.start()
+
+    return IO(connection, response, queue, reader={'thread':thread, 'kill_event':reader_kill_event})
+
+if __name__ == '__main__':
+    with http({'host':'localhost','port':8123},{'method':'GET', 'url':'?query=SELECT%201'}) as client:
+        client.logger(sys.stdout)
+        client.timeout(2)
+        print client.response.status, client.response.reason
+        client.expect('1\n')
diff --git a/dbms/tests/queries/0_stateless/helpers/uexpect.py b/dbms/tests/queries/0_stateless/helpers/uexpect.py
index 2a42b8a5de0..2f323cf6ca6 100644
--- a/dbms/tests/queries/0_stateless/helpers/uexpect.py
+++ b/dbms/tests/queries/0_stateless/helpers/uexpect.py
@@ -35,10 +35,13 @@ class ExpectTimeoutError(Exception):
         self.buffer = buffer
 
     def __str__(self):
-        return ('Timeout %.3fs ' % float(self.timeout) +
-            'for %s ' % repr(self.pattern.pattern) +
-            'buffer %s ' % repr(self.buffer[:]) +
-            'or \'%s\'' % ','.join(['%x' % ord(c) for c in self.buffer[:]]))
+        s = 'Timeout %.3fs ' % float(self.timeout)
+        if self.pattern:
+            s += 'for %s ' % repr(self.pattern.pattern)
+        if self.buffer:
+            s += 'buffer %s ' % repr(self.buffer[:])
+            s += 'or \'%s\'' % ','.join(['%x' % ord(c) for c in self.buffer[:]])
+        return s
 
 class IO(object):
     class EOF(object):
@@ -125,13 +128,22 @@ class IO(object):
         if timeout is None:
             timeout = self._timeout
         timeleft = timeout
-        while timeleft >= 0:
+        while True:
             start_time = time.time()
+            if self.buffer is not None:
+                self.match = pattern.search(self.buffer, 0)
+                if self.match is not None:
+                    self.after = self.buffer[self.match.start():self.match.end()]
+                    self.before = self.buffer[:self.match.start()]
+                    self.buffer = self.buffer[self.match.end():]
+                    break
+            if timeleft < 0:
+                break
             try:
                 data = self.read(timeout=timeleft, raise_exception=True)
             except TimeoutError:
                 if self._logger:
-                    self._logger.write(self.buffer + '\n')
+                    self._logger.write((self.buffer or '') + '\n')
                     self._logger.flush()
                 exception = ExpectTimeoutError(pattern, timeout, self.buffer)
                 self.buffer = None
@@ -139,12 +151,6 @@ class IO(object):
             timeleft -= (time.time() - start_time)
             if data:
                 self.buffer = (self.buffer + data) if self.buffer else data
-            self.match = pattern.search(self.buffer, 0)
-            if self.match is not None:
-                self.after = self.buffer[self.match.start():self.match.end()]
-                self.before = self.buffer[:self.match.start()]
-                self.buffer = self.buffer[self.match.end():]
-                break
         if self._logger:
             self._logger.write((self.before or '') + (self.after or ''))
             self._logger.flush()

From 5983273694c45c76da6619b0b732d52e02db8bd7 Mon Sep 17 00:00:00 2001
From: Vitaliy Zakaznikov <vzakaznikov@protonmail.com>
Date: Wed, 12 Jun 2019 09:11:44 -0400
Subject: [PATCH 041/107] Fixing bugs reported by sanitizers * data race
 condition on storage is_dropped access * invalid reference to storage after
 it is deleted * invalid reference to mutex after storage is deleted

---
 .../DataStreams/LiveViewBlockInputStream.h    | 33 +++++++++----------
 .../LiveViewEventsBlockInputStream.h          | 28 ++++++++--------
 dbms/src/Storages/IStorage.h                  |  2 +-
 dbms/src/Storages/StorageLiveView.cpp         |  4 +--
 4 files changed, 32 insertions(+), 35 deletions(-)

diff --git a/dbms/src/DataStreams/LiveViewBlockInputStream.h b/dbms/src/DataStreams/LiveViewBlockInputStream.h
index 9de503fd6f7..e9bb599a1d6 100644
--- a/dbms/src/DataStreams/LiveViewBlockInputStream.h
+++ b/dbms/src/DataStreams/LiveViewBlockInputStream.h
@@ -36,17 +36,18 @@ public:
     {
         /// Start storage no users thread
         /// if we are the last active user
-        if (!storage.is_dropped && blocks_ptr.use_count() < 3)
-            storage.startNoUsersThread(temporary_live_view_timeout);
+        if (!storage->is_dropped && blocks_ptr.use_count() < 3)
+            storage->startNoUsersThread(temporary_live_view_timeout);
     }
     /// length default -2 because we want LIMIT to specify number of updates so that LIMIT 1 waits for 1 update
     /// and LIMIT 0 just returns data without waiting for any updates
-    LiveViewBlockInputStream(StorageLiveView & storage_, std::shared_ptr<BlocksPtr> blocks_ptr_,
+    LiveViewBlockInputStream(std::shared_ptr<StorageLiveView> storage_,
+        std::shared_ptr<BlocksPtr> blocks_ptr_,
         std::shared_ptr<BlocksMetadataPtr> blocks_metadata_ptr_,
-        std::shared_ptr<bool> active_ptr_, Poco::Condition & condition_, Poco::FastMutex & mutex_,
+        std::shared_ptr<bool> active_ptr_,
         int64_t length_, const UInt64 & heartbeat_interval_,
         const UInt64 & temporary_live_view_timeout_)
-        : storage(storage_), blocks_ptr(blocks_ptr_), blocks_metadata_ptr(blocks_metadata_ptr_), active_ptr(active_ptr_), condition(condition_), mutex(mutex_), length(length_ + 1), heartbeat_interval(heartbeat_interval_ * 1000000), temporary_live_view_timeout(temporary_live_view_timeout_),
+        : storage(storage_), blocks_ptr(blocks_ptr_), blocks_metadata_ptr(blocks_metadata_ptr_), active_ptr(active_ptr_), length(length_ + 1), heartbeat_interval(heartbeat_interval_ * 1000000), temporary_live_view_timeout(temporary_live_view_timeout_),
         blocks_hash("")
     {
         /// grab active pointer
@@ -57,14 +58,14 @@ public:
 
     void cancel(bool kill) override
     {
-        if (isCancelled() || storage.is_dropped)
+        if (isCancelled() || storage->is_dropped)
             return;
         IBlockInputStream::cancel(kill);
-        Poco::FastMutex::ScopedLock lock(mutex);
-        condition.broadcast();
+        Poco::FastMutex::ScopedLock lock(storage->mutex);
+        storage->condition.broadcast();
     }
 
-    Block getHeader() const override { return storage.getHeader(); }
+    Block getHeader() const override { return storage->getHeader(); }
 
     void refresh()
     {
@@ -117,7 +118,7 @@ protected:
         /// If blocks were never assigned get blocks
         if (!blocks)
         {
-            Poco::FastMutex::ScopedLock lock(mutex);
+            Poco::FastMutex::ScopedLock lock(storage->mutex);
             if (!active)
                 return { Block(), false };
             blocks = (*blocks_ptr);
@@ -126,7 +127,7 @@ protected:
             end = blocks->end();
         }
 
-        if (isCancelled() || storage.is_dropped)
+        if (isCancelled() || storage->is_dropped)
         {
             return { Block(), true };
         }
@@ -134,7 +135,7 @@ protected:
         if (it == end)
         {
             {
-                Poco::FastMutex::ScopedLock lock(mutex);
+                Poco::FastMutex::ScopedLock lock(storage->mutex);
                 if (!active)
                     return { Block(), false };
                 /// If we are done iterating over our blocks
@@ -161,9 +162,9 @@ protected:
                     while (true)
                     {
                         UInt64 timestamp_usec = static_cast<UInt64>(timestamp.epochMicroseconds());
-                        bool signaled = condition.tryWait(mutex, std::max(static_cast<UInt64>(0), heartbeat_interval - (timestamp_usec - last_event_timestamp)) / 1000);
+                        bool signaled = storage->condition.tryWait(storage->mutex, std::max(static_cast<UInt64>(0), heartbeat_interval - (timestamp_usec - last_event_timestamp)) / 1000);
 
-                        if (isCancelled() || storage.is_dropped)
+                        if (isCancelled() || storage->is_dropped)
                         {
                             return { Block(), true };
                         }
@@ -199,7 +200,7 @@ protected:
     }
 
 private:
-    StorageLiveView & storage;
+    std::shared_ptr<StorageLiveView> storage;
     std::shared_ptr<BlocksPtr> blocks_ptr;
     std::shared_ptr<BlocksMetadataPtr> blocks_metadata_ptr;
     std::weak_ptr<bool> active_ptr;
@@ -209,8 +210,6 @@ private:
     Blocks::iterator it;
     Blocks::iterator end;
     Blocks::iterator begin;
-    Poco::Condition & condition;
-    Poco::FastMutex & mutex;
     /// Length specifies number of updates to send, default -1 (no limit)
     int64_t length;
     bool end_of_blocks{0};
diff --git a/dbms/src/DataStreams/LiveViewEventsBlockInputStream.h b/dbms/src/DataStreams/LiveViewEventsBlockInputStream.h
index 215d5a17380..c7911074176 100644
--- a/dbms/src/DataStreams/LiveViewEventsBlockInputStream.h
+++ b/dbms/src/DataStreams/LiveViewEventsBlockInputStream.h
@@ -40,14 +40,14 @@ public:
     {
         /// Start storage no users thread
         /// if we are the last active user
-        if (!storage.is_dropped && blocks_ptr.use_count() < 3)
-            storage.startNoUsersThread(temporary_live_view_timeout);
+        if (!storage->is_dropped && blocks_ptr.use_count() < 3)
+            storage->startNoUsersThread(temporary_live_view_timeout);
     }
     /// length default -2 because we want LIMIT to specify number of updates so that LIMIT 1 waits for 1 update
     /// and LIMIT 0 just returns data without waiting for any updates
-    LiveViewEventsBlockInputStream(StorageLiveView & storage_, std::shared_ptr<BlocksPtr> blocks_ptr_, std::shared_ptr<BlocksMetadataPtr> blocks_metadata_ptr_, std::shared_ptr<bool> active_ptr_, Poco::Condition & condition_, Poco::FastMutex & mutex_,
+    LiveViewEventsBlockInputStream(std::shared_ptr<StorageLiveView> storage_, std::shared_ptr<BlocksPtr> blocks_ptr_, std::shared_ptr<BlocksMetadataPtr> blocks_metadata_ptr_, std::shared_ptr<bool> active_ptr_,
         int64_t length_, const UInt64 & heartbeat_interval_, const UInt64 & temporary_live_view_timeout_)
-        : storage(storage_), blocks_ptr(blocks_ptr_), blocks_metadata_ptr(blocks_metadata_ptr_), active_ptr(active_ptr_), condition(condition_), mutex(mutex_), length(length_ + 1), heartbeat_interval(heartbeat_interval_ * 1000000), temporary_live_view_timeout(temporary_live_view_timeout_)
+        : storage(storage_), blocks_ptr(blocks_ptr_), blocks_metadata_ptr(blocks_metadata_ptr_), active_ptr(active_ptr_), length(length_ + 1), heartbeat_interval(heartbeat_interval_ * 1000000), temporary_live_view_timeout(temporary_live_view_timeout_)
     {
         /// grab active pointer
         active = active_ptr.lock();
@@ -57,11 +57,11 @@ public:
 
     void cancel(bool kill) override
     {
-        if (isCancelled() || storage.is_dropped)
+        if (isCancelled() || storage->is_dropped)
             return;
         IBlockInputStream::cancel(kill);
-        Poco::FastMutex::ScopedLock lock(mutex);
-        condition.broadcast();
+        Poco::FastMutex::ScopedLock lock(storage->mutex);
+        storage->condition.broadcast();
     }
 
     Block getHeader() const override
@@ -136,7 +136,7 @@ protected:
         /// If blocks were never assigned get blocks
         if (!blocks)
         {
-            Poco::FastMutex::ScopedLock lock(mutex);
+            Poco::FastMutex::ScopedLock lock(storage->mutex);
             if (!active)
                 return { Block(), false };
             blocks = (*blocks_ptr);
@@ -146,7 +146,7 @@ protected:
             end = blocks->end();
         }
 
-        if (isCancelled() || storage.is_dropped)
+        if (isCancelled() || storage->is_dropped)
         {
             return { Block(), true };
         }
@@ -154,7 +154,7 @@ protected:
         if (it == end)
         {
             {
-                Poco::FastMutex::ScopedLock lock(mutex);
+                Poco::FastMutex::ScopedLock lock(storage->mutex);
                 if (!active)
                     return { Block(), false };
                 /// If we are done iterating over our blocks
@@ -182,9 +182,9 @@ protected:
                     while (true)
                     {
                         UInt64 timestamp_usec = static_cast<UInt64>(timestamp.epochMicroseconds());
-                        bool signaled = condition.tryWait(mutex, std::max(static_cast<UInt64>(0), heartbeat_interval - (timestamp_usec - last_event_timestamp)) / 1000);
+                        bool signaled = storage->condition.tryWait(storage->mutex, std::max(static_cast<UInt64>(0), heartbeat_interval - (timestamp_usec - last_event_timestamp)) / 1000);
 
-                        if (isCancelled() || storage.is_dropped)
+                        if (isCancelled() || storage->is_dropped)
                         {
                             return { Block(), true };
                         }
@@ -220,7 +220,7 @@ protected:
     }
 
 private:
-    StorageLiveView & storage;
+    std::shared_ptr<StorageLiveView> storage;
     std::shared_ptr<BlocksPtr> blocks_ptr;
     std::shared_ptr<BlocksMetadataPtr> blocks_metadata_ptr;
     std::weak_ptr<bool> active_ptr;
@@ -230,8 +230,6 @@ private:
     Blocks::iterator it;
     Blocks::iterator end;
     Blocks::iterator begin;
-    Poco::Condition & condition;
-    Poco::FastMutex & mutex;
     /// Length specifies number of updates to send, default -1 (no limit)
     int64_t length;
     bool end_of_blocks{0};
diff --git a/dbms/src/Storages/IStorage.h b/dbms/src/Storages/IStorage.h
index 4a63c1ef34a..9fcd8e5ddcf 100644
--- a/dbms/src/Storages/IStorage.h
+++ b/dbms/src/Storages/IStorage.h
@@ -298,7 +298,7 @@ public:
         return {};
     }
 
-    bool is_dropped{false};
+    std::atomic<bool> is_dropped{false};
 
     /// Does table support index for IN sections
     virtual bool supportsIndexForIn() const { return false; }
diff --git a/dbms/src/Storages/StorageLiveView.cpp b/dbms/src/Storages/StorageLiveView.cpp
index 28e6717611f..9a129141a1b 100644
--- a/dbms/src/Storages/StorageLiveView.cpp
+++ b/dbms/src/Storages/StorageLiveView.cpp
@@ -401,7 +401,7 @@ BlockInputStreams StorageLiveView::watch(
 
     if (query.is_watch_events)
     {
-        auto reader = std::make_shared<LiveViewEventsBlockInputStream>(*this, blocks_ptr, blocks_metadata_ptr, active_ptr, condition, mutex, length, context.getSettingsRef().live_view_heartbeat_interval.totalSeconds(),
+        auto reader = std::make_shared<LiveViewEventsBlockInputStream>(std::static_pointer_cast<StorageLiveView>(shared_from_this()), blocks_ptr, blocks_metadata_ptr, active_ptr, length, context.getSettingsRef().live_view_heartbeat_interval.totalSeconds(),
         context.getSettingsRef().temporary_live_view_timeout.totalSeconds());
 
         if (no_users_thread.joinable())
@@ -426,7 +426,7 @@ BlockInputStreams StorageLiveView::watch(
     }
     else
     {
-        auto reader = std::make_shared<LiveViewBlockInputStream>(*this, blocks_ptr, blocks_metadata_ptr, active_ptr, condition, mutex, length, context.getSettingsRef().live_view_heartbeat_interval.totalSeconds(),
+        auto reader = std::make_shared<LiveViewBlockInputStream>(std::static_pointer_cast<StorageLiveView>( shared_from_this()), blocks_ptr, blocks_metadata_ptr, active_ptr, length, context.getSettingsRef().live_view_heartbeat_interval.totalSeconds(),
         context.getSettingsRef().temporary_live_view_timeout.totalSeconds());
 
         if (no_users_thread.joinable())

From 576393272bc5d67983ca55bdd7f169598a7db654 Mon Sep 17 00:00:00 2001
From: Vitaliy Zakaznikov <vzakaznikov@protonmail.com>
Date: Wed, 12 Jun 2019 20:45:41 -0400
Subject: [PATCH 042/107] * Fixing styling check error

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

diff --git a/dbms/src/Storages/StorageLiveView.cpp b/dbms/src/Storages/StorageLiveView.cpp
index 9a129141a1b..77e95ac2e48 100644
--- a/dbms/src/Storages/StorageLiveView.cpp
+++ b/dbms/src/Storages/StorageLiveView.cpp
@@ -426,7 +426,7 @@ BlockInputStreams StorageLiveView::watch(
     }
     else
     {
-        auto reader = std::make_shared<LiveViewBlockInputStream>(std::static_pointer_cast<StorageLiveView>( shared_from_this()), blocks_ptr, blocks_metadata_ptr, active_ptr, length, context.getSettingsRef().live_view_heartbeat_interval.totalSeconds(),
+        auto reader = std::make_shared<LiveViewBlockInputStream>(std::static_pointer_cast<StorageLiveView>(shared_from_this()), blocks_ptr, blocks_metadata_ptr, active_ptr, length, context.getSettingsRef().live_view_heartbeat_interval.totalSeconds(),
         context.getSettingsRef().temporary_live_view_timeout.totalSeconds());
 
         if (no_users_thread.joinable())

From 825c21f29a38e33debe9c931e6435cef84dba2c3 Mon Sep 17 00:00:00 2001
From: Vitaliy Zakaznikov <vzakaznikov@protonmail.com>
Date: Thu, 13 Jun 2019 06:36:59 -0400
Subject: [PATCH 043/107] * Increasing timeout from 2 to 20 sec. * Style fix

---
 .../queries/0_stateless/00962_temporary_live_view_watch_live.py | 2 +-
 dbms/tests/queries/0_stateless/helpers/client.py                | 2 +-
 dbms/tests/queries/0_stateless/helpers/httpclient.py            | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/dbms/tests/queries/0_stateless/00962_temporary_live_view_watch_live.py b/dbms/tests/queries/0_stateless/00962_temporary_live_view_watch_live.py
index 48311d890c5..1967284c38b 100755
--- a/dbms/tests/queries/0_stateless/00962_temporary_live_view_watch_live.py
+++ b/dbms/tests/queries/0_stateless/00962_temporary_live_view_watch_live.py
@@ -18,7 +18,7 @@ with client(name='client1>', log=log) as client1, client(name='client2>', log=lo
 
     client1.send('DROP TABLE IF EXISTS test.lv')
     client1.expect(prompt)
-    client1.send(' DROP TABLE IF EXISTS test.mt')
+    client1.send('DROP TABLE IF EXISTS test.mt')
     client1.expect(prompt)
     client1.send('CREATE TABLE test.mt (a Int32) Engine=MergeTree order by tuple()')
     client1.expect(prompt)
diff --git a/dbms/tests/queries/0_stateless/helpers/client.py b/dbms/tests/queries/0_stateless/helpers/client.py
index b509a321cee..59ea3d898ea 100644
--- a/dbms/tests/queries/0_stateless/helpers/client.py
+++ b/dbms/tests/queries/0_stateless/helpers/client.py
@@ -17,5 +17,5 @@ def client(command=None, name='', log=None):
         client = uexpect.spawn(command)
     client.eol('\r')
     client.logger(log, prefix=name)
-    client.timeout(2)
+    client.timeout(20)
     return client
diff --git a/dbms/tests/queries/0_stateless/helpers/httpclient.py b/dbms/tests/queries/0_stateless/helpers/httpclient.py
index 111841ba708..a42fad2cbc3 100644
--- a/dbms/tests/queries/0_stateless/helpers/httpclient.py
+++ b/dbms/tests/queries/0_stateless/helpers/httpclient.py
@@ -10,5 +10,5 @@ import httpexpect
 def client(request, name='', log=None):
     client = httpexpect.spawn({'host':'localhost','port':8123}, request)
     client.logger(log, prefix=name)
-    client.timeout(2)
+    client.timeout(20)
     return client

From b82bb4a954391398fab7e60b86e536a5d215c350 Mon Sep 17 00:00:00 2001
From: Vitaliy Zakaznikov <vzakaznikov@protonmail.com>
Date: Thu, 13 Jun 2019 12:37:29 -0400
Subject: [PATCH 044/107] * Updates to sync with yandex/master

---
 contrib/googletest                            |    1 +
 .../boost/archive/archive_exception.hpp       |  100 -
 .../boost/archive/basic_archive.hpp           |  304 ---
 .../boost/archive/basic_binary_iarchive.hpp   |  204 --
 .../boost/archive/basic_binary_iprimitive.hpp |  198 --
 .../boost/archive/basic_binary_oarchive.hpp   |  185 --
 .../boost/archive/basic_binary_oprimitive.hpp |  188 --
 .../archive/basic_streambuf_locale_saver.hpp  |  108 --
 .../boost/archive/basic_text_iarchive.hpp     |   96 -
 .../boost/archive/basic_text_iprimitive.hpp   |  142 --
 .../boost/archive/basic_text_oarchive.hpp     |  119 --
 .../boost/archive/basic_text_oprimitive.hpp   |  209 --
 .../boost/archive/basic_xml_archive.hpp       |   67 -
 .../boost/archive/basic_xml_iarchive.hpp      |  119 --
 .../boost/archive/basic_xml_oarchive.hpp      |  138 --
 .../boost/archive/binary_iarchive.hpp         |   64 -
 .../boost/archive/binary_iarchive_impl.hpp    |  105 -
 .../boost/archive/binary_oarchive.hpp         |   64 -
 .../boost/archive/binary_oarchive_impl.hpp    |  106 -
 .../boost/archive/binary_wiarchive.hpp        |   56 -
 .../boost/archive/binary_woarchive.hpp        |   59 -
 .../boost/archive/codecvt_null.hpp            |  109 --
 .../boost/archive/detail/abi_prefix.hpp       |   16 -
 .../boost/archive/detail/abi_suffix.hpp       |   15 -
 .../archive/detail/archive_serializer_map.hpp |   54 -
 .../archive/detail/auto_link_archive.hpp      |   48 -
 .../archive/detail/auto_link_warchive.hpp     |   47 -
 .../boost/archive/detail/basic_iarchive.hpp   |  105 -
 .../archive/detail/basic_iserializer.hpp      |   91 -
 .../boost/archive/detail/basic_oarchive.hpp   |   94 -
 .../archive/detail/basic_oserializer.hpp      |   89 -
 .../detail/basic_pointer_iserializer.hpp      |   70 -
 .../detail/basic_pointer_oserializer.hpp      |   68 -
 .../boost/archive/detail/basic_serializer.hpp |   77 -
 .../archive/detail/basic_serializer_map.hpp   |   69 -
 .../boost/archive/detail/check.hpp            |  169 --
 .../boost/archive/detail/common_iarchive.hpp  |   88 -
 .../boost/archive/detail/common_oarchive.hpp  |   88 -
 .../boost/archive/detail/decl.hpp             |   57 -
 .../archive/detail/helper_collection.hpp      |   99 -
 .../archive/detail/interface_iarchive.hpp     |   85 -
 .../archive/detail/interface_oarchive.hpp     |   87 -
 .../boost/archive/detail/iserializer.hpp      |  631 ------
 .../boost/archive/detail/oserializer.hpp      |  540 ------
 .../detail/polymorphic_iarchive_route.hpp     |  218 ---
 .../detail/polymorphic_oarchive_route.hpp     |  209 --
 .../boost/archive/detail/register_archive.hpp |   91 -
 .../archive/detail/utf8_codecvt_facet.hpp     |   39 -
 .../boost_1_65_0/boost/archive/dinkumware.hpp |  224 ---
 .../archive/impl/archive_serializer_map.ipp   |   75 -
 .../archive/impl/basic_binary_iarchive.ipp    |  134 --
 .../archive/impl/basic_binary_iprimitive.ipp  |  171 --
 .../archive/impl/basic_binary_oarchive.ipp    |   42 -
 .../archive/impl/basic_binary_oprimitive.ipp  |  126 --
 .../archive/impl/basic_text_iarchive.ipp      |   76 -
 .../archive/impl/basic_text_iprimitive.ipp    |  137 --
 .../archive/impl/basic_text_oarchive.ipp      |   62 -
 .../archive/impl/basic_text_oprimitive.ipp    |  115 --
 .../boost/archive/impl/basic_xml_grammar.hpp  |  173 --
 .../boost/archive/impl/basic_xml_iarchive.ipp |  115 --
 .../boost/archive/impl/basic_xml_oarchive.ipp |  272 ---
 .../boost/archive/impl/text_iarchive_impl.ipp |  128 --
 .../boost/archive/impl/text_oarchive_impl.ipp |  122 --
 .../archive/impl/text_wiarchive_impl.ipp      |  118 --
 .../archive/impl/text_woarchive_impl.ipp      |   85 -
 .../boost/archive/impl/xml_iarchive_impl.ipp  |  199 --
 .../boost/archive/impl/xml_oarchive_impl.ipp  |  142 --
 .../boost/archive/impl/xml_wiarchive_impl.ipp |  189 --
 .../boost/archive/impl/xml_woarchive_impl.ipp |  171 --
 .../archive/iterators/base64_exception.hpp    |   68 -
 .../archive/iterators/base64_from_binary.hpp  |  109 --
 .../archive/iterators/binary_from_base64.hpp  |  118 --
 .../boost/archive/iterators/dataflow.hpp      |  102 -
 .../archive/iterators/dataflow_exception.hpp  |   80 -
 .../boost/archive/iterators/escape.hpp        |  115 --
 .../archive/iterators/insert_linebreaks.hpp   |   99 -
 .../archive/iterators/istream_iterator.hpp    |   92 -
 .../boost/archive/iterators/mb_from_wchar.hpp |  139 --
 .../archive/iterators/ostream_iterator.hpp    |   83 -
 .../archive/iterators/remove_whitespace.hpp   |  167 --
 .../archive/iterators/transform_width.hpp     |  177 --
 .../boost/archive/iterators/unescape.hpp      |   89 -
 .../boost/archive/iterators/wchar_from_mb.hpp |  194 --
 .../boost/archive/iterators/xml_escape.hpp    |  121 --
 .../boost/archive/iterators/xml_unescape.hpp  |  125 --
 .../iterators/xml_unescape_exception.hpp      |   49 -
 .../archive/polymorphic_binary_iarchive.hpp   |   54 -
 .../archive/polymorphic_binary_oarchive.hpp   |   43 -
 .../boost/archive/polymorphic_iarchive.hpp    |  168 --
 .../boost/archive/polymorphic_oarchive.hpp    |  154 --
 .../archive/polymorphic_text_iarchive.hpp     |   54 -
 .../archive/polymorphic_text_oarchive.hpp     |   39 -
 .../archive/polymorphic_text_wiarchive.hpp    |   59 -
 .../archive/polymorphic_text_woarchive.hpp    |   44 -
 .../archive/polymorphic_xml_iarchive.hpp      |   54 -
 .../archive/polymorphic_xml_oarchive.hpp      |   39 -
 .../archive/polymorphic_xml_wiarchive.hpp     |   50 -
 .../archive/polymorphic_xml_woarchive.hpp     |   44 -
 .../boost/archive/text_iarchive.hpp           |  132 --
 .../boost/archive/text_oarchive.hpp           |  121 --
 .../boost/archive/text_wiarchive.hpp          |  137 --
 .../boost/archive/text_woarchive.hpp          |  155 --
 .../boost_1_65_0/boost/archive/tmpdir.hpp     |   50 -
 .../boost_1_65_0/boost/archive/wcslen.hpp     |   58 -
 .../boost/archive/xml_archive_exception.hpp   |   57 -
 .../boost/archive/xml_iarchive.hpp            |  142 --
 .../boost/archive/xml_oarchive.hpp            |  137 --
 .../boost/archive/xml_wiarchive.hpp           |  149 --
 .../boost/archive/xml_woarchive.hpp           |  134 --
 .../boost_1_65_0/boost/foreach_fwd.hpp        |   51 -
 .../boost/multi_index/composite_key.hpp       | 1513 ---------------
 .../multi_index/detail/access_specifier.hpp   |   54 -
 .../boost/multi_index/detail/adl_swap.hpp     |   44 -
 .../detail/archive_constructed.hpp            |   83 -
 .../boost/multi_index/detail/auto_space.hpp   |   91 -
 .../boost/multi_index/detail/base_type.hpp    |   74 -
 .../detail/bidir_node_iterator.hpp            |  114 --
 .../boost/multi_index/detail/bucket_array.hpp |  243 ---
 .../multi_index/detail/cons_stdtuple.hpp      |   93 -
 .../boost/multi_index/detail/converter.hpp    |   52 -
 .../boost/multi_index/detail/copy_map.hpp     |  142 --
 .../detail/do_not_copy_elements_tag.hpp       |   34 -
 .../detail/duplicates_iterator.hpp            |  120 --
 .../boost/multi_index/detail/has_tag.hpp      |   42 -
 .../multi_index/detail/hash_index_args.hpp    |  105 -
 .../detail/hash_index_iterator.hpp            |  166 --
 .../multi_index/detail/hash_index_node.hpp    |  778 --------
 .../multi_index/detail/header_holder.hpp      |   50 -
 .../detail/ignore_wstrict_aliasing.hpp        |   18 -
 .../boost/multi_index/detail/index_base.hpp   |  293 ---
 .../boost/multi_index/detail/index_loader.hpp |  139 --
 .../multi_index/detail/index_matcher.hpp      |  249 ---
 .../multi_index/detail/index_node_base.hpp    |  135 --
 .../boost/multi_index/detail/index_saver.hpp  |  135 --
 .../multi_index/detail/invariant_assert.hpp   |   21 -
 .../multi_index/detail/is_index_list.hpp      |   40 -
 .../multi_index/detail/is_transparent.hpp     |  135 --
 .../boost/multi_index/detail/iter_adaptor.hpp |  321 ---
 .../multi_index/detail/modify_key_adaptor.hpp |   49 -
 .../multi_index/detail/no_duplicate_tags.hpp  |   97 -
 .../boost/multi_index/detail/node_type.hpp    |   66 -
 .../multi_index/detail/ord_index_args.hpp     |   83 -
 .../multi_index/detail/ord_index_impl.hpp     | 1567 ---------------
 .../multi_index/detail/ord_index_impl_fwd.hpp |  128 --
 .../multi_index/detail/ord_index_node.hpp     |  658 -------
 .../multi_index/detail/ord_index_ops.hpp      |  266 ---
 .../boost/multi_index/detail/promotes_arg.hpp |   83 -
 .../boost/multi_index/detail/raw_ptr.hpp      |   52 -
 .../detail/restore_wstrict_aliasing.hpp       |   11 -
 .../multi_index/detail/rnd_index_loader.hpp   |  173 --
 .../multi_index/detail/rnd_index_node.hpp     |  273 ---
 .../multi_index/detail/rnd_index_ops.hpp      |  203 --
 .../detail/rnd_index_ptr_array.hpp            |  144 --
 .../multi_index/detail/rnd_node_iterator.hpp  |  140 --
 .../multi_index/detail/rnk_index_ops.hpp      |  300 ---
 .../boost/multi_index/detail/safe_mode.hpp    |  588 ------
 .../boost/multi_index/detail/scope_guard.hpp  |  453 -----
 .../multi_index/detail/seq_index_node.hpp     |  217 ---
 .../multi_index/detail/seq_index_ops.hpp      |  203 --
 .../detail/serialization_version.hpp          |   73 -
 .../boost/multi_index/detail/uintptr_type.hpp |   76 -
 .../boost/multi_index/detail/unbounded.hpp    |   66 -
 .../multi_index/detail/value_compare.hpp      |   56 -
 .../multi_index/detail/vartempl_support.hpp   |  247 ---
 .../boost/multi_index/global_fun.hpp          |  185 --
 .../boost/multi_index/hashed_index.hpp        | 1725 -----------------
 .../boost/multi_index/hashed_index_fwd.hpp    |   74 -
 .../boost/multi_index/identity.hpp            |  145 --
 .../boost/multi_index/identity_fwd.hpp        |   26 -
 .../boost/multi_index/indexed_by.hpp          |   68 -
 .../boost/multi_index/key_extractors.hpp      |   22 -
 .../boost/multi_index/mem_fun.hpp             |  205 --
 .../boost_1_65_0/boost/multi_index/member.hpp |  262 ---
 .../boost/multi_index/ordered_index.hpp       |  114 --
 .../boost/multi_index/ordered_index_fwd.hpp   |   35 -
 .../boost/multi_index/random_access_index.hpp | 1167 -----------
 .../multi_index/random_access_index_fwd.hpp   |   91 -
 .../boost/multi_index/ranked_index.hpp        |  382 ----
 .../boost/multi_index/ranked_index_fwd.hpp    |   35 -
 .../boost/multi_index/safe_mode_errors.hpp    |   48 -
 .../boost/multi_index/sequenced_index.hpp     | 1062 ----------
 .../boost/multi_index/sequenced_index_fwd.hpp |   91 -
 .../boost_1_65_0/boost/multi_index/tag.hpp    |   88 -
 .../boost/multi_index_container.hpp           | 1362 -------------
 .../boost/multi_index_container_fwd.hpp       |  121 --
 .../boost/serialization/access.hpp            |  145 --
 .../archive_input_unordered_map.hpp           |   85 -
 .../archive_input_unordered_set.hpp           |   72 -
 .../boost/serialization/array.hpp             |   48 -
 .../serialization/array_optimization.hpp      |   37 -
 .../boost/serialization/array_wrapper.hpp     |  121 --
 .../boost/serialization/assume_abstract.hpp   |   60 -
 .../boost/serialization/base_object.hpp       |  100 -
 .../boost/serialization/binary_object.hpp     |   79 -
 .../boost/serialization/bitset.hpp            |   75 -
 .../boost/serialization/boost_array.hpp       |   33 -
 .../serialization/boost_unordered_map.hpp     |  154 --
 .../serialization/boost_unordered_set.hpp     |  150 --
 .../serialization/collection_size_type.hpp    |   62 -
 .../boost/serialization/collection_traits.hpp |   79 -
 .../serialization/collections_load_imp.hpp    |  106 -
 .../serialization/collections_save_imp.hpp    |   82 -
 .../boost/serialization/complex.hpp           |   81 -
 .../boost/serialization/config.hpp            |   74 -
 .../boost/serialization/deque.hpp             |   80 -
 .../detail/is_default_constructible.hpp       |   54 -
 .../serialization/detail/shared_count_132.hpp |  551 ------
 .../serialization/detail/shared_ptr_132.hpp   |  443 -----
 .../detail/shared_ptr_nmt_132.hpp             |  182 --
 .../detail/stack_constructor.hpp              |   66 -
 .../boost/serialization/ephemeral.hpp         |   72 -
 .../boost/serialization/export.hpp            |  225 ---
 .../serialization/extended_type_info.hpp      |  116 --
 .../extended_type_info_no_rtti.hpp            |  182 --
 .../extended_type_info_typeid.hpp             |  167 --
 .../boost/serialization/factory.hpp           |  102 -
 .../boost/serialization/force_include.hpp     |   55 -
 .../boost/serialization/forward_list.hpp      |  124 --
 .../hash_collections_load_imp.hpp             |   77 -
 .../hash_collections_save_imp.hpp             |   97 -
 .../boost/serialization/hash_map.hpp          |  232 ---
 .../boost/serialization/hash_set.hpp          |  222 ---
 .../serialization/is_bitwise_serializable.hpp |   46 -
 .../boost/serialization/item_version_type.hpp |   68 -
 .../boost/serialization/level.hpp             |  116 --
 .../boost/serialization/level_enum.hpp        |   55 -
 .../boost_1_65_0/boost/serialization/list.hpp |   85 -
 .../boost_1_65_0/boost/serialization/map.hpp  |  139 --
 .../boost_1_65_0/boost/serialization/nvp.hpp  |  123 --
 .../boost/serialization/optional.hpp          |  107 -
 .../boost/serialization/priority_queue.hpp    |   76 -
 .../boost/serialization/queue.hpp             |   76 -
 .../boost/serialization/scoped_ptr.hpp        |   58 -
 .../boost/serialization/serialization.hpp     |  154 --
 .../boost_1_65_0/boost/serialization/set.hpp  |  137 --
 .../boost/serialization/shared_ptr.hpp        |  281 ---
 .../boost/serialization/shared_ptr_132.hpp    |  222 ---
 .../boost/serialization/shared_ptr_helper.hpp |  209 --
 .../boost/serialization/singleton.hpp         |  166 --
 .../boost/serialization/slist.hpp             |  145 --
 .../boost/serialization/smart_cast.hpp        |  275 ---
 .../boost/serialization/split_free.hpp        |   93 -
 .../boost/serialization/split_member.hpp      |   86 -
 .../boost/serialization/stack.hpp             |   76 -
 .../boost/serialization/state_saver.hpp       |   96 -
 .../boost/serialization/static_warning.hpp    |  103 -
 .../boost/serialization/string.hpp            |   30 -
 .../boost/serialization/strong_typedef.hpp    |   50 -
 .../boost/serialization/throw_exception.hpp   |   44 -
 .../boost/serialization/tracking.hpp          |  118 --
 .../boost/serialization/tracking_enum.hpp     |   41 -
 .../boost/serialization/traits.hpp            |   65 -
 .../type_info_implementation.hpp              |   73 -
 .../boost/serialization/unique_ptr.hpp        |   68 -
 .../unordered_collections_load_imp.hpp        |   73 -
 .../unordered_collections_save_imp.hpp        |   86 -
 .../boost/serialization/unordered_map.hpp     |  160 --
 .../boost/serialization/unordered_set.hpp     |  162 --
 .../boost/serialization/utility.hpp           |   56 -
 .../boost/serialization/valarray.hpp          |   86 -
 .../boost/serialization/variant.hpp           |  158 --
 .../boost/serialization/vector.hpp            |  233 ---
 .../boost/serialization/vector_135.hpp        |   26 -
 .../boost/serialization/version.hpp           |  107 -
 .../boost/serialization/void_cast.hpp         |  298 ---
 .../boost/serialization/void_cast_fwd.hpp     |   37 -
 .../boost/serialization/weak_ptr.hpp          |   99 -
 .../boost/serialization/wrapper.hpp           |   60 -
 contrib/poco                                  |    1 +
 contrib/zlib-ng                               |    1 +
 dbms/src/Storages/MergeTree/MergeTreeData.cpp |    3 -
 271 files changed, 3 insertions(+), 41591 deletions(-)
 create mode 160000 contrib/googletest
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/archive_exception.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/basic_archive.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/basic_binary_iarchive.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/basic_binary_iprimitive.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/basic_binary_oarchive.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/basic_binary_oprimitive.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/basic_streambuf_locale_saver.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/basic_text_iarchive.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/basic_text_iprimitive.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/basic_text_oarchive.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/basic_text_oprimitive.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/basic_xml_archive.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/basic_xml_iarchive.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/basic_xml_oarchive.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/binary_iarchive.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/binary_iarchive_impl.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/binary_oarchive.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/binary_oarchive_impl.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/binary_wiarchive.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/binary_woarchive.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/codecvt_null.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/detail/abi_prefix.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/detail/abi_suffix.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/detail/archive_serializer_map.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/detail/auto_link_archive.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/detail/auto_link_warchive.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/detail/basic_iarchive.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/detail/basic_iserializer.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/detail/basic_oarchive.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/detail/basic_oserializer.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/detail/basic_pointer_iserializer.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/detail/basic_pointer_oserializer.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/detail/basic_serializer.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/detail/basic_serializer_map.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/detail/check.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/detail/common_iarchive.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/detail/common_oarchive.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/detail/decl.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/detail/helper_collection.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/detail/interface_iarchive.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/detail/interface_oarchive.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/detail/iserializer.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/detail/oserializer.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/detail/polymorphic_iarchive_route.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/detail/polymorphic_oarchive_route.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/detail/register_archive.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/detail/utf8_codecvt_facet.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/dinkumware.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/impl/archive_serializer_map.ipp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/impl/basic_binary_iarchive.ipp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/impl/basic_binary_iprimitive.ipp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/impl/basic_binary_oarchive.ipp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/impl/basic_binary_oprimitive.ipp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/impl/basic_text_iarchive.ipp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/impl/basic_text_iprimitive.ipp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/impl/basic_text_oarchive.ipp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/impl/basic_text_oprimitive.ipp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/impl/basic_xml_grammar.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/impl/basic_xml_iarchive.ipp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/impl/basic_xml_oarchive.ipp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/impl/text_iarchive_impl.ipp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/impl/text_oarchive_impl.ipp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/impl/text_wiarchive_impl.ipp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/impl/text_woarchive_impl.ipp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/impl/xml_iarchive_impl.ipp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/impl/xml_oarchive_impl.ipp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/impl/xml_wiarchive_impl.ipp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/impl/xml_woarchive_impl.ipp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/iterators/base64_exception.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/iterators/base64_from_binary.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/iterators/binary_from_base64.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/iterators/dataflow.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/iterators/dataflow_exception.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/iterators/escape.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/iterators/insert_linebreaks.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/iterators/istream_iterator.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/iterators/mb_from_wchar.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/iterators/ostream_iterator.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/iterators/remove_whitespace.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/iterators/transform_width.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/iterators/unescape.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/iterators/wchar_from_mb.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/iterators/xml_escape.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/iterators/xml_unescape.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/iterators/xml_unescape_exception.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/polymorphic_binary_iarchive.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/polymorphic_binary_oarchive.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/polymorphic_iarchive.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/polymorphic_oarchive.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/polymorphic_text_iarchive.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/polymorphic_text_oarchive.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/polymorphic_text_wiarchive.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/polymorphic_text_woarchive.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/polymorphic_xml_iarchive.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/polymorphic_xml_oarchive.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/polymorphic_xml_wiarchive.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/polymorphic_xml_woarchive.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/text_iarchive.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/text_oarchive.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/text_wiarchive.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/text_woarchive.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/tmpdir.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/wcslen.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/xml_archive_exception.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/xml_iarchive.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/xml_oarchive.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/xml_wiarchive.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/archive/xml_woarchive.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/foreach_fwd.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/composite_key.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/access_specifier.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/adl_swap.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/archive_constructed.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/auto_space.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/base_type.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/bidir_node_iterator.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/bucket_array.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/cons_stdtuple.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/converter.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/copy_map.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/do_not_copy_elements_tag.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/duplicates_iterator.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/has_tag.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/hash_index_args.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/hash_index_iterator.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/hash_index_node.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/header_holder.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/ignore_wstrict_aliasing.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/index_base.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/index_loader.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/index_matcher.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/index_node_base.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/index_saver.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/invariant_assert.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/is_index_list.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/is_transparent.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/iter_adaptor.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/modify_key_adaptor.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/no_duplicate_tags.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/node_type.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/ord_index_args.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/ord_index_impl.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/ord_index_impl_fwd.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/ord_index_node.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/ord_index_ops.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/promotes_arg.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/raw_ptr.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/restore_wstrict_aliasing.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/rnd_index_loader.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/rnd_index_node.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/rnd_index_ops.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/rnd_index_ptr_array.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/rnd_node_iterator.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/rnk_index_ops.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/safe_mode.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/scope_guard.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/seq_index_node.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/seq_index_ops.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/serialization_version.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/uintptr_type.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/unbounded.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/value_compare.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/detail/vartempl_support.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/global_fun.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/hashed_index.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/hashed_index_fwd.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/identity.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/identity_fwd.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/indexed_by.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/key_extractors.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/mem_fun.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/member.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/ordered_index.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/ordered_index_fwd.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/random_access_index.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/random_access_index_fwd.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/ranked_index.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/ranked_index_fwd.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/safe_mode_errors.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/sequenced_index.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/sequenced_index_fwd.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index/tag.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index_container.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/multi_index_container_fwd.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/access.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/archive_input_unordered_map.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/archive_input_unordered_set.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/array.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/array_optimization.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/array_wrapper.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/assume_abstract.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/base_object.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/binary_object.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/bitset.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/boost_array.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/boost_unordered_map.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/boost_unordered_set.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/collection_size_type.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/collection_traits.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/collections_load_imp.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/collections_save_imp.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/complex.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/config.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/deque.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/detail/is_default_constructible.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/detail/shared_count_132.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/detail/shared_ptr_132.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/detail/shared_ptr_nmt_132.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/detail/stack_constructor.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/ephemeral.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/export.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/extended_type_info.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/extended_type_info_no_rtti.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/extended_type_info_typeid.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/factory.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/force_include.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/forward_list.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/hash_collections_load_imp.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/hash_collections_save_imp.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/hash_map.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/hash_set.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/is_bitwise_serializable.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/item_version_type.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/level.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/level_enum.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/list.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/map.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/nvp.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/optional.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/priority_queue.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/queue.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/scoped_ptr.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/serialization.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/set.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/shared_ptr.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/shared_ptr_132.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/shared_ptr_helper.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/singleton.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/slist.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/smart_cast.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/split_free.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/split_member.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/stack.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/state_saver.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/static_warning.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/string.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/strong_typedef.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/throw_exception.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/tracking.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/tracking_enum.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/traits.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/type_info_implementation.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/unique_ptr.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/unordered_collections_load_imp.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/unordered_collections_save_imp.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/unordered_map.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/unordered_set.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/utility.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/valarray.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/variant.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/vector.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/vector_135.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/version.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/void_cast.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/void_cast_fwd.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/weak_ptr.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/serialization/wrapper.hpp
 create mode 160000 contrib/poco
 create mode 160000 contrib/zlib-ng

diff --git a/contrib/googletest b/contrib/googletest
new file mode 160000
index 00000000000..d175c8bf823
--- /dev/null
+++ b/contrib/googletest
@@ -0,0 +1 @@
+Subproject commit d175c8bf823e709d570772b038757fadf63bc632
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/archive_exception.hpp b/contrib/libboost/boost_1_65_0/boost/archive/archive_exception.hpp
deleted file mode 100644
index fabcdb5fa71..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/archive_exception.hpp
+++ /dev/null
@@ -1,100 +0,0 @@
-#ifndef BOOST_ARCHIVE_ARCHIVE_EXCEPTION_HPP
-#define BOOST_ARCHIVE_ARCHIVE_EXCEPTION_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// archive/archive_exception.hpp:
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <exception>
-#include <boost/assert.hpp>
-#include <string>
-
-#include <boost/config.hpp> 
-#include <boost/archive/detail/decl.hpp>
-
-// note: the only reason this is in here is that windows header
-// includes #define exception_code _exception_code (arrrgghhhh!).
-// the most expedient way to address this is be sure that this
-// header is always included whenever this header file is included.
-#if defined(BOOST_WINDOWS) 
-#include <excpt.h> 
-#endif 
-
-#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
-
-namespace boost {
-namespace archive {
-
-//////////////////////////////////////////////////////////////////////
-// exceptions thrown by archives
-//
-class BOOST_SYMBOL_VISIBLE archive_exception : 
-    public virtual std::exception
-{
-private:
-    char m_buffer[128];
-protected:
-    BOOST_ARCHIVE_DECL unsigned int
-    append(unsigned int l, const char * a);
-    BOOST_ARCHIVE_DECL
-    archive_exception() BOOST_NOEXCEPT;
-public:
-    typedef enum {
-        no_exception,       // initialized without code
-        other_exception,    // any excepton not listed below
-        unregistered_class, // attempt to serialize a pointer of
-                            // an unregistered class
-        invalid_signature,  // first line of archive does not contain
-                            // expected string
-        unsupported_version,// archive created with library version
-                            // subsequent to this one
-        pointer_conflict,   // an attempt has been made to directly
-                            // serialize an object which has
-                            // already been serialized through a pointer.  
-                            // Were this permitted, the archive load would result 
-                            // in the creation of an extra copy of the obect.
-        incompatible_native_format, // attempt to read native binary format
-                            // on incompatible platform
-        array_size_too_short,// array being loaded doesn't fit in array allocated
-        input_stream_error, // error on input stream
-        invalid_class_name, // class name greater than the maximum permitted.
-                            // most likely a corrupted archive or an attempt
-                            // to insert virus via buffer overrun method.
-        unregistered_cast,   // base - derived relationship not registered with 
-                            // void_cast_register
-        unsupported_class_version, // type saved with a version # greater than the 
-                            // one used by the program.  This indicates that the program
-                            // needs to be rebuilt.
-        multiple_code_instantiation, // code for implementing serialization for some
-                            // type has been instantiated in more than one module.
-        output_stream_error // error on input stream
-    } exception_code;
-    exception_code code;
-
-    BOOST_ARCHIVE_DECL archive_exception(
-        exception_code c, 
-        const char * e1 = NULL,
-        const char * e2 = NULL
-    ) BOOST_NOEXCEPT;
-    BOOST_ARCHIVE_DECL archive_exception(archive_exception const &) BOOST_NOEXCEPT ;
-    virtual BOOST_ARCHIVE_DECL ~archive_exception() BOOST_NOEXCEPT_OR_NOTHROW ;
-    virtual BOOST_ARCHIVE_DECL const char * what() const BOOST_NOEXCEPT_OR_NOTHROW ;
-};
-
-}// namespace archive
-}// namespace boost
-
-#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
-
-#endif //BOOST_ARCHIVE_ARCHIVE_EXCEPTION_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/basic_archive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/basic_archive.hpp
deleted file mode 100644
index ce7ac99a6dd..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/basic_archive.hpp
+++ /dev/null
@@ -1,304 +0,0 @@
-#ifndef BOOST_ARCHIVE_BASIC_ARCHIVE_HPP
-#define BOOST_ARCHIVE_BASIC_ARCHIVE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// basic_archive.hpp:
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-#include <cstring> // count
-#include <boost/assert.hpp>
-#include <boost/config.hpp>
-#include <boost/cstdint.hpp> // size_t
-#include <boost/noncopyable.hpp>
-#include <boost/integer_traits.hpp>
-
-#include <boost/archive/detail/auto_link_archive.hpp>
-#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
-
-namespace boost {
-namespace archive {
-
-#if defined(_MSC_VER)
-#pragma warning( push )
-#pragma warning( disable : 4244 4267 )
-#endif
-
-/* NOTE : Warning  : Warning : Warning : Warning : Warning
- * Don't ever changes this.  If you do, they previously created
- * binary archives won't be readable !!!
- */
-class library_version_type {
-private:
-    typedef uint_least16_t base_type;
-    base_type t;
-public:
-    library_version_type(): t(0) {};
-    explicit library_version_type(const unsigned int & t_) : t(t_){
-        BOOST_ASSERT(t_ <= boost::integer_traits<base_type>::const_max);
-    }
-    library_version_type(const library_version_type & t_) : 
-        t(t_.t)
-    {}
-    library_version_type & operator=(const library_version_type & rhs){
-        t = rhs.t; 
-        return *this;
-    }
-    // used for text output
-    operator base_type () const {
-        return t;
-    }                
-    // used for text input
-    operator base_type & (){
-        return t;
-    }                
-    bool operator==(const library_version_type & rhs) const {
-        return t == rhs.t;
-    } 
-    bool operator<(const library_version_type & rhs) const {
-        return t < rhs.t;
-    }   
-};
-
-BOOST_ARCHIVE_DECL library_version_type
-BOOST_ARCHIVE_VERSION();
-
-class version_type {
-private:
-    typedef uint_least32_t base_type;
-    base_type t;
-public:
-    // should be private - but MPI fails if it's not!!!
-    version_type(): t(0) {};
-    explicit version_type(const unsigned int & t_) : t(t_){
-        BOOST_ASSERT(t_ <= boost::integer_traits<base_type>::const_max);
-    }
-    version_type(const version_type & t_) : 
-        t(t_.t)
-    {}
-    version_type & operator=(const version_type & rhs){
-        t = rhs.t; 
-        return *this;
-    }
-    // used for text output
-    operator base_type () const {
-        return t;
-    }                
-    // used for text intput
-    operator base_type  & (){
-        return t;
-    }                
-    bool operator==(const version_type & rhs) const {
-        return t == rhs.t;
-    } 
-    bool operator<(const version_type & rhs) const {
-        return t < rhs.t;
-    }   
-};
-
-class class_id_type {
-private:
-    typedef int_least16_t base_type;
-    base_type t;
-public:
-    // should be private - but then can't use BOOST_STRONG_TYPE below
-    class_id_type() : t(0) {};
-    explicit class_id_type(const int t_) : t(t_){
-        BOOST_ASSERT(t_ <= boost::integer_traits<base_type>::const_max);
-    }
-    explicit class_id_type(const std::size_t t_) : t(t_){
- //       BOOST_ASSERT(t_ <= boost::integer_traits<base_type>::const_max);
-    }
-    class_id_type(const class_id_type & t_) : 
-        t(t_.t)
-    {}
-    class_id_type & operator=(const class_id_type & rhs){
-        t = rhs.t; 
-        return *this;
-    }
-
-    // used for text output
-    operator int () const {
-        return t;
-    }                
-    // used for text input
-    operator int_least16_t &() {
-        return t;
-    }                
-    bool operator==(const class_id_type & rhs) const {
-        return t == rhs.t;
-    } 
-    bool operator<(const class_id_type & rhs) const {
-        return t < rhs.t;
-    }   
-};
-
-#define NULL_POINTER_TAG boost::archive::class_id_type(-1)
-
-class object_id_type {
-private:
-    typedef uint_least32_t base_type;
-    base_type t;
-public:
-    object_id_type(): t(0) {};
-    // note: presumes that size_t >= unsigned int.
-    explicit object_id_type(const std::size_t & t_) : t(t_){
-        BOOST_ASSERT(t_ <= boost::integer_traits<base_type>::const_max);
-    }
-    object_id_type(const object_id_type & t_) : 
-        t(t_.t)
-    {}
-    object_id_type & operator=(const object_id_type & rhs){
-        t = rhs.t; 
-        return *this;
-    }
-    // used for text output
-    operator uint_least32_t () const {
-        return t;
-    }                
-    // used for text input
-    operator uint_least32_t & () {
-        return t;
-    }                
-    bool operator==(const object_id_type & rhs) const {
-        return t == rhs.t;
-    } 
-    bool operator<(const object_id_type & rhs) const {
-        return t < rhs.t;
-    }   
-};
-
-#if defined(_MSC_VER)
-#pragma warning( pop )
-#endif
-
-struct tracking_type {
-    bool t;
-    explicit tracking_type(const bool t_ = false)
-        : t(t_)
-    {};
-    tracking_type(const tracking_type & t_)
-        : t(t_.t)
-    {}
-    operator bool () const {
-        return t;
-    };
-    operator bool & () {
-        return t;
-    };
-    tracking_type & operator=(const bool t_){
-        t = t_;
-        return *this;
-    }
-    bool operator==(const tracking_type & rhs) const {
-        return t == rhs.t;
-    }
-    bool operator==(const bool & rhs) const {
-        return t == rhs;
-    }
-    tracking_type & operator=(const tracking_type & rhs){
-        t = rhs.t;
-        return *this;
-    }
-};
-
-struct class_name_type : 
-    private boost::noncopyable 
-{
-    char *t;
-    operator const char * & () const {
-        return const_cast<const char * &>(t);
-    }
-    operator char * () {
-        return t;
-    }
-    std::size_t size() const {
-        return std::strlen(t);
-    }
-    explicit class_name_type(const char *key_) 
-    : t(const_cast<char *>(key_)){}
-    explicit class_name_type(char *key_) 
-    : t(key_){}
-    class_name_type & operator=(const class_name_type & rhs){
-        t = rhs.t;
-        return *this;
-    }
-};
-
-enum archive_flags {
-    no_header = 1,  // suppress archive header info
-    no_codecvt = 2,  // suppress alteration of codecvt facet
-    no_xml_tag_checking = 4,   // suppress checking of xml tags
-    no_tracking = 8,           // suppress ALL tracking
-    flags_last = 8
-};
-
-BOOST_ARCHIVE_DECL const char *
-BOOST_ARCHIVE_SIGNATURE();
-
-/* NOTE : Warning  : Warning : Warning : Warning : Warning
- * If any of these are changed to different sized types, 
- * binary_iarchive won't be able to read older archives
- * unless you rev the library version and include conditional
- * code based on the library version.  There is nothing
- * inherently wrong in doing this - but you have to be super
- * careful because it's easy to get wrong and start breaking
- * old archives !!!
- */
-
-#define BOOST_ARCHIVE_STRONG_TYPEDEF(T, D)         \
-    class D : public T {                           \
-    public:                                        \
-        explicit D(const T tt) : T(tt){}           \
-    };                                             \
-/**/
-
-BOOST_ARCHIVE_STRONG_TYPEDEF(class_id_type, class_id_reference_type)
-BOOST_ARCHIVE_STRONG_TYPEDEF(class_id_type, class_id_optional_type)
-BOOST_ARCHIVE_STRONG_TYPEDEF(object_id_type, object_reference_type)
-
-}// namespace archive
-}// namespace boost
-
-#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
-
-#include <boost/serialization/level.hpp>
-
-// set implementation level to primitive for all types
-// used internally by the serialization library
-
-BOOST_CLASS_IMPLEMENTATION(boost::archive::library_version_type, primitive_type)
-BOOST_CLASS_IMPLEMENTATION(boost::archive::version_type, primitive_type)
-BOOST_CLASS_IMPLEMENTATION(boost::archive::class_id_type, primitive_type)
-BOOST_CLASS_IMPLEMENTATION(boost::archive::class_id_reference_type, primitive_type)
-BOOST_CLASS_IMPLEMENTATION(boost::archive::class_id_optional_type, primitive_type)
-BOOST_CLASS_IMPLEMENTATION(boost::archive::class_name_type, primitive_type)
-BOOST_CLASS_IMPLEMENTATION(boost::archive::object_id_type, primitive_type)
-BOOST_CLASS_IMPLEMENTATION(boost::archive::object_reference_type, primitive_type)
-BOOST_CLASS_IMPLEMENTATION(boost::archive::tracking_type, primitive_type)
-
-#include <boost/serialization/is_bitwise_serializable.hpp>
-
-// set types used internally by the serialization library 
-// to be bitwise serializable
-
-BOOST_IS_BITWISE_SERIALIZABLE(boost::archive::library_version_type)
-BOOST_IS_BITWISE_SERIALIZABLE(boost::archive::version_type)
-BOOST_IS_BITWISE_SERIALIZABLE(boost::archive::class_id_type)
-BOOST_IS_BITWISE_SERIALIZABLE(boost::archive::class_id_reference_type)
-BOOST_IS_BITWISE_SERIALIZABLE(boost::archive::class_id_optional_type)
-BOOST_IS_BITWISE_SERIALIZABLE(boost::archive::class_name_type)
-BOOST_IS_BITWISE_SERIALIZABLE(boost::archive::object_id_type)
-BOOST_IS_BITWISE_SERIALIZABLE(boost::archive::object_reference_type)
-BOOST_IS_BITWISE_SERIALIZABLE(boost::archive::tracking_type)
-
-#endif //BOOST_ARCHIVE_BASIC_ARCHIVE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/basic_binary_iarchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/basic_binary_iarchive.hpp
deleted file mode 100644
index c0cc655c997..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/basic_binary_iarchive.hpp
+++ /dev/null
@@ -1,204 +0,0 @@
-#ifndef BOOST_ARCHIVE_BASIC_BINARY_IARCHIVE_HPP
-#define BOOST_ARCHIVE_BASIC_BINARY_IARCHIVE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// basic_binary_iarchive.hpp
-//
-// archives stored as native binary - this should be the fastest way
-// to archive the state of a group of obects.  It makes no attempt to
-// convert to any canonical form.
-
-// IN GENERAL, ARCHIVES CREATED WITH THIS CLASS WILL NOT BE READABLE
-// ON PLATFORM APART FROM THE ONE THEY ARE CREATED ON
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/config.hpp>
-#include <boost/detail/workaround.hpp>
-
-#include <boost/archive/basic_archive.hpp>
-#include <boost/archive/detail/common_iarchive.hpp>
-#include <boost/serialization/collection_size_type.hpp>
-#include <boost/serialization/string.hpp>
-#include <boost/serialization/item_version_type.hpp>
-#include <boost/integer_traits.hpp>
-
-#ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable : 4511 4512)
-#endif
-
-#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
-
-namespace boost { 
-namespace archive {
-
-namespace detail {
-    template<class Archive> class interface_iarchive;
-} // namespace detail
-
-/////////////////////////////////////////////////////////////////////////
-// class basic_binary_iarchive - read serialized objects from a input binary stream
-template<class Archive>
-class BOOST_SYMBOL_VISIBLE basic_binary_iarchive : 
-    public detail::common_iarchive<Archive>
-{
-#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
-public:
-#else
-protected:
-    #if BOOST_WORKAROUND(BOOST_MSVC, < 1500)
-        // for some inexplicable reason insertion of "class" generates compile erro
-        // on msvc 7.1
-        friend detail::interface_iarchive<Archive>;
-    #else
-        friend class detail::interface_iarchive<Archive>;
-    #endif
-#endif
-    // intermediate level to support override of operators
-    // fot templates in the absence of partial function 
-    // template ordering. If we get here pass to base class
-    // note extra nonsense to sneak it pass the borland compiers
-    typedef detail::common_iarchive<Archive> detail_common_iarchive;
-    template<class T>
-    void load_override(T & t){
-      this->detail_common_iarchive::load_override(t);
-    }
-
-    // include these to trap a change in binary format which
-    // isn't specifically handled
-    // upto 32K classes
-    BOOST_STATIC_ASSERT(sizeof(class_id_type) == sizeof(int_least16_t));
-    BOOST_STATIC_ASSERT(sizeof(class_id_reference_type) == sizeof(int_least16_t));
-    // upto 2G objects
-    BOOST_STATIC_ASSERT(sizeof(object_id_type) == sizeof(uint_least32_t));
-    BOOST_STATIC_ASSERT(sizeof(object_reference_type) == sizeof(uint_least32_t));
-
-    // binary files don't include the optional information 
-    void load_override(class_id_optional_type & /* t */){}
-
-    void load_override(tracking_type & t, int /*version*/){
-        library_version_type lvt = this->get_library_version();
-        if(boost::archive::library_version_type(6) < lvt){
-            int_least8_t x=0;
-            * this->This() >> x;
-            t = boost::archive::tracking_type(x);
-        }
-        else{
-            bool x=0;
-            * this->This() >> x;
-            t = boost::archive::tracking_type(x);
-        }
-    }
-    void load_override(class_id_type & t){
-        library_version_type lvt = this->get_library_version();
-        if(boost::archive::library_version_type(7) < lvt){
-            this->detail_common_iarchive::load_override(t);
-        }
-        else
-        if(boost::archive::library_version_type(6) < lvt){
-            int_least16_t x=0;
-            * this->This() >> x;
-            t = boost::archive::class_id_type(x);
-        }
-        else{
-            int x=0;
-            * this->This() >> x;
-            t = boost::archive::class_id_type(x);
-        }
-    }
-    void load_override(class_id_reference_type & t){
-        load_override(static_cast<class_id_type &>(t));
-    }
-
-    void load_override(version_type & t){
-        library_version_type lvt = this->get_library_version();
-        if(boost::archive::library_version_type(7) < lvt){
-            this->detail_common_iarchive::load_override(t);
-        }
-        else
-        if(boost::archive::library_version_type(6) < lvt){
-            uint_least8_t x=0;
-            * this->This() >> x;
-            t = boost::archive::version_type(x);
-        }
-        else
-        if(boost::archive::library_version_type(5) < lvt){
-            uint_least16_t x=0;
-            * this->This() >> x;
-            t = boost::archive::version_type(x);
-        }
-        else
-        if(boost::archive::library_version_type(2) < lvt){
-            // upto 255 versions
-            unsigned char x=0;
-            * this->This() >> x;
-            t = version_type(x);
-        }
-        else{
-            unsigned int x=0;
-            * this->This() >> x;
-            t = boost::archive::version_type(x);
-        }
-    }
-
-    void load_override(boost::serialization::item_version_type & t){
-        library_version_type lvt = this->get_library_version();
-//        if(boost::archive::library_version_type(7) < lvt){
-        if(boost::archive::library_version_type(6) < lvt){
-            this->detail_common_iarchive::load_override(t);
-        }
-        else
-        if(boost::archive::library_version_type(6) < lvt){
-            uint_least16_t x=0;
-            * this->This() >> x;
-            t = boost::serialization::item_version_type(x);
-        }
-        else{
-            unsigned int x=0;
-            * this->This() >> x;
-            t = boost::serialization::item_version_type(x);
-        }
-    }
-
-    void load_override(serialization::collection_size_type & t){
-        if(boost::archive::library_version_type(5) < this->get_library_version()){
-            this->detail_common_iarchive::load_override(t);
-        }
-        else{
-            unsigned int x=0;
-            * this->This() >> x;
-            t = serialization::collection_size_type(x);
-        } 
-    }
-
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-    load_override(class_name_type & t);
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-    init();
-   
-    basic_binary_iarchive(unsigned int flags) :
-        detail::common_iarchive<Archive>(flags)
-    {}
-};
-
-} // namespace archive
-} // namespace boost
-
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
-
-#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
-
-#endif // BOOST_ARCHIVE_BASIC_BINARY_IARCHIVE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/basic_binary_iprimitive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/basic_binary_iprimitive.hpp
deleted file mode 100644
index 665d3e81e1f..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/basic_binary_iprimitive.hpp
+++ /dev/null
@@ -1,198 +0,0 @@
-#ifndef BOOST_ARCHIVE_BINARY_IPRIMITIVE_HPP
-#define BOOST_ARCHIVE_BINARY_IPRIMITIVE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-#if defined(_MSC_VER)
-#pragma warning( disable : 4800 )
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// basic_binary_iprimitive.hpp
-//
-// archives stored as native binary - this should be the fastest way
-// to archive the state of a group of obects.  It makes no attempt to
-// convert to any canonical form.
-
-// IN GENERAL, ARCHIVES CREATED WITH THIS CLASS WILL NOT BE READABLE
-// ON PLATFORM APART FROM THE ONE THEY ARE CREATED ON
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <iosfwd>
-#include <boost/assert.hpp>
-#include <locale>
-#include <cstring> // std::memcpy
-#include <cstddef> // std::size_t
-#include <streambuf> // basic_streambuf
-#include <string>
-
-#include <boost/config.hpp>
-#if defined(BOOST_NO_STDC_NAMESPACE)
-namespace std{ 
-    using ::memcpy; 
-    using ::size_t;
-} // namespace std
-#endif
-
-#include <boost/cstdint.hpp>
-#include <boost/serialization/throw_exception.hpp>
-#include <boost/integer.hpp>
-#include <boost/integer_traits.hpp>
-
-//#include <boost/mpl/placeholders.hpp>
-#include <boost/serialization/is_bitwise_serializable.hpp>
-#include <boost/serialization/array_wrapper.hpp>
-
-#include <boost/archive/basic_streambuf_locale_saver.hpp>
-#include <boost/archive/codecvt_null.hpp>
-#include <boost/archive/archive_exception.hpp>
-#include <boost/archive/detail/auto_link_archive.hpp>
-#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
-
-namespace boost { 
-namespace archive {
-
-/////////////////////////////////////////////////////////////////////////////
-// class binary_iarchive - read serialized objects from a input binary stream
-template<class Archive, class Elem, class Tr>
-class BOOST_SYMBOL_VISIBLE basic_binary_iprimitive {
-#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
-    friend class load_access;
-protected:
-#else
-public:
-#endif
-    std::basic_streambuf<Elem, Tr> & m_sb;
-    // return a pointer to the most derived class
-    Archive * This(){
-        return static_cast<Archive *>(this);
-    }
-
-    #ifndef BOOST_NO_STD_LOCALE
-    // note order! - if you change this, libstd++ will fail!
-    // a) create new locale with new codecvt facet
-    // b) save current locale
-    // c) change locale to new one
-    // d) use stream buffer
-    // e) change locale back to original
-    // f) destroy new codecvt facet
-    boost::archive::codecvt_null<Elem> codecvt_null_facet;
-    basic_streambuf_locale_saver<Elem, Tr> locale_saver;
-    std::locale archive_locale;
-    #endif
-
-    // main template for serilization of primitive types
-    template<class T>
-    void load(T & t){
-        load_binary(& t, sizeof(T));
-    }
-
-    /////////////////////////////////////////////////////////
-    // fundamental types that need special treatment
-    
-    // trap usage of invalid uninitialized boolean 
-    void load(bool & t){
-        load_binary(& t, sizeof(t));
-        int i = t;
-        BOOST_ASSERT(0 == i || 1 == i);
-        (void)i; // warning suppression for release builds.
-    }
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-    load(std::string &s);
-    #ifndef BOOST_NO_STD_WSTRING
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-    load(std::wstring &ws);
-    #endif
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-    load(char * t);
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-    load(wchar_t * t);
-
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-    init();
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL 
-    basic_binary_iprimitive(
-        std::basic_streambuf<Elem, Tr> & sb, 
-        bool no_codecvt
-    );
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL 
-    ~basic_binary_iprimitive();
-public:
-    // we provide an optimized load for all fundamental types
-    // typedef serialization::is_bitwise_serializable<mpl::_1> 
-    // use_array_optimization;
-    struct use_array_optimization {  
-        template <class T>  
-        #if defined(BOOST_NO_DEPENDENT_NESTED_DERIVATIONS)  
-            struct apply {  
-                typedef typename boost::serialization::is_bitwise_serializable< T >::type type;  
-            };
-        #else
-            struct apply : public boost::serialization::is_bitwise_serializable< T > {};  
-        #endif
-    };
-
-    // the optimized load_array dispatches to load_binary 
-    template <class ValueType>
-    void load_array(serialization::array_wrapper<ValueType>& a, unsigned int)
-    {
-      load_binary(a.address(),a.count()*sizeof(ValueType));
-    }
-
-    void
-    load_binary(void *address, std::size_t count);
-};
-
-template<class Archive, class Elem, class Tr>
-inline void
-basic_binary_iprimitive<Archive, Elem, Tr>::load_binary(
-    void *address, 
-    std::size_t count
-){
-    // note: an optimizer should eliminate the following for char files
-    BOOST_ASSERT(
-        static_cast<std::streamsize>(count / sizeof(Elem)) 
-        <= boost::integer_traits<std::streamsize>::const_max
-    );
-    std::streamsize s = static_cast<std::streamsize>(count / sizeof(Elem));
-    std::streamsize scount = m_sb.sgetn(
-        static_cast<Elem *>(address), 
-        s
-    );
-    if(scount != s)
-        boost::serialization::throw_exception(
-            archive_exception(archive_exception::input_stream_error)
-        );
-    // note: an optimizer should eliminate the following for char files
-    BOOST_ASSERT(count % sizeof(Elem) <= boost::integer_traits<std::streamsize>::const_max);
-    s = static_cast<std::streamsize>(count % sizeof(Elem));
-    if(0 < s){
-//        if(is.fail())
-//            boost::serialization::throw_exception(
-//                archive_exception(archive_exception::stream_error)
-//        );
-        Elem t;
-        scount = m_sb.sgetn(& t, 1);
-        if(scount != 1)
-            boost::serialization::throw_exception(
-                archive_exception(archive_exception::input_stream_error)
-            );
-        std::memcpy(static_cast<char*>(address) + (count - s), &t, static_cast<std::size_t>(s));
-    }
-}
-
-} // namespace archive
-} // namespace boost
-
-#include <boost/archive/detail/abi_suffix.hpp> // pop pragmas
-
-#endif // BOOST_ARCHIVE_BINARY_IPRIMITIVE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/basic_binary_oarchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/basic_binary_oarchive.hpp
deleted file mode 100644
index f05f2f86d55..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/basic_binary_oarchive.hpp
+++ /dev/null
@@ -1,185 +0,0 @@
-#ifndef BOOST_ARCHIVE_BASIC_BINARY_OARCHIVE_HPP
-#define BOOST_ARCHIVE_BASIC_BINARY_OARCHIVE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// basic_binary_oarchive.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-// archives stored as native binary - this should be the fastest way
-// to archive the state of a group of obects.  It makes no attempt to
-// convert to any canonical form.
-
-// IN GENERAL, ARCHIVES CREATED WITH THIS CLASS WILL NOT BE READABLE
-// ON PLATFORM APART FROM THE ONE THEY ARE CREATE ON
-
-#include <boost/assert.hpp>
-#include <boost/config.hpp>
-#include <boost/detail/workaround.hpp>
-
-#include <boost/integer.hpp>
-#include <boost/integer_traits.hpp>
-
-#include <boost/archive/detail/common_oarchive.hpp>
-#include <boost/serialization/string.hpp>
-#include <boost/serialization/collection_size_type.hpp>
-#include <boost/serialization/item_version_type.hpp>
-
-#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
-
-#ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable : 4511 4512)
-#endif
-
-namespace boost {
-namespace archive {
-
-namespace detail {
-    template<class Archive> class interface_oarchive;
-} // namespace detail
-
-//////////////////////////////////////////////////////////////////////
-// class basic_binary_oarchive - write serialized objects to a binary output stream
-// note: this archive has no pretensions to portability.  Archive format
-// may vary across machine architectures and compilers.  About the only
-// guarentee is that an archive created with this code will be readable
-// by a program built with the same tools for the same machne.  This class
-// does have the virtue of buiding the smalles archive in the minimum amount
-// of time.  So under some circumstances it may be he right choice.
-template<class Archive>
-class BOOST_SYMBOL_VISIBLE basic_binary_oarchive : 
-    public detail::common_oarchive<Archive>
-{
-#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
-public:
-#else
-protected:
-    #if BOOST_WORKAROUND(BOOST_MSVC, < 1500)
-        // for some inexplicable reason insertion of "class" generates compile erro
-        // on msvc 7.1
-        friend detail::interface_oarchive<Archive>;
-    #else
-        friend class detail::interface_oarchive<Archive>;
-    #endif
-#endif
-    // any datatype not specifed below will be handled by base class
-    typedef detail::common_oarchive<Archive> detail_common_oarchive;
-    template<class T>
-    void save_override(const T & t){
-      this->detail_common_oarchive::save_override(t);
-    }
-
-    // include these to trap a change in binary format which
-    // isn't specifically handled
-    BOOST_STATIC_ASSERT(sizeof(tracking_type) == sizeof(bool));
-    // upto 32K classes
-    BOOST_STATIC_ASSERT(sizeof(class_id_type) == sizeof(int_least16_t));
-    BOOST_STATIC_ASSERT(sizeof(class_id_reference_type) == sizeof(int_least16_t));
-    // upto 2G objects
-    BOOST_STATIC_ASSERT(sizeof(object_id_type) == sizeof(uint_least32_t));
-    BOOST_STATIC_ASSERT(sizeof(object_reference_type) == sizeof(uint_least32_t));
-
-    // binary files don't include the optional information 
-    void save_override(const class_id_optional_type & /* t */){}
-
-    // enable this if we decide to support generation of previous versions
-    #if 0
-    void save_override(const boost::archive::version_type & t){
-        library_version_type lvt = this->get_library_version();
-        if(boost::archive::library_version_type(7) < lvt){
-            this->detail_common_oarchive::save_override(t);
-        }
-        else
-        if(boost::archive::library_version_type(6) < lvt){
-            const boost::uint_least16_t x = t;
-            * this->This() << x;
-        }
-        else{
-            const unsigned int x = t;
-            * this->This() << x;
-        }
-    }
-    void save_override(const boost::serialization::item_version_type & t){
-        library_version_type lvt = this->get_library_version();
-        if(boost::archive::library_version_type(7) < lvt){
-            this->detail_common_oarchive::save_override(t);
-        }
-        else
-        if(boost::archive::library_version_type(6) < lvt){
-            const boost::uint_least16_t x = t;
-            * this->This() << x;
-        }
-        else{
-            const unsigned int x = t;
-            * this->This() << x;
-        }
-    }
-
-    void save_override(class_id_type & t){
-        library_version_type lvt = this->get_library_version();
-        if(boost::archive::library_version_type(7) < lvt){
-            this->detail_common_oarchive::save_override(t);
-        }
-        else
-        if(boost::archive::library_version_type(6) < lvt){
-            const boost::int_least16_t x = t;
-            * this->This() << x;
-        }
-        else{
-            const int x = t;
-            * this->This() << x;
-        }
-    }
-    void save_override(class_id_reference_type & t){
-        save_override(static_cast<class_id_type &>(t));
-    }
-
-    #endif
-
-    // explicitly convert to char * to avoid compile ambiguities
-    void save_override(const class_name_type & t){
-        const std::string s(t);
-        * this->This() << s;
-    }
-
-    #if 0
-    void save_override(const serialization::collection_size_type & t){
-        if (get_library_version() < boost::archive::library_version_type(6)){
-            unsigned int x=0;
-            * this->This() >> x;
-            t = serialization::collection_size_type(x);
-        } 
-        else{
-            * this->This() >> t;
-        }
-    }
-    #endif
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-    init();
-
-    basic_binary_oarchive(unsigned int flags) :
-        detail::common_oarchive<Archive>(flags)
-    {}
-};
-
-} // namespace archive
-} // namespace boost
-
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
-
-#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
-
-#endif // BOOST_ARCHIVE_BASIC_BINARY_OARCHIVE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/basic_binary_oprimitive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/basic_binary_oprimitive.hpp
deleted file mode 100644
index 6dc770c60e8..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/basic_binary_oprimitive.hpp
+++ /dev/null
@@ -1,188 +0,0 @@
-#ifndef BOOST_ARCHIVE_BASIC_BINARY_OPRIMITIVE_HPP
-#define BOOST_ARCHIVE_BASIC_BINARY_OPRIMITIVE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// basic_binary_oprimitive.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-// archives stored as native binary - this should be the fastest way
-// to archive the state of a group of obects.  It makes no attempt to
-// convert to any canonical form.
-
-// IN GENERAL, ARCHIVES CREATED WITH THIS CLASS WILL NOT BE READABLE
-// ON PLATFORM APART FROM THE ONE THEY ARE CREATE ON
-
-#include <iosfwd>
-#include <boost/assert.hpp>
-#include <locale>
-#include <streambuf> // basic_streambuf
-#include <string>
-#include <cstddef> // size_t
-
-#include <boost/config.hpp>
-#if defined(BOOST_NO_STDC_NAMESPACE)
-namespace std{ 
-    using ::size_t; 
-} // namespace std
-#endif
-
-#include <boost/cstdint.hpp>
-#include <boost/integer.hpp>
-#include <boost/integer_traits.hpp>
-#include <boost/scoped_ptr.hpp>
-#include <boost/serialization/throw_exception.hpp>
-
-//#include <boost/mpl/placeholders.hpp>
-#include <boost/serialization/is_bitwise_serializable.hpp>
-#include <boost/serialization/array_wrapper.hpp>
-
-#include <boost/archive/basic_streambuf_locale_saver.hpp>
-#include <boost/archive/codecvt_null.hpp>
-#include <boost/archive/archive_exception.hpp>
-#include <boost/archive/detail/auto_link_archive.hpp>
-#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
-
-namespace boost {
-namespace archive {
-
-/////////////////////////////////////////////////////////////////////////
-// class basic_binary_oprimitive - binary output of prmitives
-
-template<class Archive, class Elem, class Tr>
-class BOOST_SYMBOL_VISIBLE basic_binary_oprimitive {
-#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
-    friend class save_access;
-protected:
-#else
-public:
-#endif
-    std::basic_streambuf<Elem, Tr> & m_sb;
-    // return a pointer to the most derived class
-    Archive * This(){
-        return static_cast<Archive *>(this);
-    }
-    #ifndef BOOST_NO_STD_LOCALE
-    // note order! - if you change this, libstd++ will fail!
-    // a) create new locale with new codecvt facet
-    // b) save current locale
-    // c) change locale to new one
-    // d) use stream buffer
-    // e) change locale back to original
-    // f) destroy new codecvt facet
-    boost::archive::codecvt_null<Elem> codecvt_null_facet;
-    basic_streambuf_locale_saver<Elem, Tr> locale_saver;
-    std::locale archive_locale;
-    #endif
-    // default saving of primitives.
-    template<class T>
-    void save(const T & t)
-    {
-        save_binary(& t, sizeof(T));
-    }
-
-    /////////////////////////////////////////////////////////
-    // fundamental types that need special treatment
-    
-    // trap usage of invalid uninitialized boolean which would
-    // otherwise crash on load.
-    void save(const bool t){
-        BOOST_ASSERT(0 == static_cast<int>(t) || 1 == static_cast<int>(t));
-        save_binary(& t, sizeof(t));
-    }
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-    save(const std::string &s);
-    #ifndef BOOST_NO_STD_WSTRING
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-    save(const std::wstring &ws);
-    #endif
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-    save(const char * t);
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-    save(const wchar_t * t);
-
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-    init();
-    
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL 
-    basic_binary_oprimitive(
-        std::basic_streambuf<Elem, Tr> & sb, 
-        bool no_codecvt
-    );
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL 
-    ~basic_binary_oprimitive();
-public:
-
-    // we provide an optimized save for all fundamental types
-    // typedef serialization::is_bitwise_serializable<mpl::_1> 
-    // use_array_optimization;
-    // workaround without using mpl lambdas
-    struct use_array_optimization {
-        template <class T>  
-        #if defined(BOOST_NO_DEPENDENT_NESTED_DERIVATIONS)  
-            struct apply {  
-                typedef typename boost::serialization::is_bitwise_serializable< T >::type type;  
-            };
-        #else
-            struct apply : public boost::serialization::is_bitwise_serializable< T > {};  
-        #endif
-    };
-
-    // the optimized save_array dispatches to save_binary 
-    template <class ValueType>
-    void save_array(boost::serialization::array_wrapper<ValueType> const& a, unsigned int)
-    {
-      save_binary(a.address(),a.count()*sizeof(ValueType));
-    }
-
-    void save_binary(const void *address, std::size_t count);
-};
-
-template<class Archive, class Elem, class Tr>
-inline void 
-basic_binary_oprimitive<Archive, Elem, Tr>::save_binary(
-    const void *address, 
-    std::size_t count
-){
-    // BOOST_ASSERT(count <= std::size_t(boost::integer_traits<std::streamsize>::const_max));
-    // note: if the following assertions fail
-    // a likely cause is that the output stream is set to "text"
-    // mode where by cr characters recieve special treatment.
-    // be sure that the output stream is opened with ios::binary
-    //if(os.fail())
-    //    boost::serialization::throw_exception(
-    //        archive_exception(archive_exception::output_stream_error)
-    //    );
-    // figure number of elements to output - round up
-    count = ( count + sizeof(Elem) - 1) / sizeof(Elem);
-    std::streamsize scount = m_sb.sputn(
-        static_cast<const Elem *>(address), 
-        static_cast<std::streamsize>(count)
-    );
-    if(count != static_cast<std::size_t>(scount))
-        boost::serialization::throw_exception(
-            archive_exception(archive_exception::output_stream_error)
-        );
-    //os.write(
-    //    static_cast<const typename OStream::char_type *>(address), 
-    //    count
-    //);
-    //BOOST_ASSERT(os.good());
-}
-
-} //namespace boost 
-} //namespace archive 
-
-#include <boost/archive/detail/abi_suffix.hpp> // pop pragmas
-
-#endif // BOOST_ARCHIVE_BASIC_BINARY_OPRIMITIVE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/basic_streambuf_locale_saver.hpp b/contrib/libboost/boost_1_65_0/boost/archive/basic_streambuf_locale_saver.hpp
deleted file mode 100644
index 5cd4b36f081..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/basic_streambuf_locale_saver.hpp
+++ /dev/null
@@ -1,108 +0,0 @@
-#ifndef BOOST_ARCHIVE_BASIC_STREAMBUF_LOCALE_SAVER_HPP
-#define BOOST_ARCHIVE_BASIC_STREAMBUF_LOCALE_SAVER_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// basic_streambuf_locale_saver.hpp
-
-// (C) Copyright 2005 Robert Ramey - http://www.rrsd.com
-
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-// note derived from boost/io/ios_state.hpp
-// Copyright 2002, 2005 Daryle Walker.  Use, modification, and distribution
-// are subject to the Boost Software License, Version 1.0.  (See accompanying
-// file LICENSE_1_0.txt or a copy at <http://www.boost.org/LICENSE_1_0.txt>.)
-
-//  See <http://www.boost.org/libs/io/> for the library's home page.
-
-#ifndef BOOST_NO_STD_LOCALE
-
-#include <locale>     // for std::locale
-#include <ios>
-#include <streambuf>  // for std::basic_streambuf
-
-#include <boost/config.hpp>
-#include <boost/noncopyable.hpp>
-
-#ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable : 4511 4512)
-#endif
-
-namespace boost{
-namespace archive{
-
-template < typename Ch, class Tr >
-class basic_streambuf_locale_saver :
-    private boost::noncopyable
-{
-public:
-    explicit basic_streambuf_locale_saver(std::basic_streambuf<Ch, Tr> &s) :
-        m_streambuf(s),
-        m_locale(s.getloc())
-    {}
-    ~basic_streambuf_locale_saver(){
-        m_streambuf.pubsync();
-        m_streambuf.pubimbue(m_locale);
-    }
-private:
-    std::basic_streambuf<Ch, Tr> &       m_streambuf;
-    std::locale const  m_locale;
-};
-
-template < typename Ch, class Tr >
-class basic_istream_locale_saver :
-    private boost::noncopyable
-{
-public:
-    explicit basic_istream_locale_saver(std::basic_istream<Ch, Tr> &s) :
-        m_istream(s),
-        m_locale(s.getloc())
-    {}
-    ~basic_istream_locale_saver(){
-        // libstdc++ crashes without this
-        m_istream.sync();
-        m_istream.imbue(m_locale);
-    }
-private:
-    std::basic_istream<Ch, Tr> & m_istream;
-    std::locale const  m_locale;
-};
-
-template < typename Ch, class Tr >
-class basic_ostream_locale_saver :
-    private boost::noncopyable
-{
-public:
-    explicit basic_ostream_locale_saver(std::basic_ostream<Ch, Tr> &s) :
-        m_ostream(s),
-        m_locale(s.getloc())
-    {}
-    ~basic_ostream_locale_saver(){
-        m_ostream.flush();
-        m_ostream.imbue(m_locale);
-    }
-private:
-    std::basic_ostream<Ch, Tr> & m_ostream;
-    std::locale const  m_locale;
-};
-
-
-} // archive
-} // boost
-
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
-
-#endif // BOOST_NO_STD_LOCALE
-#endif // BOOST_ARCHIVE_BASIC_STREAMBUF_LOCALE_SAVER_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/basic_text_iarchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/basic_text_iarchive.hpp
deleted file mode 100644
index 48a646cc1f7..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/basic_text_iarchive.hpp
+++ /dev/null
@@ -1,96 +0,0 @@
-#ifndef BOOST_ARCHIVE_BASIC_TEXT_IARCHIVE_HPP
-#define BOOST_ARCHIVE_BASIC_TEXT_IARCHIVE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// basic_text_iarchive.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-// archives stored as text - note these ar templated on the basic
-// stream templates to accommodate wide (and other?) kind of characters
-//
-// note the fact that on libraries without wide characters, ostream is
-// is not a specialization of basic_ostream which in fact is not defined
-// in such cases.   So we can't use basic_istream<IStream::char_type> but rather
-// use two template parameters
-
-#include <boost/config.hpp>
-#include <boost/detail/workaround.hpp>
-
-#include <boost/archive/detail/common_iarchive.hpp>
-
-#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
-
-#ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable : 4511 4512)
-#endif
-
-namespace boost {
-namespace archive {
-
-namespace detail {
-    template<class Archive> class interface_iarchive;
-} // namespace detail
-
-/////////////////////////////////////////////////////////////////////////
-// class basic_text_iarchive - read serialized objects from a input text stream
-template<class Archive>
-class BOOST_SYMBOL_VISIBLE basic_text_iarchive : 
-    public detail::common_iarchive<Archive>
-{
-#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
-public:
-#else
-protected:
-    #if BOOST_WORKAROUND(BOOST_MSVC, < 1500)
-        // for some inexplicable reason insertion of "class" generates compile erro
-        // on msvc 7.1
-        friend detail::interface_iarchive<Archive>;
-    #else
-        friend class detail::interface_iarchive<Archive>;
-    #endif
-#endif
-    // intermediate level to support override of operators
-    // fot templates in the absence of partial function 
-    // template ordering
-    typedef detail::common_iarchive<Archive> detail_common_iarchive;
-    template<class T>
-    void load_override(T & t){
-        this->detail_common_iarchive::load_override(t);
-    }
-    // text file don't include the optional information 
-    void load_override(class_id_optional_type & /*t*/){}
-
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-    load_override(class_name_type & t);
-
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-    init(void);
-
-    basic_text_iarchive(unsigned int flags) : 
-        detail::common_iarchive<Archive>(flags)
-    {}
-    ~basic_text_iarchive(){}
-};
-
-} // namespace archive
-} // namespace boost
-
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
-
-#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
-
-#endif // BOOST_ARCHIVE_BASIC_TEXT_IARCHIVE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/basic_text_iprimitive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/basic_text_iprimitive.hpp
deleted file mode 100644
index bf936b55546..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/basic_text_iprimitive.hpp
+++ /dev/null
@@ -1,142 +0,0 @@
-#ifndef BOOST_ARCHIVE_BASIC_TEXT_IPRIMITIVE_HPP
-#define BOOST_ARCHIVE_BASIC_TEXT_IPRIMITIVE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// basic_text_iprimitive.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-// archives stored as text - note these are templated on the basic
-// stream templates to accommodate wide (and other?) kind of characters
-//
-// Note the fact that on libraries without wide characters, ostream is
-// not a specialization of basic_ostream which in fact is not defined
-// in such cases.   So we can't use basic_ostream<IStream::char_type> but rather
-// use two template parameters
-
-#include <locale>
-#include <cstddef> // size_t
-
-#include <boost/config.hpp>
-#if defined(BOOST_NO_STDC_NAMESPACE)
-namespace std{ 
-    using ::size_t; 
-    #if ! defined(BOOST_DINKUMWARE_STDLIB) && ! defined(__SGI_STL_PORT)
-        using ::locale;
-    #endif
-} // namespace std
-#endif
-
-#include <boost/io/ios_state.hpp>
-#include <boost/static_assert.hpp>
-
-#include <boost/detail/workaround.hpp>
-#if BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, == 1)
-#include <boost/archive/dinkumware.hpp>
-#endif
-#include <boost/serialization/throw_exception.hpp>
-#include <boost/archive/codecvt_null.hpp>
-#include <boost/archive/archive_exception.hpp>
-#include <boost/archive/basic_streambuf_locale_saver.hpp>
-#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
-
-namespace boost {
-namespace archive {
-
-/////////////////////////////////////////////////////////////////////////
-// class basic_text_iarchive - load serialized objects from a input text stream
-#if defined(_MSC_VER)
-#pragma warning( push )
-#pragma warning( disable : 4244 4267 )
-#endif
-
-template<class IStream>
-class BOOST_SYMBOL_VISIBLE basic_text_iprimitive {
-protected:
-    IStream &is;
-    io::ios_flags_saver flags_saver;
-    io::ios_precision_saver precision_saver;
-
-    #ifndef BOOST_NO_STD_LOCALE
-    // note order! - if you change this, libstd++ will fail!
-    // a) create new locale with new codecvt facet
-    // b) save current locale
-    // c) change locale to new one
-    // d) use stream buffer
-    // e) change locale back to original
-    // f) destroy new codecvt facet
-    boost::archive::codecvt_null<typename IStream::char_type> codecvt_null_facet;
-    std::locale archive_locale;
-    basic_istream_locale_saver<
-        typename IStream::char_type,
-        typename IStream::traits_type
-    > locale_saver;
-    #endif
-
-    template<class T>
-    void load(T & t)
-    {
-        if(is >> t)
-            return;
-        boost::serialization::throw_exception(
-            archive_exception(archive_exception::input_stream_error)
-        );
-    }
-
-    void load(char & t)
-    {
-        short int i;
-        load(i);
-        t = i;
-    }
-    void load(signed char & t)
-    {
-        short int i;
-        load(i);
-        t = i;
-    }
-    void load(unsigned char & t)
-    {
-        unsigned short int i;
-        load(i);
-        t = i;
-    }
-
-    #ifndef BOOST_NO_INTRINSIC_WCHAR_T
-    void load(wchar_t & t)
-    {
-        BOOST_STATIC_ASSERT(sizeof(wchar_t) <= sizeof(int));
-        int i;
-        load(i);
-        t = i;
-    }
-    #endif
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL 
-    basic_text_iprimitive(IStream  &is, bool no_codecvt);
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL 
-    ~basic_text_iprimitive();
-public:
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-    load_binary(void *address, std::size_t count);
-};
-
-#if defined(_MSC_VER)
-#pragma warning( pop )
-#endif
-
-} // namespace archive
-} // namespace boost
-
-#include <boost/archive/detail/abi_suffix.hpp> // pop pragmas
-
-#endif // BOOST_ARCHIVE_BASIC_TEXT_IPRIMITIVE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/basic_text_oarchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/basic_text_oarchive.hpp
deleted file mode 100644
index 6f7f8fb167d..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/basic_text_oarchive.hpp
+++ /dev/null
@@ -1,119 +0,0 @@
-#ifndef BOOST_ARCHIVE_BASIC_TEXT_OARCHIVE_HPP
-#define BOOST_ARCHIVE_BASIC_TEXT_OARCHIVE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// basic_text_oarchive.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-// archives stored as text - note these ar templated on the basic
-// stream templates to accommodate wide (and other?) kind of characters
-//
-// note the fact that on libraries without wide characters, ostream is
-// is not a specialization of basic_ostream which in fact is not defined
-// in such cases.   So we can't use basic_ostream<OStream::char_type> but rather
-// use two template parameters
-
-#include <boost/config.hpp>
-#include <boost/detail/workaround.hpp>
-#include <boost/archive/detail/common_oarchive.hpp>
-#include <boost/serialization/string.hpp>
-
-#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
-
-#ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable : 4511 4512)
-#endif
-
-namespace boost {
-namespace archive {
-
-namespace detail {
-    template<class Archive> class interface_oarchive;
-} // namespace detail
-
-/////////////////////////////////////////////////////////////////////////
-// class basic_text_oarchive 
-template<class Archive>
-class BOOST_SYMBOL_VISIBLE basic_text_oarchive : 
-    public detail::common_oarchive<Archive>
-{
-#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
-public:
-#else
-protected:
-    #if BOOST_WORKAROUND(BOOST_MSVC, < 1500)
-        // for some inexplicable reason insertion of "class" generates compile erro
-        // on msvc 7.1
-        friend detail::interface_oarchive<Archive>;
-    #else
-        friend class detail::interface_oarchive<Archive>;
-    #endif
-#endif
-
-    enum {
-        none,
-        eol,
-        space
-    } delimiter;
-
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-    newtoken();
-
-    void newline(){
-        delimiter = eol;
-    }
-
-    // default processing - kick back to base class.  Note the
-    // extra stuff to get it passed borland compilers
-    typedef detail::common_oarchive<Archive> detail_common_oarchive;
-    template<class T>
-    void save_override(T & t){
-        this->detail_common_oarchive::save_override(t);
-    }
-
-    // start new objects on a new line
-    void save_override(const object_id_type & t){
-        this->This()->newline();
-        this->detail_common_oarchive::save_override(t);
-    }
-
-    // text file don't include the optional information 
-    void save_override(const class_id_optional_type & /* t */){}
-
-    void save_override(const class_name_type & t){
-        const std::string s(t);
-        * this->This() << s;
-    }
-
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-    init();
-
-    basic_text_oarchive(unsigned int flags) :
-        detail::common_oarchive<Archive>(flags),
-        delimiter(none)
-    {}
-    ~basic_text_oarchive(){}
-};
-
-} // namespace archive
-} // namespace boost
-
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
-
-#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
-
-#endif // BOOST_ARCHIVE_BASIC_TEXT_OARCHIVE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/basic_text_oprimitive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/basic_text_oprimitive.hpp
deleted file mode 100644
index 45f09358ece..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/basic_text_oprimitive.hpp
+++ /dev/null
@@ -1,209 +0,0 @@
-#ifndef BOOST_ARCHIVE_BASIC_TEXT_OPRIMITIVE_HPP
-#define BOOST_ARCHIVE_BASIC_TEXT_OPRIMITIVE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// basic_text_oprimitive.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-// archives stored as text - note these ar templated on the basic
-// stream templates to accommodate wide (and other?) kind of characters
-//
-// note the fact that on libraries without wide characters, ostream is
-// is not a specialization of basic_ostream which in fact is not defined
-// in such cases.   So we can't use basic_ostream<OStream::char_type> but rather
-// use two template parameters
-
-#include <iomanip>
-#include <locale>
-#include <cstddef> // size_t
-
-#include <boost/config.hpp>
-#include <boost/static_assert.hpp>
-#include <boost/io/ios_state.hpp>
-
-#include <boost/detail/workaround.hpp>
-#if BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, == 1)
-#include <boost/archive/dinkumware.hpp>
-#endif
-
-#if defined(BOOST_NO_STDC_NAMESPACE)
-namespace std{ 
-    using ::size_t;
-    #if ! defined(BOOST_DINKUMWARE_STDLIB) && ! defined(__SGI_STL_PORT)
-        using ::locale;
-    #endif
-} // namespace std
-#endif
-
-#include <boost/type_traits/is_floating_point.hpp>
-#include <boost/mpl/bool.hpp>
-#include <boost/limits.hpp>
-#include <boost/integer.hpp>
-#include <boost/io/ios_state.hpp>
-#include <boost/serialization/throw_exception.hpp>
-#include <boost/archive/basic_streambuf_locale_saver.hpp>
-#include <boost/archive/codecvt_null.hpp>
-#include <boost/archive/archive_exception.hpp>
-#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
-
-namespace boost {
-namespace archive {
-
-/////////////////////////////////////////////////////////////////////////
-// class basic_text_oprimitive - output of prmitives to stream
-template<class OStream>
-class BOOST_SYMBOL_VISIBLE basic_text_oprimitive
-{
-protected:
-    OStream &os;
-    io::ios_flags_saver flags_saver;
-    io::ios_precision_saver precision_saver;
-
-    #ifndef BOOST_NO_STD_LOCALE
-    // note order! - if you change this, libstd++ will fail!
-    // a) create new locale with new codecvt facet
-    // b) save current locale
-    // c) change locale to new one
-    // d) use stream buffer
-    // e) change locale back to original
-    // f) destroy new codecvt facet
-    boost::archive::codecvt_null<typename OStream::char_type> codecvt_null_facet;
-    std::locale archive_locale;
-    basic_ostream_locale_saver<
-        typename OStream::char_type,
-        typename OStream::traits_type
-    > locale_saver;
-    #endif
-
-    /////////////////////////////////////////////////////////
-    // fundamental types that need special treatment
-    void save(const bool t){
-        // trap usage of invalid uninitialized boolean which would
-        // otherwise crash on load.
-        BOOST_ASSERT(0 == static_cast<int>(t) || 1 == static_cast<int>(t));
-        if(os.fail())
-            boost::serialization::throw_exception(
-                archive_exception(archive_exception::output_stream_error)
-            );
-        os << t;
-    }
-    void save(const signed char t)
-    {
-        save(static_cast<short int>(t));
-    }
-    void save(const unsigned char t)
-    {
-        save(static_cast<short unsigned int>(t));
-    }
-    void save(const char t)
-    {
-        save(static_cast<short int>(t));
-    }
-    #ifndef BOOST_NO_INTRINSIC_WCHAR_T
-    void save(const wchar_t t)
-    {
-        BOOST_STATIC_ASSERT(sizeof(wchar_t) <= sizeof(int));
-        save(static_cast<int>(t));
-    }
-    #endif
-
-    /////////////////////////////////////////////////////////
-    // saving of any types not listed above
-
-    template<class T>
-    void save_impl(const T &t, boost::mpl::bool_<false> &){
-        if(os.fail())
-            boost::serialization::throw_exception(
-                archive_exception(archive_exception::output_stream_error)
-            );
-        os << t;
-    }
-
-    /////////////////////////////////////////////////////////
-    // floating point types need even more special treatment
-    // the following determines whether the type T is some sort
-    // of floating point type.  Note that we then assume that
-    // the stream << operator is defined on that type - if not
-    // we'll get a compile time error. This is meant to automatically
-    // support synthesized types which support floating point
-    // operations. Also it should handle compiler dependent types
-    // such long double.  Due to John Maddock.
-
-    template<class T>
-    struct is_float {
-        typedef typename mpl::bool_< 
-            boost::is_floating_point<T>::value 
-            || (std::numeric_limits<T>::is_specialized
-            && !std::numeric_limits<T>::is_integer
-            && !std::numeric_limits<T>::is_exact
-            && std::numeric_limits<T>::max_exponent) 
-        >::type type;
-    };
-
-    template<class T>
-    void save_impl(const T &t, boost::mpl::bool_<true> &){
-        // must be a user mistake - can't serialize un-initialized data
-        if(os.fail())
-            boost::serialization::throw_exception(
-                archive_exception(archive_exception::output_stream_error)
-            );
-        // The formulae for the number of decimla digits required is given in
-        // http://www2.open-std.org/JTC1/SC22/WG21/docs/papers/2005/n1822.pdf
-        // which is derived from Kahan's paper:
-        // www.eecs.berkeley.edu/~wkahan/ieee754status/ieee754.ps
-        // const unsigned int digits = (std::numeric_limits<T>::digits * 3010) / 10000;
-        // note: I've commented out the above because I didn't get good results.  e.g.
-        // in one case I got a difference of 19 units.
-        #ifndef BOOST_NO_CXX11_NUMERIC_LIMITS
-            const unsigned int digits = std::numeric_limits<T>::max_digits10;
-        #else
-            const unsigned int digits = std::numeric_limits<T>::digits10 + 2;
-        #endif
-        os << std::setprecision(digits) << std::scientific << t;
-    }
-
-    template<class T>
-    void save(const T & t){
-        typename is_float<T>::type tf;
-        save_impl(t, tf);
-    }
-
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL
-    basic_text_oprimitive(OStream & os, bool no_codecvt);
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL 
-    ~basic_text_oprimitive();
-public:
-    // unformatted append of one character
-    void put(typename OStream::char_type c){
-        if(os.fail())
-            boost::serialization::throw_exception(
-                archive_exception(archive_exception::output_stream_error)
-            );
-        os.put(c);
-    }
-    // unformatted append of null terminated string
-    void put(const char * s){
-        while('\0' != *s)
-            os.put(*s++);
-    }
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL void 
-    save_binary(const void *address, std::size_t count);
-};
-
-} //namespace boost 
-} //namespace archive 
-
-#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
-
-#endif // BOOST_ARCHIVE_BASIC_TEXT_OPRIMITIVE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/basic_xml_archive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/basic_xml_archive.hpp
deleted file mode 100644
index bef368b973b..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/basic_xml_archive.hpp
+++ /dev/null
@@ -1,67 +0,0 @@
-#ifndef BOOST_ARCHIVE_BASIC_XML_TEXT_ARCHIVE_HPP
-#define BOOST_ARCHIVE_BASIC_XML_TEXT_ARCHIVE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// basic_xml_archive.hpp:
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/archive/archive_exception.hpp>
-
-#include <boost/archive/detail/auto_link_archive.hpp>
-#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
-
-namespace boost { 
-namespace archive {
-
-// constant strings used in xml i/o
-
-extern 
-BOOST_ARCHIVE_DECL const char *
-BOOST_ARCHIVE_XML_OBJECT_ID();
-
-extern 
-BOOST_ARCHIVE_DECL const char *
-BOOST_ARCHIVE_XML_OBJECT_REFERENCE();
-
-extern 
-BOOST_ARCHIVE_DECL const char *
-BOOST_ARCHIVE_XML_CLASS_ID();
-
-extern 
-BOOST_ARCHIVE_DECL const char *
-BOOST_ARCHIVE_XML_CLASS_ID_REFERENCE();
-
-extern 
-BOOST_ARCHIVE_DECL const char *
-BOOST_ARCHIVE_XML_CLASS_NAME();
-
-extern 
-BOOST_ARCHIVE_DECL const char *
-BOOST_ARCHIVE_XML_TRACKING();
-
-extern 
-BOOST_ARCHIVE_DECL const char *
-BOOST_ARCHIVE_XML_VERSION();
-
-extern 
-BOOST_ARCHIVE_DECL const char *
-BOOST_ARCHIVE_XML_SIGNATURE();
-
-}// namespace archive
-}// namespace boost
-
-#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
-
-#endif // BOOST_ARCHIVE_BASIC_XML_TEXT_ARCHIVE_HPP
-
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/basic_xml_iarchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/basic_xml_iarchive.hpp
deleted file mode 100644
index e9f7482f744..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/basic_xml_iarchive.hpp
+++ /dev/null
@@ -1,119 +0,0 @@
-#ifndef BOOST_ARCHIVE_BASIC_XML_IARCHIVE_HPP
-#define BOOST_ARCHIVE_BASIC_XML_IARCHIVE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// basic_xml_iarchive.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/config.hpp>
-#include <boost/mpl/assert.hpp>
-
-#include <boost/archive/detail/common_iarchive.hpp>
-#include <boost/serialization/nvp.hpp>
-#include <boost/serialization/string.hpp>
-
-#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
-
-#ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable : 4511 4512)
-#endif
-
-namespace boost {
-namespace archive {
-
-namespace detail {
-    template<class Archive> class interface_iarchive;
-} // namespace detail
-
-/////////////////////////////////////////////////////////////////////////
-// class basic_xml_iarchive - read serialized objects from a input text stream
-template<class Archive>
-class BOOST_SYMBOL_VISIBLE basic_xml_iarchive :
-    public detail::common_iarchive<Archive>
-{
-    unsigned int depth;
-#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
-public:
-#else
-protected:
-    friend class detail::interface_iarchive<Archive>;
-#endif
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-    load_start(const char *name);
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-    load_end(const char *name);
-
-    // Anything not an attribute and not a name-value pair is an
-    // should be trapped here.
-    template<class T>
-    void load_override(T & t)
-    {
-        // If your program fails to compile here, its most likely due to
-        // not specifying an nvp wrapper around the variable to
-        // be serialized.
-        BOOST_MPL_ASSERT((serialization::is_wrapper< T >));
-        this->detail_common_iarchive::load_override(t);
-    }
-
-    // Anything not an attribute - see below - should be a name value
-    // pair and be processed here
-    typedef detail::common_iarchive<Archive> detail_common_iarchive;
-    template<class T>
-    void load_override(
-        const boost::serialization::nvp< T > & t
-    ){
-        this->This()->load_start(t.name());
-        this->detail_common_iarchive::load_override(t.value());
-        this->This()->load_end(t.name());
-    }
-
-    // specific overrides for attributes - handle as
-    // primitives. These are not name-value pairs
-    // so they have to be intercepted here and passed on to load.
-    // although the class_id is included in the xml text file in order
-    // to make the file self describing, it isn't used when loading
-    // an xml archive.  So we can skip it here.  Note: we MUST override
-    // it otherwise it will be loaded as a normal primitive w/o tag and
-    // leaving the archive in an undetermined state
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-    load_override(class_id_type & t);
-    void load_override(class_id_optional_type & /* t */){}
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-    load_override(object_id_type & t);
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-    load_override(version_type & t);
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-    load_override(tracking_type & t);
-    // class_name_type can't be handled here as it depends upon the
-    // char type used by the stream.  So require the derived implementation
-    // handle this.
-    // void load_override(class_name_type & t);
-
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL
-    basic_xml_iarchive(unsigned int flags);
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL
-    ~basic_xml_iarchive();
-};
-
-} // namespace archive
-} // namespace boost
-
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
-
-#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
-
-#endif // BOOST_ARCHIVE_BASIC_XML_IARCHIVE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/basic_xml_oarchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/basic_xml_oarchive.hpp
deleted file mode 100644
index 107fca4ec65..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/basic_xml_oarchive.hpp
+++ /dev/null
@@ -1,138 +0,0 @@
-#ifndef BOOST_ARCHIVE_BASIC_XML_OARCHIVE_HPP
-#define BOOST_ARCHIVE_BASIC_XML_OARCHIVE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// basic_xml_oarchive.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/config.hpp>
-#include <boost/mpl/assert.hpp>
-
-#include <boost/archive/detail/common_oarchive.hpp>
-#include <boost/serialization/nvp.hpp>
-#include <boost/serialization/string.hpp>
-
-#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
-
-#ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable : 4511 4512)
-#endif
-
-namespace boost {
-namespace archive {
-
-namespace detail {
-    template<class Archive> class interface_oarchive;
-} // namespace detail
-
-//////////////////////////////////////////////////////////////////////
-// class basic_xml_oarchive - write serialized objects to a xml output stream
-template<class Archive>
-class BOOST_SYMBOL_VISIBLE basic_xml_oarchive :
-    public detail::common_oarchive<Archive>
-{
-    // special stuff for xml output
-    unsigned int depth;
-    bool pending_preamble;
-#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
-public:
-#else
-protected:
-    friend class detail::interface_oarchive<Archive>;
-#endif
-    bool indent_next;
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-    indent();
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-    init();
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-    windup();
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-    write_attribute(
-        const char *attribute_name,
-        int t,
-        const char *conjunction = "=\""
-    );
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-    write_attribute(
-        const char *attribute_name,
-        const char *key
-    );
-    // helpers used below
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-    save_start(const char *name);
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-    save_end(const char *name);
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-    end_preamble();
-
-    // Anything not an attribute and not a name-value pair is an
-    // error and should be trapped here.
-    template<class T>
-    void save_override(T & t)
-    {
-        // If your program fails to compile here, its most likely due to
-        // not specifying an nvp wrapper around the variable to
-        // be serialized.
-        BOOST_MPL_ASSERT((serialization::is_wrapper< T >));
-        this->detail_common_oarchive::save_override(t);
-    }
-
-    // special treatment for name-value pairs.
-    typedef detail::common_oarchive<Archive> detail_common_oarchive;
-    template<class T>
-    void save_override(
-        const ::boost::serialization::nvp< T > & t
-    ){
-        this->This()->save_start(t.name());
-        this->detail_common_oarchive::save_override(t.const_value());
-        this->This()->save_end(t.name());
-    }
-
-    // specific overrides for attributes - not name value pairs so we
-    // want to trap them before the above "fall through"
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-    save_override(const class_id_type & t);
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-    save_override(const class_id_optional_type & t);
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-    save_override(const class_id_reference_type & t);
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-    save_override(const object_id_type & t);
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-    save_override(const object_reference_type & t);
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-    save_override(const version_type & t);
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-    save_override(const class_name_type & t);
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-    save_override(const tracking_type & t);
-
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL
-    basic_xml_oarchive(unsigned int flags);
-    BOOST_ARCHIVE_OR_WARCHIVE_DECL
-    ~basic_xml_oarchive();
-};
-
-} // namespace archive
-} // namespace boost
-
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
-
-#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
-
-#endif // BOOST_ARCHIVE_BASIC_XML_OARCHIVE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/binary_iarchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/binary_iarchive.hpp
deleted file mode 100644
index 785ce7610b1..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/binary_iarchive.hpp
+++ /dev/null
@@ -1,64 +0,0 @@
-#ifndef BOOST_ARCHIVE_BINARY_IARCHIVE_HPP
-#define BOOST_ARCHIVE_BINARY_IARCHIVE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// binary_iarchive.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <istream>
-#include <boost/archive/binary_iarchive_impl.hpp>
-#include <boost/archive/detail/register_archive.hpp>
-
-#ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable : 4511 4512)
-#endif
-
-namespace boost {
-namespace archive {
-
-// do not derive from this class.  If you want to extend this functionality
-// via inhertance, derived from binary_iarchive_impl instead.  This will
-// preserve correct static polymorphism.
-class BOOST_SYMBOL_VISIBLE binary_iarchive :
-    public binary_iarchive_impl<
-        boost::archive::binary_iarchive, 
-        std::istream::char_type, 
-        std::istream::traits_type
-    >{
-public:
-    binary_iarchive(std::istream & is, unsigned int flags = 0) :
-        binary_iarchive_impl<
-            binary_iarchive, std::istream::char_type, std::istream::traits_type
-        >(is, flags)
-    {}
-    binary_iarchive(std::streambuf & bsb, unsigned int flags = 0) :
-        binary_iarchive_impl<
-            binary_iarchive, std::istream::char_type, std::istream::traits_type
-        >(bsb, flags)
-    {}
-};
-
-} // namespace archive
-} // namespace boost
-
-// required by export
-BOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::binary_iarchive)
-BOOST_SERIALIZATION_USE_ARRAY_OPTIMIZATION(boost::archive::binary_iarchive)
-
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
-
-#endif // BOOST_ARCHIVE_BINARY_IARCHIVE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/binary_iarchive_impl.hpp b/contrib/libboost/boost_1_65_0/boost/archive/binary_iarchive_impl.hpp
deleted file mode 100644
index b4747c98ece..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/binary_iarchive_impl.hpp
+++ /dev/null
@@ -1,105 +0,0 @@
-#ifndef BOOST_ARCHIVE_BINARY_IARCHIVE_IMPL_HPP
-#define BOOST_ARCHIVE_BINARY_IARCHIVE_IMPL_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// binary_iarchive_impl.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <istream>
-#include <boost/archive/basic_binary_iprimitive.hpp>
-#include <boost/archive/basic_binary_iarchive.hpp>
-
-#ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable : 4511 4512)
-#endif
-
-namespace boost { 
-namespace archive {
-
-namespace detail {
-    template<class Archive> class interface_iarchive;
-} // namespace detail
-
-template<class Archive, class Elem, class Tr>
-class BOOST_SYMBOL_VISIBLE binary_iarchive_impl : 
-    public basic_binary_iprimitive<Archive, Elem, Tr>,
-    public basic_binary_iarchive<Archive>
-{
-#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
-public:
-#else
-protected:
-    #if BOOST_WORKAROUND(BOOST_MSVC, < 1500)
-        // for some inexplicable reason insertion of "class" generates compile erro
-        // on msvc 7.1
-        friend detail::interface_iarchive<Archive>;
-        friend basic_binary_iarchive<Archive>;
-        friend load_access;
-    #else
-        friend class detail::interface_iarchive<Archive>;
-        friend class basic_binary_iarchive<Archive>;
-        friend class load_access;
-    #endif
-#endif
-    template<class T>
-    void load_override(T & t){
-        this->basic_binary_iarchive<Archive>::load_override(t);
-    }
-    void init(unsigned int flags){
-        if(0 != (flags & no_header)){
-            return;
-        }
-        #if ! defined(__MWERKS__)
-            this->basic_binary_iarchive<Archive>::init();
-            this->basic_binary_iprimitive<Archive, Elem, Tr>::init();
-        #else
-            basic_binary_iarchive<Archive>::init();
-            basic_binary_iprimitive<Archive, Elem, Tr>::init();
-        #endif
-    }
-    binary_iarchive_impl(
-        std::basic_streambuf<Elem, Tr> & bsb, 
-        unsigned int flags
-    ) :
-        basic_binary_iprimitive<Archive, Elem, Tr>(
-            bsb, 
-            0 != (flags & no_codecvt)
-        ),
-        basic_binary_iarchive<Archive>(flags)
-    {
-        init(flags);
-    }
-    binary_iarchive_impl(
-        std::basic_istream<Elem, Tr> & is, 
-        unsigned int flags
-    ) :
-        basic_binary_iprimitive<Archive, Elem, Tr>(
-            * is.rdbuf(), 
-            0 != (flags & no_codecvt)
-        ),
-        basic_binary_iarchive<Archive>(flags)
-    {
-        init(flags);
-    }
-};
-
-} // namespace archive
-} // namespace boost
-
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
-
-#endif // BOOST_ARCHIVE_BINARY_IARCHIVE_IMPL_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/binary_oarchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/binary_oarchive.hpp
deleted file mode 100644
index e8313fd7c95..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/binary_oarchive.hpp
+++ /dev/null
@@ -1,64 +0,0 @@
-#ifndef BOOST_ARCHIVE_BINARY_OARCHIVE_HPP
-#define BOOST_ARCHIVE_BINARY_OARCHIVE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// binary_oarchive.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <ostream>
-#include <boost/config.hpp>
-#include <boost/archive/binary_oarchive_impl.hpp>
-#include <boost/archive/detail/register_archive.hpp>
-
-#ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable : 4511 4512)
-#endif
-
-namespace boost { 
-namespace archive {
-
-// do not derive from this class.  If you want to extend this functionality
-// via inhertance, derived from binary_oarchive_impl instead.  This will
-// preserve correct static polymorphism.
-class BOOST_SYMBOL_VISIBLE binary_oarchive : 
-    public binary_oarchive_impl<
-        binary_oarchive, std::ostream::char_type, std::ostream::traits_type
-    >
-{
-public:
-    binary_oarchive(std::ostream & os, unsigned int flags = 0) :
-        binary_oarchive_impl<
-            binary_oarchive, std::ostream::char_type, std::ostream::traits_type
-        >(os, flags)
-    {}
-    binary_oarchive(std::streambuf & bsb, unsigned int flags = 0) :
-        binary_oarchive_impl<
-            binary_oarchive, std::ostream::char_type, std::ostream::traits_type
-        >(bsb, flags)
-    {}
-};
-
-} // namespace archive
-} // namespace boost
-
-// required by export
-BOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::binary_oarchive)
-BOOST_SERIALIZATION_USE_ARRAY_OPTIMIZATION(boost::archive::binary_oarchive)
-
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
-
-#endif // BOOST_ARCHIVE_BINARY_OARCHIVE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/binary_oarchive_impl.hpp b/contrib/libboost/boost_1_65_0/boost/archive/binary_oarchive_impl.hpp
deleted file mode 100644
index 6b4d018a564..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/binary_oarchive_impl.hpp
+++ /dev/null
@@ -1,106 +0,0 @@
-#ifndef BOOST_ARCHIVE_BINARY_OARCHIVE_IMPL_HPP
-#define BOOST_ARCHIVE_BINARY_OARCHIVE_IMPL_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// binary_oarchive_impl.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <ostream>
-#include <boost/config.hpp>
-#include <boost/archive/basic_binary_oprimitive.hpp>
-#include <boost/archive/basic_binary_oarchive.hpp>
-
-#ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable : 4511 4512)
-#endif
-
-namespace boost { 
-namespace archive {
-
-namespace detail {
-    template<class Archive> class interface_oarchive;
-} // namespace detail
-
-template<class Archive, class Elem, class Tr>
-class BOOST_SYMBOL_VISIBLE binary_oarchive_impl : 
-    public basic_binary_oprimitive<Archive, Elem, Tr>,
-    public basic_binary_oarchive<Archive>
-{
-#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
-public:
-#else
-protected:
-    #if BOOST_WORKAROUND(BOOST_MSVC, < 1500)
-        // for some inexplicable reason insertion of "class" generates compile erro
-        // on msvc 7.1
-        friend detail::interface_oarchive<Archive>;
-        friend basic_binary_oarchive<Archive>;
-        friend save_access;
-    #else
-        friend class detail::interface_oarchive<Archive>;
-        friend class basic_binary_oarchive<Archive>;
-        friend class save_access;
-    #endif
-#endif
-    template<class T>
-    void save_override(T & t){
-        this->basic_binary_oarchive<Archive>::save_override(t);
-    }
-    void init(unsigned int flags) {
-        if(0 != (flags & no_header)){
-            return;
-        }
-        #if ! defined(__MWERKS__)
-            this->basic_binary_oarchive<Archive>::init();
-            this->basic_binary_oprimitive<Archive, Elem, Tr>::init();
-        #else
-            basic_binary_oarchive<Archive>::init();
-            basic_binary_oprimitive<Archive, Elem, Tr>::init();
-        #endif
-    }
-    binary_oarchive_impl(
-        std::basic_streambuf<Elem, Tr> & bsb, 
-        unsigned int flags
-    ) :
-        basic_binary_oprimitive<Archive, Elem, Tr>(
-            bsb, 
-            0 != (flags & no_codecvt)
-        ),
-        basic_binary_oarchive<Archive>(flags)
-    {
-        init(flags);
-    }
-    binary_oarchive_impl(
-        std::basic_ostream<Elem, Tr> & os, 
-        unsigned int flags
-    ) :
-        basic_binary_oprimitive<Archive, Elem, Tr>(
-            * os.rdbuf(), 
-            0 != (flags & no_codecvt)
-        ),
-        basic_binary_oarchive<Archive>(flags)
-    {
-        init(flags);
-    }
-};
-
-} // namespace archive
-} // namespace boost
-
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
-
-#endif // BOOST_ARCHIVE_BINARY_OARCHIVE_IMPL_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/binary_wiarchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/binary_wiarchive.hpp
deleted file mode 100644
index 775d8f82726..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/binary_wiarchive.hpp
+++ /dev/null
@@ -1,56 +0,0 @@
-#ifndef BOOST_ARCHIVE_BINARY_WIARCHIVE_HPP
-#define BOOST_ARCHIVE_BINARY_WIARCHIVE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// binary_wiarchive.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/config.hpp>
-#ifdef BOOST_NO_STD_WSTREAMBUF
-#error "wide char i/o not supported on this platform"
-#else
-
-#include <istream> // wistream
-#include <boost/archive/binary_iarchive_impl.hpp>
-#include <boost/archive/detail/register_archive.hpp>
-
-namespace boost { 
-namespace archive {
-
-class binary_wiarchive : 
-    public binary_iarchive_impl<
-        binary_wiarchive, std::wistream::char_type, std::wistream::traits_type
-    >
-{
-public:
-    binary_wiarchive(std::wistream & is, unsigned int flags = 0) :
-        binary_iarchive_impl<
-            binary_wiarchive, std::wistream::char_type, std::wistream::traits_type
-        >(is, flags)
-    {}
-    binary_wiarchive(std::wstreambuf & bsb, unsigned int flags = 0) :
-        binary_iarchive_impl<
-            binary_wiarchive, std::wistream::char_type, std::wistream::traits_type
-        >(bsb, flags)
-    {}
-};
-
-} // namespace archive
-} // namespace boost
-
-// required by export
-BOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::binary_wiarchive)
-
-#endif // BOOST_NO_STD_WSTREAMBUF
-#endif // BOOST_ARCHIVE_BINARY_WIARCHIVE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/binary_woarchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/binary_woarchive.hpp
deleted file mode 100644
index a8817d6f8b4..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/binary_woarchive.hpp
+++ /dev/null
@@ -1,59 +0,0 @@
-#ifndef BOOST_ARCHIVE_BINARY_WOARCHIVE_HPP
-#define BOOST_ARCHIVE_BINARY_WOARCHIVE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// binary_woarchive.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/config.hpp>
-#ifdef BOOST_NO_STD_WSTREAMBUF
-#error "wide char i/o not supported on this platform"
-#else
-
-#include <ostream>
-#include <boost/archive/binary_oarchive_impl.hpp>
-#include <boost/archive/detail/register_archive.hpp>
-
-namespace boost { 
-namespace archive {
-
-// do not derive from this class.  If you want to extend this functionality
-// via inhertance, derived from binary_oarchive_impl instead.  This will
-// preserve correct static polymorphism.
-class binary_woarchive : 
-    public binary_oarchive_impl<
-            binary_woarchive, std::wostream::char_type, std::wostream::traits_type
-        >
-{
-public:
-    binary_woarchive(std::wostream & os, unsigned int flags = 0) :
-        binary_oarchive_impl<
-            binary_woarchive, std::wostream::char_type, std::wostream::traits_type
-        >(os, flags)
-    {}
-    binary_woarchive(std::wstreambuf & bsb, unsigned int flags = 0) :
-        binary_oarchive_impl<
-            binary_woarchive, std::wostream::char_type, std::wostream::traits_type
-        >(bsb, flags)
-    {}
-};
-
-} // namespace archive
-} // namespace boost
-
-// required by export
-BOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::binary_woarchive)
-
-#endif // BOOST_NO_STD_WSTREAMBUF
-#endif // BOOST_ARCHIVE_BINARY_WOARCHIVE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/codecvt_null.hpp b/contrib/libboost/boost_1_65_0/boost/archive/codecvt_null.hpp
deleted file mode 100644
index 7bce2b9b329..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/codecvt_null.hpp
+++ /dev/null
@@ -1,109 +0,0 @@
-#ifndef BOOST_ARCHIVE_CODECVT_NULL_HPP
-#define BOOST_ARCHIVE_CODECVT_NULL_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// codecvt_null.hpp:
-
-// (C) Copyright 2004 Robert Ramey - http://www.rrsd.com .
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <locale>
-#include <cstddef> // NULL, size_t
-#ifndef BOOST_NO_CWCHAR
-#include <cwchar>   // for mbstate_t
-#endif
-#include <boost/config.hpp>
-#include <boost/serialization/force_include.hpp>
-#include <boost/archive/detail/auto_link_archive.hpp>
-#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
-
-#if defined(BOOST_NO_STDC_NAMESPACE)
-namespace std {
-// For STLport on WinCE, BOOST_NO_STDC_NAMESPACE can get defined if STLport is putting symbols in its own namespace.
-// In the case of codecvt, however, this does not mean that codecvt is in the global namespace (it will be in STLport's namespace)
-#  if !defined(__SGI_STL_PORT) && !defined(_STLPORT_VERSION)
-    using ::codecvt;
-#  endif
-    using ::mbstate_t;
-    using ::size_t;
-} // namespace
-#endif
-
-#ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable : 4511 4512)
-#endif
-
-namespace boost {
-namespace archive {
-
-template<class Ch>
-class codecvt_null;
-
-template<>
-class codecvt_null<char> : public std::codecvt<char, char, std::mbstate_t>
-{
-    virtual bool do_always_noconv() const throw() {
-        return true;
-    }
-public:
-    explicit codecvt_null(std::size_t no_locale_manage = 0) :
-        std::codecvt<char, char, std::mbstate_t>(no_locale_manage)
-    {}
-    virtual ~codecvt_null(){};
-};
-
-template<>
-class BOOST_SYMBOL_VISIBLE codecvt_null<wchar_t> : public std::codecvt<wchar_t, char, std::mbstate_t>
-{
-    virtual BOOST_WARCHIVE_DECL BOOST_DLLEXPORT std::codecvt_base::result
-    do_out(
-        std::mbstate_t & state,
-        const wchar_t * first1,
-        const wchar_t * last1,
-        const wchar_t * & next1,
-        char * first2,
-        char * last2,
-        char * & next2
-    ) const BOOST_USED;
-    virtual BOOST_WARCHIVE_DECL BOOST_DLLEXPORT std::codecvt_base::result
-    do_in(
-        std::mbstate_t & state,
-        const char * first1,
-        const char * last1,
-        const char * & next1,
-        wchar_t * first2,
-        wchar_t * last2,
-        wchar_t * & next2
-    ) const BOOST_USED;
-    virtual int do_encoding( ) const throw( ){
-        return sizeof(wchar_t) / sizeof(char);
-    }
-    virtual int do_max_length( ) const throw( ){
-        return do_encoding();
-    }
-public:
-    BOOST_DLLEXPORT explicit codecvt_null(std::size_t no_locale_manage = 0) :
-        std::codecvt<wchar_t, char, std::mbstate_t>(no_locale_manage)
-    {}
-    virtual ~codecvt_null(){};
-};
-
-} // namespace archive
-} // namespace boost
-
-#ifdef BOOST_MSVC
-#  pragma warning(pop)
-#endif
-#include <boost/archive/detail/abi_suffix.hpp> // pop pragmas
-
-#endif //BOOST_ARCHIVE_CODECVT_NULL_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/detail/abi_prefix.hpp b/contrib/libboost/boost_1_65_0/boost/archive/detail/abi_prefix.hpp
deleted file mode 100644
index debf79e9f0b..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/detail/abi_prefix.hpp
+++ /dev/null
@@ -1,16 +0,0 @@
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// abi_prefix.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/config/abi_prefix.hpp> // must be the last header
-#ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable : 4251 4231 4660 4275)
-#endif
-
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/detail/abi_suffix.hpp b/contrib/libboost/boost_1_65_0/boost/archive/detail/abi_suffix.hpp
deleted file mode 100644
index 4e054d66214..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/detail/abi_suffix.hpp
+++ /dev/null
@@ -1,15 +0,0 @@
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// abi_suffix.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
-#include <boost/config/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
-
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/detail/archive_serializer_map.hpp b/contrib/libboost/boost_1_65_0/boost/archive/detail/archive_serializer_map.hpp
deleted file mode 100644
index 5432bfc73e7..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/detail/archive_serializer_map.hpp
+++ /dev/null
@@ -1,54 +0,0 @@
-#ifndef BOOST_ARCHIVE_SERIALIZER_MAP_HPP
-#define BOOST_ARCHIVE_SERIALIZER_MAP_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// archive_serializer_map.hpp: extenstion of type_info required for 
-// serialization.
-
-// (C) Copyright 2009 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-// note: this is nothing more than the thinest of wrappers around
-// basic_serializer_map so we can have a one map / archive type. 
-
-#include <boost/config.hpp>
-#include <boost/archive/detail/auto_link_archive.hpp>
-#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
-
-namespace boost {
-
-namespace serialization {
-    class extended_type_info;
-} // namespace serialization
-
-namespace archive {
-namespace detail {
-
-class basic_serializer;
-
-template<class Archive>
-class BOOST_SYMBOL_VISIBLE archive_serializer_map {
-public:
-    static BOOST_ARCHIVE_OR_WARCHIVE_DECL bool insert(const basic_serializer * bs);
-    static BOOST_ARCHIVE_OR_WARCHIVE_DECL void erase(const basic_serializer * bs);
-    static BOOST_ARCHIVE_OR_WARCHIVE_DECL const basic_serializer * find(
-        const boost::serialization::extended_type_info & type_
-    );
-};
-
-} // namespace detail
-} // namespace archive
-} // namespace boost
-
-#include <boost/archive/detail/abi_suffix.hpp> // must be the last header
-
-#endif //BOOST_ARCHIVE_SERIALIZER_MAP_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/detail/auto_link_archive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/detail/auto_link_archive.hpp
deleted file mode 100644
index 79b0e490d65..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/detail/auto_link_archive.hpp
+++ /dev/null
@@ -1,48 +0,0 @@
-#ifndef BOOST_ARCHIVE_DETAIL_AUTO_LINK_ARCHIVE_HPP
-#define BOOST_ARCHIVE_DETAIL_AUTO_LINK_ARCHIVE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-//  auto_link_archive.hpp
-//
-//  (c) Copyright Robert Ramey 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)
-
-//  See library home page at http://www.boost.org/libs/serialization
-
-//----------------------------------------------------------------------------// 
-
-// This header implements separate compilation features as described in
-// http://www.boost.org/more/separate_compilation.html
-
-//  enable automatic library variant selection  ------------------------------// 
-
-#include <boost/archive/detail/decl.hpp>
-
-#if !defined(BOOST_ALL_NO_LIB) && !defined(BOOST_SERIALIZATION_NO_LIB) \
-&&  !defined(BOOST_ARCHIVE_SOURCE) && !defined(BOOST_WARCHIVE_SOURCE)  \
-&&  !defined(BOOST_SERIALIZATION_SOURCE)
-
-    // Set the name of our library, this will get undef'ed by auto_link.hpp
-    // once it's done with it:
-    //
-    #define BOOST_LIB_NAME boost_serialization
-    //
-    // If we're importing code from a dll, then tell auto_link.hpp about it:
-    //
-    #if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_SERIALIZATION_DYN_LINK)
-    #  define BOOST_DYN_LINK
-    #endif
-    //
-    // And include the header that does the work:
-    //
-    #include <boost/config/auto_link.hpp>
-#endif  // auto-linking disabled
-
-#endif // BOOST_ARCHIVE_DETAIL_AUTO_LINK_ARCHIVE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/detail/auto_link_warchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/detail/auto_link_warchive.hpp
deleted file mode 100644
index 683d191c20d..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/detail/auto_link_warchive.hpp
+++ /dev/null
@@ -1,47 +0,0 @@
-#ifndef BOOST_ARCHIVE_DETAIL_AUTO_LINK_WARCHIVE_HPP
-#define BOOST_ARCHIVE_DETAIL_AUTO_LINK_WARCHIVE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-//  auto_link_warchive.hpp
-//
-//  (c) Copyright Robert Ramey 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)
-
-//  See library home page at http://www.boost.org/libs/serialization
-
-//----------------------------------------------------------------------------// 
-
-// This header implements separate compilation features as described in
-// http://www.boost.org/more/separate_compilation.html
-
-//  enable automatic library variant selection  ------------------------------// 
-
-#include <boost/archive/detail/decl.hpp>
-
-#if !defined(BOOST_WARCHIVE_SOURCE) \
-&& !defined(BOOST_ALL_NO_LIB) && !defined(BOOST_SERIALIZATION_NO_LIB)
-
-// Set the name of our library, this will get undef'ed by auto_link.hpp
-// once it's done with it:
-//
-#define BOOST_LIB_NAME boost_wserialization
-//
-// If we're importing code from a dll, then tell auto_link.hpp about it:
-//
-#if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_SERIALIZATION_DYN_LINK)
-#  define BOOST_DYN_LINK
-#endif
-//
-// And include the header that does the work:
-//
-#include <boost/config/auto_link.hpp>
-#endif  // auto-linking disabled
-
-#endif // ARCHIVE_DETAIL_AUTO_LINK_ARCHIVE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/detail/basic_iarchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/detail/basic_iarchive.hpp
deleted file mode 100644
index 1f5a8bf63bf..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/detail/basic_iarchive.hpp
+++ /dev/null
@@ -1,105 +0,0 @@
-#ifndef BOOST_ARCHIVE_DETAIL_BASIC_IARCHIVE_HPP
-#define BOOST_ARCHIVE_DETAIL_BASIC_IARCHIVE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// basic_iarchive.hpp:
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-// can't use this - much as I'd like to as borland doesn't support it
-
-#include <boost/config.hpp>
-#include <boost/noncopyable.hpp>
-#include <boost/scoped_ptr.hpp>
-
-#include <boost/serialization/tracking_enum.hpp>
-#include <boost/archive/basic_archive.hpp>
-#include <boost/archive/detail/decl.hpp>
-#include <boost/archive/detail/helper_collection.hpp>
-#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
-
-namespace boost {
-namespace serialization {
-    class extended_type_info;
-} // namespace serialization
-
-namespace archive {
-namespace detail {
-
-class basic_iarchive_impl;
-class basic_iserializer;
-class basic_pointer_iserializer;
-
-//////////////////////////////////////////////////////////////////////
-// class basic_iarchive - read serialized objects from a input stream
-class BOOST_SYMBOL_VISIBLE basic_iarchive :
-    private boost::noncopyable,
-    public boost::archive::detail::helper_collection
-{
-    friend class basic_iarchive_impl;
-    // hide implementation of this class to minimize header conclusion
-    boost::scoped_ptr<basic_iarchive_impl> pimpl;
-
-    virtual void vload(version_type &t) =  0;
-    virtual void vload(object_id_type &t) =  0;
-    virtual void vload(class_id_type &t) =  0;
-    virtual void vload(class_id_optional_type &t) = 0;
-    virtual void vload(class_name_type &t) = 0;
-    virtual void vload(tracking_type &t) = 0;
-protected:
-    BOOST_ARCHIVE_DECL basic_iarchive(unsigned int flags);
-    boost::archive::detail::helper_collection &
-    get_helper_collection(){
-        return *this;
-    }
-public:
-    // some msvc versions require that the following function be public
-    // otherwise it should really protected.
-    virtual BOOST_ARCHIVE_DECL ~basic_iarchive();
-    // note: NOT part of the public API.
-    BOOST_ARCHIVE_DECL void next_object_pointer(void *t);
-    BOOST_ARCHIVE_DECL void register_basic_serializer(
-        const basic_iserializer & bis
-    );
-    BOOST_ARCHIVE_DECL void load_object(
-        void *t, 
-        const basic_iserializer & bis
-    );
-    BOOST_ARCHIVE_DECL const basic_pointer_iserializer * 
-    load_pointer(
-        void * & t, 
-        const basic_pointer_iserializer * bpis_ptr,
-        const basic_pointer_iserializer * (*finder)(
-            const boost::serialization::extended_type_info & eti
-        )
-    );
-    // real public API starts here
-    BOOST_ARCHIVE_DECL void 
-    set_library_version(library_version_type archive_library_version);
-    BOOST_ARCHIVE_DECL library_version_type 
-    get_library_version() const;
-    BOOST_ARCHIVE_DECL unsigned int
-    get_flags() const;
-    BOOST_ARCHIVE_DECL void 
-    reset_object_address(const void * new_address, const void * old_address);
-    BOOST_ARCHIVE_DECL void 
-    delete_created_pointers();
-};
-
-} // namespace detail
-} // namespace archive
-} // namespace boost
-
-#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
-
-#endif //BOOST_ARCHIVE_DETAIL_BASIC_IARCHIVE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/detail/basic_iserializer.hpp b/contrib/libboost/boost_1_65_0/boost/archive/detail/basic_iserializer.hpp
deleted file mode 100644
index 0d66674c349..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/detail/basic_iserializer.hpp
+++ /dev/null
@@ -1,91 +0,0 @@
-#ifndef BOOST_ARCHIVE_DETAIL_BASIC_ISERIALIZER_HPP
-#define BOOST_ARCHIVE_DETAIL_BASIC_ISERIALIZER_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// basic_iserializer.hpp: extenstion of type_info required for serialization.
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <cstdlib> // NULL
-#include <boost/config.hpp>
-
-#include <boost/archive/basic_archive.hpp>
-#include <boost/archive/detail/decl.hpp>
-#include <boost/archive/detail/basic_serializer.hpp>
-#include <boost/archive/detail/auto_link_archive.hpp>
-#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
-
-#ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable : 4511 4512)
-#endif
-
-namespace boost {
-namespace serialization {
-    class extended_type_info;
-} // namespace serialization
-
-// forward declarations
-namespace archive {
-namespace detail {
-
-class basic_iarchive;
-class basic_pointer_iserializer;
-
-class BOOST_SYMBOL_VISIBLE basic_iserializer : 
-    public basic_serializer
-{
-private:
-    basic_pointer_iserializer *m_bpis;
-protected:
-    explicit BOOST_ARCHIVE_DECL basic_iserializer(
-        const boost::serialization::extended_type_info & type
-    );
-    virtual BOOST_ARCHIVE_DECL ~basic_iserializer();
-public:
-    bool serialized_as_pointer() const {
-        return m_bpis != NULL;
-    }
-    void set_bpis(basic_pointer_iserializer *bpis){
-        m_bpis = bpis;
-    }
-    const basic_pointer_iserializer * get_bpis_ptr() const {
-        return m_bpis;
-    }
-    virtual void load_object_data(
-        basic_iarchive & ar, 
-        void *x,
-        const unsigned int file_version
-    ) const = 0;
-    // returns true if class_info should be saved
-    virtual bool class_info() const = 0 ;
-    // returns true if objects should be tracked
-    virtual bool tracking(const unsigned int) const = 0 ;
-    // returns class version
-    virtual version_type version() const = 0 ;
-    // returns true if this class is polymorphic
-    virtual bool is_polymorphic() const = 0;
-    virtual void destroy(/*const*/ void *address) const = 0 ;
-};
-
-} // namespae detail
-} // namespace archive
-} // namespace boost
-
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
-
-#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
-
-#endif // BOOST_ARCHIVE_DETAIL_BASIC_ISERIALIZER_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/detail/basic_oarchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/detail/basic_oarchive.hpp
deleted file mode 100644
index c379108d584..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/detail/basic_oarchive.hpp
+++ /dev/null
@@ -1,94 +0,0 @@
-#ifndef BOOST_ARCHIVE_BASIC_OARCHIVE_HPP
-#define BOOST_ARCHIVE_BASIC_OARCHIVE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// basic_oarchive.hpp:
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <cstddef> // NULL
-#include <boost/config.hpp>
-#include <boost/noncopyable.hpp>
-#include <boost/scoped_ptr.hpp>
-
-#include <boost/archive/basic_archive.hpp>
-#include <boost/serialization/tracking_enum.hpp>
-#include <boost/archive/detail/helper_collection.hpp>
-#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
-
-namespace boost {
-namespace serialization {
-    class extended_type_info;
-} // namespace serialization
-
-namespace archive {
-namespace detail {
-
-class basic_oarchive_impl;
-class basic_oserializer;
-class basic_pointer_oserializer;
-
-//////////////////////////////////////////////////////////////////////
-// class basic_oarchive - write serialized objects to an output stream
-class BOOST_SYMBOL_VISIBLE basic_oarchive :
-    private boost::noncopyable,
-    public boost::archive::detail::helper_collection
-{
-    friend class basic_oarchive_impl;
-    // hide implementation of this class to minimize header conclusion
-    boost::scoped_ptr<basic_oarchive_impl> pimpl;
-
-    // overload these to bracket object attributes. Used to implement
-    // xml archives
-    virtual void vsave(const version_type t) =  0;
-    virtual void vsave(const object_id_type t) =  0;
-    virtual void vsave(const object_reference_type t) =  0;
-    virtual void vsave(const class_id_type t) =  0;
-    virtual void vsave(const class_id_optional_type t) = 0;
-    virtual void vsave(const class_id_reference_type t) =  0;
-    virtual void vsave(const class_name_type & t) = 0;
-    virtual void vsave(const tracking_type t) = 0;
-protected:
-    BOOST_ARCHIVE_DECL basic_oarchive(unsigned int flags = 0);
-    BOOST_ARCHIVE_DECL boost::archive::detail::helper_collection &
-    get_helper_collection();
-    virtual BOOST_ARCHIVE_DECL ~basic_oarchive();
-public:
-    // note: NOT part of the public interface
-    BOOST_ARCHIVE_DECL void register_basic_serializer(
-        const basic_oserializer & bos
-    );
-    BOOST_ARCHIVE_DECL void save_object(
-        const void *x, 
-        const basic_oserializer & bos
-    );
-    BOOST_ARCHIVE_DECL void save_pointer(
-        const void * t, 
-        const basic_pointer_oserializer * bpos_ptr
-    );
-    void save_null_pointer(){
-        vsave(NULL_POINTER_TAG);
-    }
-    // real public interface starts here
-    BOOST_ARCHIVE_DECL void end_preamble(); // default implementation does nothing
-    BOOST_ARCHIVE_DECL library_version_type get_library_version() const;
-    BOOST_ARCHIVE_DECL unsigned int get_flags() const;
-};
-
-} // namespace detail
-} // namespace archive
-} // namespace boost
-
-#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
-
-#endif //BOOST_ARCHIVE_BASIC_OARCHIVE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/detail/basic_oserializer.hpp b/contrib/libboost/boost_1_65_0/boost/archive/detail/basic_oserializer.hpp
deleted file mode 100644
index 94247e90056..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/detail/basic_oserializer.hpp
+++ /dev/null
@@ -1,89 +0,0 @@
-#ifndef BOOST_SERIALIZATION_BASIC_OSERIALIZER_HPP
-#define BOOST_SERIALIZATION_BASIC_OSERIALIZER_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// basic_oserializer.hpp: extenstion of type_info required for serialization.
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <cstddef> // NULL
-#include <boost/config.hpp>
-#include <boost/noncopyable.hpp>
-
-#include <boost/archive/basic_archive.hpp>
-#include <boost/archive/detail/auto_link_archive.hpp>
-#include <boost/archive/detail/basic_serializer.hpp>
-
-#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
-
-#ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable : 4511 4512)
-#endif
-
-namespace boost {
-namespace serialization {
-    class extended_type_info;
-} // namespace serialization
-
-// forward declarations
-namespace archive {
-namespace detail {
-
-class basic_oarchive;
-class basic_pointer_oserializer;
-
-class BOOST_SYMBOL_VISIBLE basic_oserializer :
-    public basic_serializer
-{
-private:
-    basic_pointer_oserializer *m_bpos;
-protected:
-    explicit BOOST_ARCHIVE_DECL basic_oserializer(
-        const boost::serialization::extended_type_info & type_
-    );
-    virtual BOOST_ARCHIVE_DECL ~basic_oserializer();
-public:
-    bool serialized_as_pointer() const {
-        return m_bpos != NULL;
-    }
-    void set_bpos(basic_pointer_oserializer *bpos){
-        m_bpos = bpos;
-    }
-    const basic_pointer_oserializer * get_bpos() const {
-        return m_bpos;
-    }
-    virtual void save_object_data(
-        basic_oarchive & ar, const void * x
-    ) const = 0;
-    // returns true if class_info should be saved
-    virtual bool class_info() const = 0;
-    // returns true if objects should be tracked
-    virtual bool tracking(const unsigned int flags) const = 0;
-    // returns class version
-    virtual version_type version() const = 0;
-    // returns true if this class is polymorphic
-    virtual bool is_polymorphic() const = 0;
-};
-
-} // namespace detail
-} // namespace serialization
-} // namespace boost
-
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
-
-#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
-
-#endif // BOOST_SERIALIZATION_BASIC_OSERIALIZER_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/detail/basic_pointer_iserializer.hpp b/contrib/libboost/boost_1_65_0/boost/archive/detail/basic_pointer_iserializer.hpp
deleted file mode 100644
index 1fc4b14d6e9..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/detail/basic_pointer_iserializer.hpp
+++ /dev/null
@@ -1,70 +0,0 @@
-#ifndef BOOST_ARCHIVE_BASIC_POINTER_ISERIALIZER_HPP
-#define BOOST_ARCHIVE_BASIC_POINTER_ISERIALIZER_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// basic_pointer_oserializer.hpp: extenstion of type_info required for 
-// serialization.
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-#include <boost/config.hpp>
-#include <boost/noncopyable.hpp>
-#include <boost/archive/detail/auto_link_archive.hpp>
-#include <boost/archive/detail/basic_serializer.hpp>
-
-#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
-
-#ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable : 4511 4512)
-#endif
-
-namespace boost {
-namespace serialization {
-    class extended_type_info;
-} // namespace serialization
-
-// forward declarations
-namespace archive {
-namespace detail {
-
-class basic_iarchive;
-class basic_iserializer;
-
-class BOOST_SYMBOL_VISIBLE basic_pointer_iserializer
-    : public basic_serializer {
-protected:
-    explicit BOOST_ARCHIVE_DECL basic_pointer_iserializer(
-        const boost::serialization::extended_type_info & type_
-    );
-    virtual BOOST_ARCHIVE_DECL ~basic_pointer_iserializer();
-public:
-    virtual void * heap_allocation() const = 0;
-    virtual const basic_iserializer & get_basic_serializer() const = 0;
-    virtual void load_object_ptr(
-        basic_iarchive & ar, 
-        void * x,
-        const unsigned int file_version
-    ) const = 0;
-};
-
-} // namespace detail
-} // namespace archive
-} // namespace boost
-
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
-
-#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
-
-#endif // BOOST_ARCHIVE_BASIC_POINTER_ISERIALIZER_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/detail/basic_pointer_oserializer.hpp b/contrib/libboost/boost_1_65_0/boost/archive/detail/basic_pointer_oserializer.hpp
deleted file mode 100644
index 1a5d9549eab..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/detail/basic_pointer_oserializer.hpp
+++ /dev/null
@@ -1,68 +0,0 @@
-#ifndef BOOST_ARCHIVE_BASIC_POINTER_OSERIALIZER_HPP
-#define BOOST_ARCHIVE_BASIC_POINTER_OSERIALIZER_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// basic_pointer_oserializer.hpp: extenstion of type_info required for 
-// serialization.
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-#include <boost/config.hpp>
-#include <boost/noncopyable.hpp>
-#include <boost/archive/detail/auto_link_archive.hpp>
-#include <boost/archive/detail/basic_serializer.hpp>
-
-#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
-
-#ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable : 4511 4512)
-#endif
-
-namespace boost {
-namespace serialization {
-    class extended_type_info;
-} // namespace serialization
-
-namespace archive {
-namespace detail {
-
-class basic_oarchive;
-class basic_oserializer;
-
-class BOOST_SYMBOL_VISIBLE basic_pointer_oserializer : 
-    public basic_serializer
-{
-protected:
-    explicit BOOST_ARCHIVE_DECL basic_pointer_oserializer(
-        const boost::serialization::extended_type_info & type_
-    );
-public:
-    virtual BOOST_ARCHIVE_DECL ~basic_pointer_oserializer();
-    virtual const basic_oserializer & get_basic_serializer() const = 0;
-    virtual void save_object_ptr(
-        basic_oarchive & ar,
-        const void * x
-    ) const = 0;
-};
-
-} // namespace detail
-} // namespace archive
-} // namespace boost
-
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
-
-#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
-
-#endif // BOOST_ARCHIVE_BASIC_POINTER_OSERIALIZER_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/detail/basic_serializer.hpp b/contrib/libboost/boost_1_65_0/boost/archive/detail/basic_serializer.hpp
deleted file mode 100644
index f9c4203f862..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/detail/basic_serializer.hpp
+++ /dev/null
@@ -1,77 +0,0 @@
-#ifndef  BOOST_ARCHIVE_BASIC_SERIALIZER_HPP
-#define BOOST_ARCHIVE_BASIC_SERIALIZER_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// basic_serializer.hpp: extenstion of type_info required for serialization.
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/assert.hpp>
-#include <cstddef> // NULL
-
-#include <boost/noncopyable.hpp>
-#include <boost/config.hpp>
-#include <boost/serialization/extended_type_info.hpp>
-
-#ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable : 4511 4512)
-#endif
-
-namespace boost {
-namespace archive {
-namespace detail {
-
-class basic_serializer : 
-    private boost::noncopyable
-{
-    const boost::serialization::extended_type_info * m_eti;
-protected:
-    explicit basic_serializer(
-        const boost::serialization::extended_type_info & eti
-    ) : 
-        m_eti(& eti)
-    {}
-public:
-    inline bool 
-    operator<(const basic_serializer & rhs) const {
-        // can't compare address since there can be multiple eti records
-        // for the same type in different execution modules (that is, DLLS)
-        // leave this here as a reminder not to do this!
-        // return & lhs.get_eti() < & rhs.get_eti();
-        return get_eti() < rhs.get_eti();
-    }
-    const char * get_debug_info() const {
-        return m_eti->get_debug_info();
-    }
-    const boost::serialization::extended_type_info & get_eti() const {
-        return * m_eti;
-    }
-};
-
-class basic_serializer_arg : public basic_serializer {
-public:
-    basic_serializer_arg(const serialization::extended_type_info & eti) :
-        basic_serializer(eti)
-    {}
-};
-
-} // namespace detail
-} // namespace archive
-} // namespace boost
-
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
-
-#endif // BOOST_ARCHIVE_BASIC_SERIALIZER_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/detail/basic_serializer_map.hpp b/contrib/libboost/boost_1_65_0/boost/archive/detail/basic_serializer_map.hpp
deleted file mode 100644
index 79341803367..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/detail/basic_serializer_map.hpp
+++ /dev/null
@@ -1,69 +0,0 @@
-#ifndef  BOOST_SERIALIZER_MAP_HPP
-#define BOOST_SERIALIZER_MAP_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// basic_serializer_map.hpp: extenstion of type_info required for serialization.
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <set>
-
-#include <boost/config.hpp>
-#include <boost/noncopyable.hpp>
-#include <boost/archive/detail/auto_link_archive.hpp>
-
-#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
-
-namespace boost { 
-namespace serialization {
-    class extended_type_info;
-}
-
-namespace archive {
-namespace detail {
-
-class basic_serializer;
-
-class BOOST_SYMBOL_VISIBLE
-basic_serializer_map : public
-    boost::noncopyable
-{
-    struct type_info_pointer_compare
-    {
-        bool operator()(
-            const basic_serializer * lhs, const basic_serializer * rhs
-        ) const ;
-    };
-    typedef std::set<
-        const basic_serializer *, 
-        type_info_pointer_compare
-    > map_type;
-    map_type m_map;
-public:
-    BOOST_ARCHIVE_DECL bool insert(const basic_serializer * bs);
-    BOOST_ARCHIVE_DECL void erase(const basic_serializer * bs);
-    BOOST_ARCHIVE_DECL const basic_serializer * find(
-        const boost::serialization::extended_type_info & type_
-    ) const;
-private:
-    // cw 8.3 requires this
-    basic_serializer_map& operator=(basic_serializer_map const&);
-};
-
-} // namespace detail
-} // namespace archive
-} // namespace boost
-
-#include <boost/archive/detail/abi_suffix.hpp> // must be the last header
-
-#endif // BOOST_SERIALIZER_MAP_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/detail/check.hpp b/contrib/libboost/boost_1_65_0/boost/archive/detail/check.hpp
deleted file mode 100644
index 10034e7d101..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/detail/check.hpp
+++ /dev/null
@@ -1,169 +0,0 @@
-#ifndef BOOST_ARCHIVE_DETAIL_CHECK_HPP
-#define BOOST_ARCHIVE_DETAIL_CHECK_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#pragma inline_depth(511)
-#pragma inline_recursion(on)
-#endif
-
-#if defined(__MWERKS__)
-#pragma inline_depth(511)
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// check.hpp: interface for serialization system.
-
-// (C) Copyright 2009 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/config.hpp>
-
-#include <boost/static_assert.hpp>
-#include <boost/type_traits/is_const.hpp>
-
-#include <boost/mpl/eval_if.hpp>
-#include <boost/mpl/or.hpp>
-#include <boost/mpl/equal_to.hpp>
-#include <boost/mpl/int.hpp>
-#include <boost/mpl/not.hpp>
-#include <boost/mpl/greater.hpp>
-#include <boost/mpl/assert.hpp>
-
-#include <boost/serialization/static_warning.hpp>
-#include <boost/serialization/version.hpp>
-#include <boost/serialization/level.hpp>
-#include <boost/serialization/tracking.hpp>
-#include <boost/serialization/wrapper.hpp>
-
-namespace boost {
-namespace archive {
-namespace detail {
-
-// checks for objects
-
-template<class T>
-inline void check_object_level(){
-    typedef 
-        typename mpl::greater_equal<
-            serialization::implementation_level< T >,
-            mpl::int_<serialization::primitive_type>
-        >::type typex;
-
-    // trap attempts to serialize objects marked
-    // not_serializable
-    BOOST_STATIC_ASSERT(typex::value);
-}
-
-template<class T>
-inline void check_object_versioning(){
-    typedef 
-        typename mpl::or_<
-            typename mpl::greater<
-                serialization::implementation_level< T >,
-                mpl::int_<serialization::object_serializable>
-            >,
-            typename mpl::equal_to<
-                serialization::version< T >,
-                mpl::int_<0>
-            >
-        > typex;
-    // trap attempts to serialize with objects that don't
-    // save class information in the archive with versioning.
-    BOOST_STATIC_ASSERT(typex::value);
-}
-
-template<class T>
-inline void check_object_tracking(){
-    // presume it has already been determined that
-    // T is not a const
-    BOOST_STATIC_ASSERT(! boost::is_const< T >::value);
-    typedef typename mpl::equal_to<
-        serialization::tracking_level< T >,
-        mpl::int_<serialization::track_never>
-    >::type typex;
-    // saving an non-const object of a type not marked "track_never)
-
-    // may be an indicator of an error usage of the
-    // serialization library and should be double checked.  
-    // See documentation on object tracking.  Also, see the 
-    // "rationale" section of the documenation
-    // for motivation for this checking.
-
-    BOOST_STATIC_WARNING(typex::value);
-}
-
-// checks for pointers
-
-template<class T>
-inline void check_pointer_level(){
-    // we should only invoke this once we KNOW that T
-    // has been used as a pointer!!
-    typedef 
-        typename mpl::or_<
-            typename mpl::greater<
-                serialization::implementation_level< T >,
-                mpl::int_<serialization::object_serializable>
-            >,
-            typename mpl::not_<
-                typename mpl::equal_to<
-                    serialization::tracking_level< T >,
-                    mpl::int_<serialization::track_selectively>
-                >
-            >
-        > typex;
-    // Address the following when serializing to a pointer:
-
-    // a) This type doesn't save class information in the
-    // archive. That is, the serialization trait implementation
-    // level <= object_serializable.
-    // b) Tracking for this type is set to "track selectively"
-
-    // in this case, indication that an object is tracked is
-    // not stored in the archive itself - see level == object_serializable
-    // but rather the existence of the operation ar >> T * is used to 
-    // infer that an object of this type should be tracked.  So, if
-    // you save via a pointer but don't load via a pointer the operation
-    // will fail on load without given any valid reason for the failure.
-
-    // So if your program traps here, consider changing the 
-    // tracking or implementation level traits - or not
-    // serializing via a pointer.
-    BOOST_STATIC_WARNING(typex::value);
-}
-
-template<class T>
-void inline check_pointer_tracking(){
-    typedef typename mpl::greater<
-        serialization::tracking_level< T >,
-        mpl::int_<serialization::track_never>
-    >::type typex;
-    // serializing an object of a type marked "track_never" through a pointer
-    // could result in creating more objects than were saved!
-    BOOST_STATIC_WARNING(typex::value);
-}
-
-template<class T>
-inline void check_const_loading(){
-    typedef
-        typename mpl::or_<
-            typename boost::serialization::is_wrapper< T >,
-            typename mpl::not_<
-                typename boost::is_const< T >
-            >
-        >::type typex;
-    // cannot load data into a "const" object unless it's a
-    // wrapper around some other non-const object.
-    BOOST_STATIC_ASSERT(typex::value);
-}
-
-} // detail
-} // archive
-} // boost
-
-#endif // BOOST_ARCHIVE_DETAIL_CHECK_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/detail/common_iarchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/detail/common_iarchive.hpp
deleted file mode 100644
index 82304f1e5ac..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/detail/common_iarchive.hpp
+++ /dev/null
@@ -1,88 +0,0 @@
-#ifndef BOOST_ARCHIVE_DETAIL_COMMON_IARCHIVE_HPP
-#define BOOST_ARCHIVE_DETAIL_COMMON_IARCHIVE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// common_iarchive.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/config.hpp>
-
-#include <boost/archive/detail/basic_iarchive.hpp>
-#include <boost/archive/detail/basic_pointer_iserializer.hpp>
-#include <boost/archive/detail/interface_iarchive.hpp>
-
-#ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable : 4511 4512)
-#endif
-
-namespace boost {
-namespace archive {
-namespace detail {
-
-class extended_type_info;
-
-// note: referred to as Curiously Recurring Template Patter (CRTP)
-template<class Archive>
-class BOOST_SYMBOL_VISIBLE common_iarchive : 
-    public basic_iarchive,
-    public interface_iarchive<Archive>
-{
-    friend class interface_iarchive<Archive>;
-private:
-    virtual void vload(version_type & t){
-        * this->This() >> t; 
-    }
-    virtual void vload(object_id_type & t){
-        * this->This() >> t;
-    }
-    virtual void vload(class_id_type & t){
-        * this->This() >> t;
-    }
-    virtual void vload(class_id_optional_type & t){
-        * this->This() >> t;
-    }
-    virtual void vload(tracking_type & t){
-        * this->This() >> t;
-    }
-    virtual void vload(class_name_type &s){
-        * this->This() >> s;
-    }
-protected:
-    // default processing - invoke serialization library
-    template<class T>
-    void load_override(T & t){
-        archive::load(* this->This(), t);
-    }
-    // default implementations of functions which emit start/end tags for
-    // archive types that require them.
-    void load_start(const char * /*name*/){}
-    void load_end(const char * /*name*/){}
-    // default archive initialization
-    common_iarchive(unsigned int flags = 0) : 
-        basic_iarchive(flags),
-        interface_iarchive<Archive>()
-    {}
-};
-
-} // namespace detail
-} // namespace archive
-} // namespace boost
-
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
-
-#endif // BOOST_ARCHIVE_DETAIL_COMMON_IARCHIVE_HPP
-
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/detail/common_oarchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/detail/common_oarchive.hpp
deleted file mode 100644
index ee42bbe5976..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/detail/common_oarchive.hpp
+++ /dev/null
@@ -1,88 +0,0 @@
-#ifndef BOOST_ARCHIVE_DETAIL_COMMON_OARCHIVE_HPP
-#define BOOST_ARCHIVE_DETAIL_COMMON_OARCHIVE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// common_oarchive.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/config.hpp>
-
-#include <boost/archive/detail/basic_oarchive.hpp>
-#include <boost/archive/detail/interface_oarchive.hpp>
-
-#ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable : 4511 4512)
-#endif
-
-namespace boost {
-namespace archive {
-namespace detail {
-
-// note: referred to as Curiously Recurring Template Patter (CRTP)
-template<class Archive>
-
-class BOOST_SYMBOL_VISIBLE common_oarchive :
-    public basic_oarchive,
-    public interface_oarchive<Archive>
-{
-    friend class interface_oarchive<Archive>;
-private:
-    virtual void vsave(const version_type t){
-        * this->This() << t;
-    }
-    virtual void vsave(const object_id_type t){
-        * this->This() << t;
-    }
-    virtual void vsave(const object_reference_type t){
-        * this->This() << t;
-    }
-    virtual void vsave(const class_id_type t){
-        * this->This() << t;
-    }
-    virtual void vsave(const class_id_reference_type t){
-        * this->This() << t;
-    }
-    virtual void vsave(const class_id_optional_type t){
-        * this->This() << t;
-    }
-    virtual void vsave(const class_name_type & t){
-        * this->This() << t;
-    }
-    virtual void vsave(const tracking_type t){
-        * this->This() << t;
-    }
-protected:
-    // default processing - invoke serialization library
-    template<class T>
-    void save_override(T & t){
-        archive::save(* this->This(), t);
-    }
-    void save_start(const char * /*name*/){}
-    void save_end(const char * /*name*/){}
-    common_oarchive(unsigned int flags = 0) : 
-        basic_oarchive(flags),
-        interface_oarchive<Archive>()
-    {}
-};
-
-} // namespace detail
-} // namespace archive
-} // namespace boost
-
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
-
-#endif // BOOST_ARCHIVE_DETAIL_COMMON_OARCHIVE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/detail/decl.hpp b/contrib/libboost/boost_1_65_0/boost/archive/detail/decl.hpp
deleted file mode 100644
index 4f731cded37..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/detail/decl.hpp
+++ /dev/null
@@ -1,57 +0,0 @@
-#ifndef BOOST_ARCHIVE_DETAIL_DECL_HPP
-#define BOOST_ARCHIVE_DETAIL_DECL_HPP 
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif 
-
-/////////1/////////2///////// 3/////////4/////////5/////////6/////////7/////////8
-//  decl.hpp
-//
-//  (c) Copyright Robert Ramey 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)
-
-//  See library home page at http://www.boost.org/libs/serialization
-
-//----------------------------------------------------------------------------// 
-
-// This header implements separate compilation features as described in
-// http://www.boost.org/more/separate_compilation.html
-
-#include <boost/config.hpp>
-
-#if (defined(BOOST_ALL_DYN_LINK) || defined(BOOST_SERIALIZATION_DYN_LINK))
-    #if defined(BOOST_ARCHIVE_SOURCE)
-        #define BOOST_ARCHIVE_DECL BOOST_SYMBOL_EXPORT
-    #else
-        #define BOOST_ARCHIVE_DECL BOOST_SYMBOL_IMPORT
-    #endif
-
-    #if defined(BOOST_WARCHIVE_SOURCE)
-        #define BOOST_WARCHIVE_DECL BOOST_SYMBOL_EXPORT
-    #else
-        #define BOOST_WARCHIVE_DECL BOOST_SYMBOL_IMPORT
-    #endif
-
-    #if defined(BOOST_WARCHIVE_SOURCE) || defined(BOOST_ARCHIVE_SOURCE)
-        #define BOOST_ARCHIVE_OR_WARCHIVE_DECL BOOST_SYMBOL_EXPORT
-    #else
-        #define BOOST_ARCHIVE_OR_WARCHIVE_DECL BOOST_SYMBOL_IMPORT
-    #endif
-
-#endif
-
-#if ! defined(BOOST_ARCHIVE_DECL)
-    #define BOOST_ARCHIVE_DECL
-#endif
-#if ! defined(BOOST_WARCHIVE_DECL)
-    #define BOOST_WARCHIVE_DECL
-#endif
-#if ! defined(BOOST_ARCHIVE_OR_WARCHIVE_DECL)
-    #define BOOST_ARCHIVE_OR_WARCHIVE_DECL
-#endif
-
-#endif // BOOST_ARCHIVE_DETAIL_DECL_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/detail/helper_collection.hpp b/contrib/libboost/boost_1_65_0/boost/archive/detail/helper_collection.hpp
deleted file mode 100644
index edb4125e308..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/detail/helper_collection.hpp
+++ /dev/null
@@ -1,99 +0,0 @@
-#ifndef BOOST_ARCHIVE_DETAIL_HELPER_COLLECTION_HPP
-#define BOOST_ARCHIVE_DETAIL_HELPER_COLLECTION_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// helper_collection.hpp: archive support for run-time helpers
-
-// (C) Copyright 2002-2008 Robert Ramey and Joaquin M Lopez Munoz
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <cstddef> // NULL
-#include <vector>
-#include <utility>
-#include <memory>
-#include <algorithm>
-
-#include <boost/config.hpp>
-
-#include <boost/smart_ptr/shared_ptr.hpp>
-#include <boost/smart_ptr/make_shared.hpp>
-
-namespace boost {
-
-namespace archive {
-namespace detail {
-
-class helper_collection
-{
-    helper_collection(const helper_collection&);              // non-copyable
-    helper_collection& operator = (const helper_collection&); // non-copyable
-
-    // note: we dont' actually "share" the function object pointer
-    // we only use shared_ptr to make sure that it get's deleted
-
-    typedef std::pair<
-        const void *,
-        boost::shared_ptr<void>
-    > helper_value_type;
-    template<class T>
-    boost::shared_ptr<void> make_helper_ptr(){
-        // use boost::shared_ptr rather than std::shared_ptr to maintain
-        // c++03 compatibility
-        return boost::make_shared<T>();
-    }
-
-    typedef std::vector<helper_value_type> collection;
-    collection m_collection;
-
-    struct predicate {
-        BOOST_DELETED_FUNCTION(predicate & operator=(const predicate & rhs))
-    public:
-        const void * const m_ti;
-        bool operator()(helper_value_type const &rhs) const {
-            return m_ti == rhs.first;
-        }
-        predicate(const void * ti) :
-            m_ti(ti)
-        {}
-    };
-protected:
-    helper_collection(){}
-    ~helper_collection(){}
-public:
-    template<typename Helper>
-    Helper& find_helper(void * const id = 0) {
-        collection::const_iterator it =
-            std::find_if(
-                m_collection.begin(),
-                m_collection.end(),
-                predicate(id)
-            );
-
-        void * rval = 0;
-        if(it == m_collection.end()){
-            m_collection.push_back(
-                std::make_pair(id, make_helper_ptr<Helper>())
-            );
-            rval = m_collection.back().second.get();
-        }
-        else{
-            rval = it->second.get();
-        }
-        return *static_cast<Helper *>(rval);
-    }
-};
-
-} // namespace detail
-} // namespace serialization
-} // namespace boost
-
-#endif // BOOST_ARCHIVE_DETAIL_HELPER_COLLECTION_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/detail/interface_iarchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/detail/interface_iarchive.hpp
deleted file mode 100644
index 4a99e28b59f..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/detail/interface_iarchive.hpp
+++ /dev/null
@@ -1,85 +0,0 @@
-#ifndef BOOST_ARCHIVE_DETAIL_INTERFACE_IARCHIVE_HPP
-#define BOOST_ARCHIVE_DETAIL_INTERFACE_IARCHIVE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// interface_iarchive.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-#include <cstddef> // NULL
-#include <boost/cstdint.hpp>
-#include <boost/mpl/bool.hpp>
-#include <boost/archive/detail/auto_link_archive.hpp>
-#include <boost/archive/detail/iserializer.hpp>
-#include <boost/archive/detail/helper_collection.hpp>
-#include <boost/serialization/singleton.hpp>
-#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
-
-namespace boost {
-namespace archive {
-namespace detail {
-
-class basic_pointer_iserializer;
-
-template<class Archive>
-class interface_iarchive 
-{
-protected:
-    interface_iarchive(){};
-public:
-    /////////////////////////////////////////////////////////
-    // archive public interface
-    typedef mpl::bool_<true> is_loading;
-    typedef mpl::bool_<false> is_saving;
-
-    // return a pointer to the most derived class
-    Archive * This(){
-        return static_cast<Archive *>(this);
-    }
-
-    template<class T>
-    const basic_pointer_iserializer * 
-    register_type(T * = NULL){
-        const basic_pointer_iserializer & bpis =
-            boost::serialization::singleton<
-                pointer_iserializer<Archive, T> 
-            >::get_const_instance();
-        this->This()->register_basic_serializer(bpis.get_basic_serializer());
-        return & bpis;
-    }
-    template<class Helper>
-    Helper &
-    get_helper(void * const id = 0){
-        helper_collection & hc = this->This()->get_helper_collection();
-        return hc.template find_helper<Helper>(id);
-    }
-    
-    template<class T>
-    Archive & operator>>(T & t){
-        this->This()->load_override(t);
-        return * this->This();
-    }
-
-    // the & operator 
-    template<class T>
-    Archive & operator&(T & t){
-        return *(this->This()) >> t;
-    }
-};
-
-} // namespace detail
-} // namespace archive
-} // namespace boost
-
-#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
-
-#endif // BOOST_ARCHIVE_DETAIL_INTERFACE_IARCHIVE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/detail/interface_oarchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/detail/interface_oarchive.hpp
deleted file mode 100644
index 359463ed9d8..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/detail/interface_oarchive.hpp
+++ /dev/null
@@ -1,87 +0,0 @@
-#ifndef BOOST_ARCHIVE_DETAIL_INTERFACE_OARCHIVE_HPP
-#define BOOST_ARCHIVE_DETAIL_INTERFACE_OARCHIVE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// interface_oarchive.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-#include <cstddef> // NULL
-#include <boost/cstdint.hpp>
-#include <boost/mpl/bool.hpp>
-
-#include <boost/archive/detail/auto_link_archive.hpp>
-#include <boost/archive/detail/oserializer.hpp>
-#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
-
-#include <boost/serialization/singleton.hpp>
-
-namespace boost {
-namespace archive {
-namespace detail {
-
-class basic_pointer_oserializer;
-
-template<class Archive>
-class interface_oarchive 
-{
-protected:
-    interface_oarchive(){};
-public:
-    /////////////////////////////////////////////////////////
-    // archive public interface
-    typedef mpl::bool_<false> is_loading;
-    typedef mpl::bool_<true> is_saving;
-
-    // return a pointer to the most derived class
-    Archive * This(){
-        return static_cast<Archive *>(this);
-    }
-
-    template<class T>
-    const basic_pointer_oserializer * 
-    register_type(const T * = NULL){
-        const basic_pointer_oserializer & bpos =
-            boost::serialization::singleton<
-                pointer_oserializer<Archive, T>
-            >::get_const_instance();
-        this->This()->register_basic_serializer(bpos.get_basic_serializer());
-        return & bpos;
-    }
-    
-    template<class Helper>
-    Helper &
-    get_helper(void * const id = 0){
-        helper_collection & hc = this->This()->get_helper_collection();
-        return hc.template find_helper<Helper>(id);
-    }
-
-    template<class T>
-    Archive & operator<<(const T & t){
-        this->This()->save_override(t);
-        return * this->This();
-    }
-    
-    // the & operator 
-    template<class T>
-    Archive & operator&(const T & t){
-        return * this ->This() << t;
-    }
-};
-
-} // namespace detail
-} // namespace archive
-} // namespace boost
-
-#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
-
-#endif // BOOST_ARCHIVE_DETAIL_INTERFACE_IARCHIVE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/detail/iserializer.hpp b/contrib/libboost/boost_1_65_0/boost/archive/detail/iserializer.hpp
deleted file mode 100644
index 193e98a82e4..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/detail/iserializer.hpp
+++ /dev/null
@@ -1,631 +0,0 @@
-#ifndef BOOST_ARCHIVE_DETAIL_ISERIALIZER_HPP
-#define BOOST_ARCHIVE_DETAIL_ISERIALIZER_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#pragma inline_depth(511)
-#pragma inline_recursion(on)
-#endif
-
-#if defined(__MWERKS__)
-#pragma inline_depth(511)
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// iserializer.hpp: interface for serialization system.
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <new>     // for placement new
-#include <cstddef> // size_t, NULL
-
-#include <boost/config.hpp>
-#include <boost/detail/workaround.hpp>
-#if defined(BOOST_NO_STDC_NAMESPACE)
-namespace std{ 
-    using ::size_t; 
-} // namespace std
-#endif
-
-#include <boost/static_assert.hpp>
-
-#include <boost/mpl/eval_if.hpp>
-#include <boost/mpl/identity.hpp>
-#include <boost/mpl/greater_equal.hpp>
-#include <boost/mpl/equal_to.hpp>
-#include <boost/core/no_exceptions_support.hpp>
-
-#ifndef BOOST_SERIALIZATION_DEFAULT_TYPE_INFO   
-    #include <boost/serialization/extended_type_info_typeid.hpp>   
-#endif
-#include <boost/serialization/throw_exception.hpp>
-#include <boost/serialization/smart_cast.hpp>
-#include <boost/serialization/static_warning.hpp>
-
-#include <boost/type_traits/is_pointer.hpp>
-#include <boost/type_traits/is_enum.hpp>
-#include <boost/type_traits/is_const.hpp>
-#include <boost/type_traits/remove_const.hpp>
-#include <boost/type_traits/remove_extent.hpp>
-#include <boost/type_traits/is_polymorphic.hpp>
-
-#include <boost/serialization/assume_abstract.hpp>
-
-#ifndef BOOST_MSVC
-    #define DONT_USE_HAS_NEW_OPERATOR (                    \
-           BOOST_WORKAROUND(__IBMCPP__, < 1210)            \
-        || defined(__SUNPRO_CC) && (__SUNPRO_CC < 0x590)   \
-    )
-#else
-    #define DONT_USE_HAS_NEW_OPERATOR 0
-#endif
-
-#if ! DONT_USE_HAS_NEW_OPERATOR
-#include <boost/type_traits/has_new_operator.hpp>
-#endif
-
-#include <boost/serialization/serialization.hpp>
-#include <boost/serialization/version.hpp>
-#include <boost/serialization/level.hpp>
-#include <boost/serialization/tracking.hpp>
-#include <boost/serialization/type_info_implementation.hpp>
-#include <boost/serialization/nvp.hpp>
-#include <boost/serialization/void_cast.hpp>
-#include <boost/serialization/collection_size_type.hpp>
-#include <boost/serialization/singleton.hpp>
-#include <boost/serialization/wrapper.hpp>
-#include <boost/serialization/array_wrapper.hpp>
-
-// the following is need only for dynamic cast of polymorphic pointers
-#include <boost/archive/archive_exception.hpp>
-#include <boost/archive/detail/basic_iarchive.hpp>
-#include <boost/archive/detail/basic_iserializer.hpp>
-#include <boost/archive/detail/basic_pointer_iserializer.hpp>
-#include <boost/archive/detail/archive_serializer_map.hpp>
-#include <boost/archive/detail/check.hpp>
-
-namespace boost {
-
-namespace serialization {
-    class extended_type_info;
-} // namespace serialization
-
-namespace archive {
-
-// an accessor to permit friend access to archives.  Needed because
-// some compilers don't handle friend templates completely
-class load_access {
-public:
-    template<class Archive, class T>
-    static void load_primitive(Archive &ar, T &t){
-        ar.load(t);
-    }
-};
-
-namespace detail {
-
-#ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable : 4511 4512)
-#endif
-
-template<class Archive, class T>
-class iserializer : public basic_iserializer
-{
-private:
-    virtual void destroy(/*const*/ void *address) const {
-        boost::serialization::access::destroy(static_cast<T *>(address));
-    }
-protected:
-    // protected constructor since it's always created by singleton
-    explicit iserializer() :
-        basic_iserializer(
-            boost::serialization::singleton<
-                typename 
-                boost::serialization::type_info_implementation< T >::type
-            >::get_const_instance()
-        )
-    {}
-public:
-    virtual BOOST_DLLEXPORT void load_object_data(
-        basic_iarchive & ar,
-        void *x, 
-        const unsigned int file_version
-    ) const BOOST_USED;
-    virtual bool class_info() const {
-        return boost::serialization::implementation_level< T >::value 
-            >= boost::serialization::object_class_info;
-    }
-    virtual bool tracking(const unsigned int /* flags */) const {
-        return boost::serialization::tracking_level< T >::value 
-                == boost::serialization::track_always
-            || ( boost::serialization::tracking_level< T >::value 
-                == boost::serialization::track_selectively
-                && serialized_as_pointer());
-    }
-    virtual version_type version() const {
-        return version_type(::boost::serialization::version< T >::value);
-    }
-    virtual bool is_polymorphic() const {
-        return boost::is_polymorphic< T >::value;
-    }
-    virtual ~iserializer(){};
-};
-
-#ifdef BOOST_MSVC
-#  pragma warning(pop)
-#endif
-
-template<class Archive, class T>
-BOOST_DLLEXPORT void iserializer<Archive, T>::load_object_data(
-    basic_iarchive & ar,
-    void *x, 
-    const unsigned int file_version
-) const {
-    // note: we now comment this out. Before we permited archive
-    // version # to be very large.  Now we don't.  To permit
-    // readers of these old archives, we have to suppress this 
-    // code.  Perhaps in the future we might re-enable it but
-    // permit its suppression with a runtime switch.
-    #if 0
-    // trap case where the program cannot handle the current version
-    if(file_version > static_cast<const unsigned int>(version()))
-        boost::serialization::throw_exception(
-            archive::archive_exception(
-                boost::archive::archive_exception::unsupported_class_version,
-                get_debug_info()
-            )
-        );
-    #endif
-    // make sure call is routed through the higest interface that might
-    // be specialized by the user.
-    boost::serialization::serialize_adl(
-        boost::serialization::smart_cast_reference<Archive &>(ar),
-        * static_cast<T *>(x), 
-        file_version
-    );
-}
-
-#ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable : 4511 4512)
-#endif
-
-// the purpose of this code is to allocate memory for an object
-// without requiring the constructor to be called.  Presumably
-// the allocated object will be subsequently initialized with
-// "placement new". 
-// note: we have the boost type trait has_new_operator but we
-// have no corresponding has_delete_operator.  So we presume
-// that the former being true would imply that the a delete
-// operator is also defined for the class T.
-
-template<class T>
-struct heap_allocation {
-    // boost::has_new_operator< T > doesn't work on these compilers
-    #if DONT_USE_HAS_NEW_OPERATOR
-        // This doesn't handle operator new overload for class T
-        static T * invoke_new(){
-            return static_cast<T *>(operator new(sizeof(T)));
-        }
-        static void invoke_delete(T *t){
-            (operator delete(t));
-        }
-    #else
-        // note: we presume that a true value for has_new_operator
-        // implies the existence of a class specific delete operator as well
-        // as a class specific new operator.
-        struct has_new_operator {
-            static T * invoke_new() {
-                return static_cast<T *>((T::operator new)(sizeof(T)));
-            }
-            static void invoke_delete(T * t) {
-                // if compilation fails here, the likely cause that the class
-                // T has a class specific new operator but no class specific
-                // delete operator which matches the following signature.
-                // note that this solution addresses the issue that two
-                // possible signatures.  But it doesn't address the possibility
-                // that the class might have class specific new with NO
-                // class specific delete at all.  Patches (compatible with
-                // C++03) welcome!
-                delete t;
-            }
-        };
-        struct doesnt_have_new_operator {
-            static T* invoke_new() {
-                return static_cast<T *>(operator new(sizeof(T)));
-            }
-            static void invoke_delete(T * t) {
-                // Note: I'm reliance upon automatic conversion from T * to void * here
-                delete t;
-            }
-        };
-        static T * invoke_new() {
-            typedef typename
-                mpl::eval_if<
-                    boost::has_new_operator< T >,
-                    mpl::identity<has_new_operator >,
-                    mpl::identity<doesnt_have_new_operator >    
-                >::type typex;
-            return typex::invoke_new();
-        }
-        static void invoke_delete(T *t) {
-            typedef typename
-                mpl::eval_if<
-                    boost::has_new_operator< T >,
-                    mpl::identity<has_new_operator >,
-                    mpl::identity<doesnt_have_new_operator >    
-                >::type typex;
-            typex::invoke_delete(t);
-        }
-    #endif
-    explicit heap_allocation(){
-        m_p = invoke_new();
-    }
-    ~heap_allocation(){
-        if (0 != m_p)
-            invoke_delete(m_p);
-    }
-    T* get() const {
-        return m_p;
-    }
-
-    T* release() {
-        T* p = m_p;
-        m_p = 0;
-        return p;
-    }
-private:
-    T* m_p;
-};
-
-template<class Archive, class T>
-class pointer_iserializer :
-    public basic_pointer_iserializer
-{
-private:
-    virtual void * heap_allocation() const {
-        detail::heap_allocation<T> h;
-        T * t = h.get();
-        h.release();
-        return t;
-    }
-    virtual const basic_iserializer & get_basic_serializer() const {
-        return boost::serialization::singleton<
-            iserializer<Archive, T>
-        >::get_const_instance();
-    }
-    BOOST_DLLEXPORT virtual void load_object_ptr(
-        basic_iarchive & ar, 
-        void * x,
-        const unsigned int file_version
-    ) const BOOST_USED;
-protected:
-    // this should alway be a singleton so make the constructor protected
-    pointer_iserializer();
-    ~pointer_iserializer();
-};
-
-#ifdef BOOST_MSVC
-#  pragma warning(pop)
-#endif
-
-// note: BOOST_DLLEXPORT is so that code for polymorphic class
-// serialized only through base class won't get optimized out
-template<class Archive, class T>
-BOOST_DLLEXPORT void pointer_iserializer<Archive, T>::load_object_ptr(
-    basic_iarchive & ar, 
-    void * t,
-    const unsigned int file_version
-) const
-{
-    Archive & ar_impl = 
-        boost::serialization::smart_cast_reference<Archive &>(ar);
-
-    // note that the above will throw std::bad_alloc if the allocation
-    // fails so we don't have to address this contingency here.
-
-    // catch exception during load_construct_data so that we don't
-    // automatically delete the t which is most likely not fully
-    // constructed
-    BOOST_TRY {
-        // this addresses an obscure situation that occurs when 
-        // load_constructor de-serializes something through a pointer.
-        ar.next_object_pointer(t);
-        boost::serialization::load_construct_data_adl<Archive, T>(
-            ar_impl,
-            static_cast<T *>(t),
-            file_version
-        );
-    }
-    BOOST_CATCH(...){
-        // if we get here the load_construct failed.  The heap_allocation
-        // will be automatically deleted so we don't have to do anything
-        // special here.
-        BOOST_RETHROW;
-    }
-    BOOST_CATCH_END
-
-    ar_impl >> boost::serialization::make_nvp(NULL, * static_cast<T *>(t));
-}
-
-template<class Archive, class T>
-pointer_iserializer<Archive, T>::pointer_iserializer() :
-    basic_pointer_iserializer(
-        boost::serialization::singleton<
-            typename 
-            boost::serialization::type_info_implementation< T >::type
-        >::get_const_instance()
-    )
-{
-    boost::serialization::singleton<
-        iserializer<Archive, T>
-    >::get_mutable_instance().set_bpis(this);
-    archive_serializer_map<Archive>::insert(this);
-}
-
-template<class Archive, class T>
-pointer_iserializer<Archive, T>::~pointer_iserializer(){
-    archive_serializer_map<Archive>::erase(this);
-}
-
-template<class Archive>
-struct load_non_pointer_type {
-    // note this bounces the call right back to the archive
-    // with no runtime overhead
-    struct load_primitive {
-        template<class T>
-        static void invoke(Archive & ar, T & t){
-            load_access::load_primitive(ar, t);
-        }
-    };
-    // note this bounces the call right back to the archive
-    // with no runtime overhead
-    struct load_only {
-        template<class T>
-        static void invoke(Archive & ar, const T & t){
-            // short cut to user's serializer
-            // make sure call is routed through the higest interface that might
-            // be specialized by the user.
-            boost::serialization::serialize_adl(
-                ar, 
-                const_cast<T &>(t), 
-                boost::serialization::version< T >::value
-            );
-        }
-    };
-
-    // note this save class information including version
-    // and serialization level to the archive
-    struct load_standard {
-        template<class T>
-        static void invoke(Archive &ar, const T & t){
-            void * x = & const_cast<T &>(t);
-            ar.load_object(
-                x, 
-                boost::serialization::singleton<
-                    iserializer<Archive, T>
-                >::get_const_instance()
-            );
-        }
-    };
-
-    struct load_conditional {
-        template<class T>
-        static void invoke(Archive &ar, T &t){
-            //if(0 == (ar.get_flags() & no_tracking))
-                load_standard::invoke(ar, t);
-            //else
-            //    load_only::invoke(ar, t);
-        }
-    };
-
-    template<class T>
-    static void invoke(Archive & ar, T &t){
-        typedef typename mpl::eval_if<
-                // if its primitive
-                mpl::equal_to<
-                    boost::serialization::implementation_level< T >,
-                    mpl::int_<boost::serialization::primitive_type>
-                >,
-                mpl::identity<load_primitive>,
-            // else
-            typename mpl::eval_if<
-            // class info / version
-            mpl::greater_equal<
-                        boost::serialization::implementation_level< T >,
-                        mpl::int_<boost::serialization::object_class_info>
-                    >,
-            // do standard load
-            mpl::identity<load_standard>,
-        // else
-        typename mpl::eval_if<
-            // no tracking
-                    mpl::equal_to<
-                        boost::serialization::tracking_level< T >,
-                        mpl::int_<boost::serialization::track_never>
-                >,
-                // do a fast load
-                mpl::identity<load_only>,
-            // else
-            // do a fast load only tracking is turned off
-            mpl::identity<load_conditional>
-        > > >::type typex;
-        check_object_versioning< T >();
-        check_object_level< T >();
-        typex::invoke(ar, t);
-    }
-};
-
-template<class Archive>
-struct load_pointer_type {
-    struct abstract
-    {
-        template<class T>
-        static const basic_pointer_iserializer * register_type(Archive & /* ar */){
-            // it has? to be polymorphic
-            BOOST_STATIC_ASSERT(boost::is_polymorphic< T >::value);
-            return static_cast<basic_pointer_iserializer *>(NULL);
-         }
-    };
-
-    struct non_abstract
-    {
-        template<class T>
-        static const basic_pointer_iserializer * register_type(Archive & ar){
-            return ar.register_type(static_cast<T *>(NULL));
-        }
-    };
-
-    template<class T>
-    static const basic_pointer_iserializer * register_type(Archive &ar, const T & /*t*/){
-        // there should never be any need to load an abstract polymorphic 
-        // class pointer.  Inhibiting code generation for this
-        // permits abstract base classes to be used - note: exception
-        // virtual serialize functions used for plug-ins
-        typedef typename
-            mpl::eval_if<
-                boost::serialization::is_abstract<const T>,
-                boost::mpl::identity<abstract>,
-                boost::mpl::identity<non_abstract>  
-            >::type typex;
-        return typex::template register_type< T >(ar);
-    }
-
-    template<class T>
-    static T * pointer_tweak(
-        const boost::serialization::extended_type_info & eti,
-        void const * const t,
-        const T &
-    ) {
-        // tweak the pointer back to the base class
-        void * upcast = const_cast<void *>(
-            boost::serialization::void_upcast(
-                eti,
-                boost::serialization::singleton<
-                    typename 
-                    boost::serialization::type_info_implementation< T >::type
-                >::get_const_instance(),
-                t
-            )
-        );
-        if(NULL == upcast)
-            boost::serialization::throw_exception(
-                archive_exception(archive_exception::unregistered_class)
-            );
-        return static_cast<T *>(upcast);
-    }
-
-    template<class T>
-    static void check_load(T & /* t */){
-        check_pointer_level< T >();
-        check_pointer_tracking< T >();
-    }
-
-    static const basic_pointer_iserializer *
-    find(const boost::serialization::extended_type_info & type){
-        return static_cast<const basic_pointer_iserializer *>(
-            archive_serializer_map<Archive>::find(type)
-        );
-    }
-
-    template<class Tptr>
-    static void invoke(Archive & ar, Tptr & t){
-        check_load(*t);
-        const basic_pointer_iserializer * bpis_ptr = register_type(ar, *t);
-        const basic_pointer_iserializer * newbpis_ptr = ar.load_pointer(
-            // note major hack here !!!
-            // I tried every way to convert Tptr &t (where Tptr might
-            // include const) to void * &.  This is the only way
-            // I could make it work. RR
-            (void * & )t,
-            bpis_ptr,
-            find
-        );
-        // if the pointer isn't that of the base class
-        if(newbpis_ptr != bpis_ptr){
-            t = pointer_tweak(newbpis_ptr->get_eti(), t, *t);
-        }
-    }
-};
-
-template<class Archive>
-struct load_enum_type {
-    template<class T>
-    static void invoke(Archive &ar, T &t){
-        // convert integers to correct enum to load
-        int i;
-        ar >> boost::serialization::make_nvp(NULL, i);
-        t = static_cast< T >(i);
-    }
-};
-
-template<class Archive>
-struct load_array_type {
-    template<class T>
-    static void invoke(Archive &ar, T &t){
-        typedef typename remove_extent< T >::type value_type;
-        
-        // convert integers to correct enum to load
-        // determine number of elements in the array. Consider the
-        // fact that some machines will align elements on boundries
-        // other than characters.
-        std::size_t current_count = sizeof(t) / (
-            static_cast<char *>(static_cast<void *>(&t[1])) 
-            - static_cast<char *>(static_cast<void *>(&t[0]))
-        );
-        boost::serialization::collection_size_type count;
-        ar >> BOOST_SERIALIZATION_NVP(count);
-        if(static_cast<std::size_t>(count) > current_count)
-            boost::serialization::throw_exception(
-                archive::archive_exception(
-                    boost::archive::archive_exception::array_size_too_short
-                )
-            );
-        // explict template arguments to pass intel C++ compiler
-        ar >> serialization::make_array<
-            value_type,
-            boost::serialization::collection_size_type
-        >(
-            static_cast<value_type *>(&t[0]),
-            count
-        );
-    }
-};
-
-} // detail
-
-template<class Archive, class T>
-inline void load(Archive & ar, T &t){
-    // if this assertion trips. It means we're trying to load a
-    // const object with a compiler that doesn't have correct
-    // function template ordering.  On other compilers, this is
-    // handled below.
-    detail::check_const_loading< T >();
-    typedef
-        typename mpl::eval_if<is_pointer< T >,
-            mpl::identity<detail::load_pointer_type<Archive> >
-        ,//else
-        typename mpl::eval_if<is_array< T >,
-            mpl::identity<detail::load_array_type<Archive> >
-        ,//else
-        typename mpl::eval_if<is_enum< T >,
-            mpl::identity<detail::load_enum_type<Archive> >
-        ,//else
-            mpl::identity<detail::load_non_pointer_type<Archive> >
-        >
-        >
-        >::type typex;
-    typex::invoke(ar, t);
-}
-
-} // namespace archive
-} // namespace boost
-
-#endif // BOOST_ARCHIVE_DETAIL_ISERIALIZER_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/detail/oserializer.hpp b/contrib/libboost/boost_1_65_0/boost/archive/detail/oserializer.hpp
deleted file mode 100644
index c120ec55073..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/detail/oserializer.hpp
+++ /dev/null
@@ -1,540 +0,0 @@
-#ifndef BOOST_ARCHIVE_OSERIALIZER_HPP
-#define BOOST_ARCHIVE_OSERIALIZER_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#pragma inline_depth(511)
-#pragma inline_recursion(on)
-#endif
-
-#if defined(__MWERKS__)
-#pragma inline_depth(511)
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// oserializer.hpp: interface for serialization system.
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/assert.hpp>
-#include <cstddef> // NULL
-
-#include <boost/config.hpp>
-#include <boost/static_assert.hpp>
-#include <boost/detail/workaround.hpp>
-
-#include <boost/mpl/eval_if.hpp>
-#include <boost/mpl/equal_to.hpp>
-#include <boost/mpl/greater_equal.hpp>
-#include <boost/mpl/identity.hpp>
-#include <boost/mpl/bool_fwd.hpp>
-
-#ifndef BOOST_SERIALIZATION_DEFAULT_TYPE_INFO   
-    #include <boost/serialization/extended_type_info_typeid.hpp>   
-#endif
-#include <boost/serialization/throw_exception.hpp>
-#include <boost/serialization/smart_cast.hpp>
-#include <boost/serialization/assume_abstract.hpp>
-#include <boost/serialization/static_warning.hpp>
-
-#include <boost/type_traits/is_pointer.hpp>
-#include <boost/type_traits/is_enum.hpp>
-#include <boost/type_traits/is_const.hpp>
-#include <boost/type_traits/is_polymorphic.hpp>
-#include <boost/type_traits/remove_extent.hpp>
-
-#include <boost/serialization/serialization.hpp>
-#include <boost/serialization/version.hpp>
-#include <boost/serialization/level.hpp>
-#include <boost/serialization/tracking.hpp>
-#include <boost/serialization/type_info_implementation.hpp>
-#include <boost/serialization/nvp.hpp>
-#include <boost/serialization/void_cast.hpp>
-#include <boost/serialization/collection_size_type.hpp>
-#include <boost/serialization/array_wrapper.hpp>
-
-#include <boost/serialization/singleton.hpp>
-
-#include <boost/archive/archive_exception.hpp>
-#include <boost/archive/detail/basic_oarchive.hpp>
-#include <boost/archive/detail/basic_oserializer.hpp>
-#include <boost/archive/detail/basic_pointer_oserializer.hpp>
-#include <boost/archive/detail/archive_serializer_map.hpp>
-#include <boost/archive/detail/check.hpp>
-
-namespace boost {
-
-namespace serialization {
-    class extended_type_info;
-} // namespace serialization
-
-namespace archive {
-
-// an accessor to permit friend access to archives.  Needed because
-// some compilers don't handle friend templates completely
-class save_access {
-public:
-    template<class Archive>
-    static void end_preamble(Archive & ar){
-        ar.end_preamble();
-    }
-    template<class Archive, class T>
-    static void save_primitive(Archive & ar, const  T & t){
-        ar.end_preamble();
-        ar.save(t);
-    }
-};
-
-namespace detail {
-
-#ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable : 4511 4512)
-#endif
-
-template<class Archive, class T>
-class oserializer : public basic_oserializer
-{
-private:
-    // private constructor to inhibit any existence other than the 
-    // static one
-public:
-    explicit BOOST_DLLEXPORT oserializer() :
-        basic_oserializer(
-            boost::serialization::singleton<
-                typename 
-                boost::serialization::type_info_implementation< T >::type
-            >::get_const_instance()
-        )
-    {}
-    virtual BOOST_DLLEXPORT void save_object_data(
-        basic_oarchive & ar,    
-        const void *x
-    ) const BOOST_USED;
-    virtual bool class_info() const {
-        return boost::serialization::implementation_level< T >::value 
-            >= boost::serialization::object_class_info;
-    }
-    virtual bool tracking(const unsigned int /* flags */) const {
-        return boost::serialization::tracking_level< T >::value == boost::serialization::track_always
-            || (boost::serialization::tracking_level< T >::value == boost::serialization::track_selectively
-                && serialized_as_pointer());
-    }
-    virtual version_type version() const {
-        return version_type(::boost::serialization::version< T >::value);
-    }
-    virtual bool is_polymorphic() const {
-        return boost::is_polymorphic< T >::value;
-    }
-    virtual ~oserializer(){}
-};
-
-#ifdef BOOST_MSVC
-#  pragma warning(pop)
-#endif
-
-template<class Archive, class T>
-BOOST_DLLEXPORT void oserializer<Archive, T>::save_object_data(
-    basic_oarchive & ar,    
-    const void *x
-) const {
-    // make sure call is routed through the highest interface that might
-    // be specialized by the user.
-    BOOST_STATIC_ASSERT(boost::is_const< T >::value == false);
-    boost::serialization::serialize_adl(
-        boost::serialization::smart_cast_reference<Archive &>(ar),
-        * static_cast<T *>(const_cast<void *>(x)),
-        version()
-    );
-}
-
-#ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable : 4511 4512)
-#endif
-
-template<class Archive, class T>
-class pointer_oserializer :
-    public basic_pointer_oserializer
-{
-private:
-    const basic_oserializer & 
-    get_basic_serializer() const {
-        return boost::serialization::singleton<
-            oserializer<Archive, T>
-        >::get_const_instance();
-    }
-    virtual BOOST_DLLEXPORT void save_object_ptr(
-        basic_oarchive & ar,
-        const void * x
-    ) const BOOST_USED;
-public:
-    pointer_oserializer();
-    ~pointer_oserializer();
-};
-
-#ifdef BOOST_MSVC
-#  pragma warning(pop)
-#endif
-
-template<class Archive, class T>
-BOOST_DLLEXPORT void pointer_oserializer<Archive, T>::save_object_ptr(
-    basic_oarchive & ar,
-    const void * x
-) const {
-    BOOST_ASSERT(NULL != x);
-    // make sure call is routed through the highest interface that might
-    // be specialized by the user.
-    T * t = static_cast<T *>(const_cast<void *>(x));
-    const unsigned int file_version = boost::serialization::version< T >::value;
-    Archive & ar_impl 
-        = boost::serialization::smart_cast_reference<Archive &>(ar);
-    boost::serialization::save_construct_data_adl<Archive, T>(
-        ar_impl, 
-        t, 
-        file_version
-    );
-    ar_impl << boost::serialization::make_nvp(NULL, * t);
-}
-
-template<class Archive, class T>
-pointer_oserializer<Archive, T>::pointer_oserializer() :
-    basic_pointer_oserializer(
-        boost::serialization::singleton<
-            typename 
-            boost::serialization::type_info_implementation< T >::type
-        >::get_const_instance()
-    )
-{
-    // make sure appropriate member function is instantiated
-    boost::serialization::singleton<
-        oserializer<Archive, T> 
-    >::get_mutable_instance().set_bpos(this);
-    archive_serializer_map<Archive>::insert(this);
-}
-
-template<class Archive, class T>
-pointer_oserializer<Archive, T>::~pointer_oserializer(){
-    archive_serializer_map<Archive>::erase(this);
-}
-
-template<class Archive>
-struct save_non_pointer_type {
-    // note this bounces the call right back to the archive
-    // with no runtime overhead
-    struct save_primitive {
-        template<class T>
-        static void invoke(Archive & ar, const T & t){
-            save_access::save_primitive(ar, t);
-        }
-    };
-    // same as above but passes through serialization
-    struct save_only {
-        template<class T>
-        static void invoke(Archive & ar, const T & t){
-            // make sure call is routed through the highest interface that might
-            // be specialized by the user.
-            boost::serialization::serialize_adl(
-                ar, 
-                const_cast<T &>(t), 
-                ::boost::serialization::version< T >::value
-            );
-        }
-    };
-    // adds class information to the archive. This includes
-    // serialization level and class version
-    struct save_standard {
-        template<class T>
-        static void invoke(Archive &ar, const T & t){
-            ar.save_object(
-                & t, 
-                boost::serialization::singleton<
-                    oserializer<Archive, T>
-                >::get_const_instance()
-            );
-        }
-    };
-
-    // adds class information to the archive. This includes
-    // serialization level and class version
-    struct save_conditional {
-        template<class T>
-        static void invoke(Archive &ar, const T &t){
-            //if(0 == (ar.get_flags() & no_tracking))
-                save_standard::invoke(ar, t);
-            //else
-            //   save_only::invoke(ar, t);
-        }
-    };
-
-
-    template<class T>
-    static void invoke(Archive & ar, const T & t){
-        typedef 
-            typename mpl::eval_if<
-            // if its primitive
-                mpl::equal_to<
-                    boost::serialization::implementation_level< T >,
-                    mpl::int_<boost::serialization::primitive_type>
-                >,
-                mpl::identity<save_primitive>,
-            // else
-            typename mpl::eval_if<
-                // class info / version
-                mpl::greater_equal<
-                    boost::serialization::implementation_level< T >,
-                    mpl::int_<boost::serialization::object_class_info>
-                >,
-                // do standard save
-                mpl::identity<save_standard>,
-            // else
-            typename mpl::eval_if<
-                    // no tracking
-                mpl::equal_to<
-                    boost::serialization::tracking_level< T >,
-                    mpl::int_<boost::serialization::track_never>
-                >,
-                // do a fast save
-                mpl::identity<save_only>,
-            // else
-                // do a fast save only tracking is turned off
-                mpl::identity<save_conditional>
-            > > >::type typex; 
-        check_object_versioning< T >();
-        typex::invoke(ar, t);
-    }
-    template<class T>
-    static void invoke(Archive & ar, T & t){
-        check_object_level< T >();
-        check_object_tracking< T >();
-        invoke(ar, const_cast<const T &>(t));
-    }
-};
-
-template<class Archive>
-struct save_pointer_type {
-    struct abstract
-    {
-        template<class T>
-        static const basic_pointer_oserializer * register_type(Archive & /* ar */){
-            // it has? to be polymorphic
-            BOOST_STATIC_ASSERT(boost::is_polymorphic< T >::value);
-            return NULL;
-        }
-    };
-
-    struct non_abstract
-    {
-        template<class T>
-        static const basic_pointer_oserializer * register_type(Archive & ar){
-            return ar.register_type(static_cast<T *>(NULL));
-        }
-    };
-
-    template<class T>
-    static const basic_pointer_oserializer * register_type(Archive &ar, T & /*t*/){
-        // there should never be any need to save an abstract polymorphic 
-        // class pointer.  Inhibiting code generation for this
-        // permits abstract base classes to be used - note: exception
-        // virtual serialize functions used for plug-ins
-        typedef 
-            typename mpl::eval_if<
-                boost::serialization::is_abstract< T >,
-                mpl::identity<abstract>,
-                mpl::identity<non_abstract>       
-            >::type typex;
-        return typex::template register_type< T >(ar);
-    }
-
-    struct non_polymorphic
-    {
-        template<class T>
-        static void save(
-            Archive &ar, 
-            T & t
-        ){
-            const basic_pointer_oserializer & bpos = 
-                boost::serialization::singleton<
-                    pointer_oserializer<Archive, T>
-                >::get_const_instance();
-            // save the requested pointer type
-            ar.save_pointer(& t, & bpos);
-        }
-    };
-
-    struct polymorphic
-    {
-        template<class T>
-        static void save(
-            Archive &ar, 
-            T & t
-        ){
-            typename 
-            boost::serialization::type_info_implementation< T >::type const
-            & i = boost::serialization::singleton<
-                typename 
-                boost::serialization::type_info_implementation< T >::type
-            >::get_const_instance();
-
-            boost::serialization::extended_type_info const * const this_type = & i;
-
-            // retrieve the true type of the object pointed to
-            // if this assertion fails its an error in this library
-            BOOST_ASSERT(NULL != this_type);
-
-            const boost::serialization::extended_type_info * true_type =
-                i.get_derived_extended_type_info(t);
-
-            // note:if this exception is thrown, be sure that derived pointer
-            // is either registered or exported.
-            if(NULL == true_type){
-                boost::serialization::throw_exception(
-                    archive_exception(
-                        archive_exception::unregistered_class,
-                        "derived class not registered or exported"
-                    )
-                );
-            }
-
-            // if its not a pointer to a more derived type
-            const void *vp = static_cast<const void *>(&t);
-            if(*this_type == *true_type){
-                const basic_pointer_oserializer * bpos = register_type(ar, t);
-                ar.save_pointer(vp, bpos);
-                return;
-            }
-            // convert pointer to more derived type. if this is thrown
-            // it means that the base/derived relationship hasn't be registered
-            vp = serialization::void_downcast(
-                *true_type, 
-                *this_type, 
-                static_cast<const void *>(&t)
-            );
-            if(NULL == vp){
-                boost::serialization::throw_exception(
-                    archive_exception(
-                        archive_exception::unregistered_cast,
-                        true_type->get_debug_info(),
-                        this_type->get_debug_info()
-                    )
-                );
-            }
-
-            // since true_type is valid, and this only gets made if the 
-            // pointer oserializer object has been created, this should never
-            // fail
-            const basic_pointer_oserializer * bpos
-                = static_cast<const basic_pointer_oserializer *>(
-                    boost::serialization::singleton<
-                        archive_serializer_map<Archive>
-                    >::get_const_instance().find(*true_type)
-                );
-            BOOST_ASSERT(NULL != bpos);
-            if(NULL == bpos)
-                boost::serialization::throw_exception(
-                    archive_exception(
-                        archive_exception::unregistered_class,
-                        "derived class not registered or exported"
-                    )
-                );
-            ar.save_pointer(vp, bpos);
-        }
-    };
-
-    template<class T>
-    static void save(
-        Archive & ar, 
-        const T & t
-    ){
-        check_pointer_level< T >();
-        check_pointer_tracking< T >();
-        typedef typename mpl::eval_if<
-            is_polymorphic< T >,
-            mpl::identity<polymorphic>,
-            mpl::identity<non_polymorphic>
-        >::type type;
-        type::save(ar, const_cast<T &>(t));
-    }
-
-    template<class TPtr>
-    static void invoke(Archive &ar, const TPtr t){
-        register_type(ar, * t);
-        if(NULL == t){
-            basic_oarchive & boa 
-                = boost::serialization::smart_cast_reference<basic_oarchive &>(ar);
-            boa.save_null_pointer();
-            save_access::end_preamble(ar);
-            return;
-        }
-        save(ar, * t);
-    }
-};
-
-template<class Archive>
-struct save_enum_type
-{
-    template<class T>
-    static void invoke(Archive &ar, const T &t){
-        // convert enum to integers on save
-        const int i = static_cast<int>(t);
-        ar << boost::serialization::make_nvp(NULL, i);
-    }
-};
-
-template<class Archive>
-struct save_array_type
-{
-    template<class T>
-    static void invoke(Archive &ar, const T &t){
-        typedef typename boost::remove_extent< T >::type value_type;
-        
-        save_access::end_preamble(ar);
-        // consider alignment
-        std::size_t c = sizeof(t) / (
-            static_cast<const char *>(static_cast<const void *>(&t[1])) 
-            - static_cast<const char *>(static_cast<const void *>(&t[0]))
-        );
-        boost::serialization::collection_size_type count(c);
-        ar << BOOST_SERIALIZATION_NVP(count);
-        // explict template arguments to pass intel C++ compiler
-        ar << serialization::make_array<
-            const value_type,
-            boost::serialization::collection_size_type
-        >(
-            static_cast<const value_type *>(&t[0]),
-            count
-        );
-    }
-};
-
-} // detail
-
-template<class Archive, class T>
-inline void save(Archive & ar, /*const*/ T &t){
-    typedef 
-        typename mpl::eval_if<is_pointer< T >,
-            mpl::identity<detail::save_pointer_type<Archive> >,
-        //else
-        typename mpl::eval_if<is_enum< T >,
-            mpl::identity<detail::save_enum_type<Archive> >,
-        //else
-        typename mpl::eval_if<is_array< T >,
-            mpl::identity<detail::save_array_type<Archive> >,
-        //else
-            mpl::identity<detail::save_non_pointer_type<Archive> >
-        >
-        >
-        >::type typex;
-    typex::invoke(ar, t);
-}
-
-} // namespace archive
-} // namespace boost
-
-#endif // BOOST_ARCHIVE_OSERIALIZER_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/detail/polymorphic_iarchive_route.hpp b/contrib/libboost/boost_1_65_0/boost/archive/detail/polymorphic_iarchive_route.hpp
deleted file mode 100644
index 105685ebbd8..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/detail/polymorphic_iarchive_route.hpp
+++ /dev/null
@@ -1,218 +0,0 @@
-#ifndef BOOST_ARCHIVE_DETAIL_POLYMORPHIC_IARCHIVE_ROUTE_HPP
-#define BOOST_ARCHIVE_DETAIL_POLYMORPHIC_IARCHIVE_ROUTE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// polymorphic_iarchive_route.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <string>
-#include <ostream>
-#include <cstddef>
-
-#include <boost/config.hpp>
-#if defined(BOOST_NO_STDC_NAMESPACE)
-namespace std{
-    using ::size_t;
-} // namespace std
-#endif
-
-#include <boost/cstdint.hpp>
-#include <boost/integer_traits.hpp>
-#include <boost/archive/polymorphic_iarchive.hpp>
-#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
-
-namespace boost {
-namespace serialization {
-    class extended_type_info;
-} // namespace serialization
-namespace archive {
-namespace detail{
-
-class basic_iserializer;
-class basic_pointer_iserializer;
-
-#ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable : 4511 4512)
-#endif
-
-template<class ArchiveImplementation>
-class polymorphic_iarchive_route :
-    public polymorphic_iarchive,
-    // note: gcc dynamic cross cast fails if the the derivation below is
-    // not public.  I think this is a mistake.
-    public /*protected*/ ArchiveImplementation
-{
-private:
-    // these are used by the serialization library.
-    virtual void load_object(
-        void *t,
-        const basic_iserializer & bis
-    ){
-        ArchiveImplementation::load_object(t, bis);
-    }
-    virtual const basic_pointer_iserializer * load_pointer(
-        void * & t,
-        const basic_pointer_iserializer * bpis_ptr,
-        const basic_pointer_iserializer * (*finder)(
-            const boost::serialization::extended_type_info & type
-        )
-    ){
-        return ArchiveImplementation::load_pointer(t, bpis_ptr, finder);
-    }
-    virtual void set_library_version(library_version_type archive_library_version){
-        ArchiveImplementation::set_library_version(archive_library_version);
-    }
-    virtual library_version_type get_library_version() const{
-        return ArchiveImplementation::get_library_version();
-    }
-    virtual unsigned int get_flags() const {
-        return ArchiveImplementation::get_flags();
-    }
-    virtual void delete_created_pointers(){
-        ArchiveImplementation::delete_created_pointers();
-    }
-    virtual void reset_object_address(
-        const void * new_address,
-        const void * old_address
-    ){
-        ArchiveImplementation::reset_object_address(new_address, old_address);
-    }
-    virtual void load_binary(void * t, std::size_t size){
-        ArchiveImplementation::load_binary(t, size);
-    }
-    // primitive types the only ones permitted by polymorphic archives
-    virtual void load(bool & t){
-        ArchiveImplementation::load(t);
-    }
-    virtual void load(char & t){
-        ArchiveImplementation::load(t);
-    }
-    virtual void load(signed char & t){
-        ArchiveImplementation::load(t);
-    }
-    virtual void load(unsigned char & t){
-        ArchiveImplementation::load(t);
-    }
-    #ifndef BOOST_NO_CWCHAR
-    #ifndef BOOST_NO_INTRINSIC_WCHAR_T
-    virtual void load(wchar_t & t){
-        ArchiveImplementation::load(t);
-    }
-    #endif
-    #endif
-    virtual void load(short & t){
-        ArchiveImplementation::load(t);
-    }
-    virtual void load(unsigned short & t){
-        ArchiveImplementation::load(t);
-    }
-    virtual void load(int & t){
-        ArchiveImplementation::load(t);
-    }
-    virtual void load(unsigned int & t){
-        ArchiveImplementation::load(t);
-    }
-    virtual void load(long & t){
-        ArchiveImplementation::load(t);
-    }
-    virtual void load(unsigned long & t){
-        ArchiveImplementation::load(t);
-    }
-    #if defined(BOOST_HAS_LONG_LONG)
-    virtual void load(boost::long_long_type & t){
-        ArchiveImplementation::load(t);
-    }
-    virtual void load(boost::ulong_long_type & t){
-        ArchiveImplementation::load(t);
-    }
-    #elif defined(BOOST_HAS_MS_INT64)
-    virtual void load(__int64 & t){
-        ArchiveImplementation::load(t);
-    }
-    virtual void load(unsigned __int64 & t){
-        ArchiveImplementation::load(t);
-    }
-    #endif
-    virtual void load(float & t){
-        ArchiveImplementation::load(t);
-    }
-    virtual void load(double & t){
-        ArchiveImplementation::load(t);
-    }
-    virtual void load(std::string & t){
-        ArchiveImplementation::load(t);
-    }
-    #ifndef BOOST_NO_STD_WSTRING
-    virtual void load(std::wstring & t){
-        ArchiveImplementation::load(t);
-    }
-    #endif
-    // used for xml and other tagged formats default does nothing
-    virtual void load_start(const char * name){
-        ArchiveImplementation::load_start(name);
-    }
-    virtual void load_end(const char * name){
-        ArchiveImplementation::load_end(name);
-    }
-    virtual void register_basic_serializer(const basic_iserializer & bis){
-        ArchiveImplementation::register_basic_serializer(bis);
-    }
-    virtual helper_collection &
-    get_helper_collection(){
-        return ArchiveImplementation::get_helper_collection();
-    }
-public:
-    // this can't be inheriteded because they appear in mulitple
-    // parents
-    typedef mpl::bool_<true> is_loading;
-    typedef mpl::bool_<false> is_saving;
-    // the >> operator
-    template<class T>
-    polymorphic_iarchive & operator>>(T & t){
-        return polymorphic_iarchive::operator>>(t);
-    }
-    // the & operator
-    template<class T>
-    polymorphic_iarchive & operator&(T & t){
-        return polymorphic_iarchive::operator&(t);
-    }
-    // register type function
-    template<class T>
-    const basic_pointer_iserializer * 
-    register_type(T * t = NULL){
-        return ArchiveImplementation::register_type(t);
-    }
-    // all current archives take a stream as constructor argument
-    template <class _Elem, class _Tr>
-    polymorphic_iarchive_route(
-        std::basic_istream<_Elem, _Tr> & is,
-        unsigned int flags = 0
-    ) :
-        ArchiveImplementation(is, flags)
-    {}
-    virtual ~polymorphic_iarchive_route(){};
-};
-
-} // namespace detail
-} // namespace archive
-} // namespace boost
-
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
-
-#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
-
-#endif // BOOST_ARCHIVE_DETAIL_POLYMORPHIC_IARCHIVE_DISPATCH_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/detail/polymorphic_oarchive_route.hpp b/contrib/libboost/boost_1_65_0/boost/archive/detail/polymorphic_oarchive_route.hpp
deleted file mode 100644
index b23fd6bf39d..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/detail/polymorphic_oarchive_route.hpp
+++ /dev/null
@@ -1,209 +0,0 @@
-#ifndef BOOST_ARCHIVE_DETAIL_POLYMORPHIC_OARCHIVE_ROUTE_HPP
-#define BOOST_ARCHIVE_DETAIL_POLYMORPHIC_OARCHIVE_ROUTE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// polymorphic_oarchive_route.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <string>
-#include <ostream>
-#include <cstddef> // size_t
-
-#include <boost/config.hpp>
-#if defined(BOOST_NO_STDC_NAMESPACE)
-namespace std{
-    using ::size_t;
-} // namespace std
-#endif
-
-#include <boost/cstdint.hpp>
-#include <boost/integer_traits.hpp>
-#include <boost/archive/polymorphic_oarchive.hpp>
-#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
-
-namespace boost {
-namespace serialization {
-    class extended_type_info;
-} // namespace serialization
-namespace archive {
-namespace detail{
-
-class basic_oserializer;
-class basic_pointer_oserializer;
-
-#ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable : 4511 4512)
-#endif
-
-template<class ArchiveImplementation>
-class polymorphic_oarchive_route :
-    public polymorphic_oarchive,
-    // note: gcc dynamic cross cast fails if the the derivation below is
-    // not public.  I think this is a mistake.
-    public /*protected*/ ArchiveImplementation
-{
-private:
-    // these are used by the serialization library.
-    virtual void save_object(
-        const void *x,
-        const detail::basic_oserializer & bos
-    ){
-        ArchiveImplementation::save_object(x, bos);
-    }
-    virtual void save_pointer(
-        const void * t,
-        const detail::basic_pointer_oserializer * bpos_ptr
-    ){
-        ArchiveImplementation::save_pointer(t, bpos_ptr);
-    }
-    virtual void save_null_pointer(){
-        ArchiveImplementation::save_null_pointer();
-    }
-    // primitive types the only ones permitted by polymorphic archives
-    virtual void save(const bool t){
-        ArchiveImplementation::save(t);
-    }
-    virtual void save(const char t){
-        ArchiveImplementation::save(t);
-    }
-    virtual void save(const signed char t){
-        ArchiveImplementation::save(t);
-    }
-    virtual void save(const unsigned char t){
-        ArchiveImplementation::save(t);
-    }
-    #ifndef BOOST_NO_CWCHAR
-    #ifndef BOOST_NO_INTRINSIC_WCHAR_T
-    virtual void save(const wchar_t t){
-        ArchiveImplementation::save(t);
-    }
-    #endif
-    #endif
-    virtual void save(const short t){
-        ArchiveImplementation::save(t);
-    }
-    virtual void save(const unsigned short t){
-        ArchiveImplementation::save(t);
-    }
-    virtual void save(const int t){
-        ArchiveImplementation::save(t);
-    }
-    virtual void save(const unsigned int t){
-        ArchiveImplementation::save(t);
-    }
-    virtual void save(const long t){
-        ArchiveImplementation::save(t);
-    }
-    virtual void save(const unsigned long t){
-        ArchiveImplementation::save(t);
-    }
-    #if defined(BOOST_HAS_LONG_LONG)
-    virtual void save(const boost::long_long_type t){
-        ArchiveImplementation::save(t);
-    }
-    virtual void save(const boost::ulong_long_type t){
-        ArchiveImplementation::save(t);
-    }
-    #elif defined(BOOST_HAS_MS_INT64)
-    virtual void save(const boost::int64_t t){
-        ArchiveImplementation::save(t);
-    }
-    virtual void save(const boost::uint64_t t){
-        ArchiveImplementation::save(t);
-    }
-    #endif
-    virtual void save(const float t){
-        ArchiveImplementation::save(t);
-    }
-    virtual void save(const double t){
-        ArchiveImplementation::save(t);
-    }
-    virtual void save(const std::string & t){
-        ArchiveImplementation::save(t);
-    }
-    #ifndef BOOST_NO_STD_WSTRING
-    virtual void save(const std::wstring & t){
-        ArchiveImplementation::save(t);
-    }
-    #endif
-    virtual library_version_type get_library_version() const{
-        return ArchiveImplementation::get_library_version();
-    }
-    virtual unsigned int get_flags() const {
-        return ArchiveImplementation::get_flags();
-    }
-    virtual void save_binary(const void * t, std::size_t size){
-        ArchiveImplementation::save_binary(t, size);
-    }
-    // used for xml and other tagged formats default does nothing
-    virtual void save_start(const char * name){
-        ArchiveImplementation::save_start(name);
-    }
-    virtual void save_end(const char * name){
-        ArchiveImplementation::save_end(name);
-    }
-    virtual void end_preamble(){
-        ArchiveImplementation::end_preamble();
-    }
-    virtual void register_basic_serializer(const detail::basic_oserializer & bos){
-        ArchiveImplementation::register_basic_serializer(bos);
-    }
-    virtual helper_collection &
-    get_helper_collection(){
-        return ArchiveImplementation::get_helper_collection();
-    }
-public:
-    // this can't be inheriteded because they appear in mulitple
-    // parents
-    typedef mpl::bool_<false> is_loading;
-    typedef mpl::bool_<true> is_saving;
-    // the << operator
-    template<class T>
-    polymorphic_oarchive & operator<<(T & t){
-        return polymorphic_oarchive::operator<<(t);
-    }
-    // the & operator
-    template<class T>
-    polymorphic_oarchive & operator&(T & t){
-        return polymorphic_oarchive::operator&(t);
-    }
-    // register type function
-    template<class T>
-    const basic_pointer_oserializer * 
-    register_type(T * t = NULL){
-        return ArchiveImplementation::register_type(t);
-    }
-    // all current archives take a stream as constructor argument
-    template <class _Elem, class _Tr>
-    polymorphic_oarchive_route(
-        std::basic_ostream<_Elem, _Tr> & os,
-        unsigned int flags = 0
-    ) :
-        ArchiveImplementation(os, flags)
-    {}
-    virtual ~polymorphic_oarchive_route(){};
-};
-
-} // namespace detail
-} // namespace archive
-} // namespace boost
-
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
-
-#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
-
-#endif // BOOST_ARCHIVE_DETAIL_POLYMORPHIC_OARCHIVE_DISPATCH_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/detail/register_archive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/detail/register_archive.hpp
deleted file mode 100644
index 5ffecc702ce..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/detail/register_archive.hpp
+++ /dev/null
@@ -1,91 +0,0 @@
-// Copyright David Abrahams 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)
-#ifndef BOOST_ARCHIVE_DETAIL_REGISTER_ARCHIVE_DWA2006521_HPP
-# define BOOST_ARCHIVE_DETAIL_REGISTER_ARCHIVE_DWA2006521_HPP
-
-namespace boost { namespace archive { namespace detail { 
-
-// No instantiate_ptr_serialization overloads generated by
-// BOOST_SERIALIZATION_REGISTER_ARCHIVE that lexically follow the call
-// will be seen *unless* they are in an associated namespace of one of
-// the arguments, so we pass one of these along to make sure this
-// namespace is considered.  See temp.dep.candidate (14.6.4.2) in the
-// standard.
-struct adl_tag {};
-
-template <class Archive, class Serializable>
-struct ptr_serialization_support;
-
-// We could've just used ptr_serialization_support, above, but using
-// it with only a forward declaration causes vc6/7 to complain about a
-// missing instantiate member, even if it has one.  This is just a
-// friendly layer of indirection.
-template <class Archive, class Serializable>
-struct _ptr_serialization_support
-  : ptr_serialization_support<Archive,Serializable>
-{
-    typedef int type;
-};
-
-#if defined(__SUNPRO_CC) && (__SUNPRO_CC < 0x5130)
-
-template<int N>
-struct counter : counter<N-1> {};
-template<>
-struct counter<0> {};
-
-template<class Serializable>
-void instantiate_ptr_serialization(Serializable* s, int, adl_tag) {
-    instantiate_ptr_serialization(s, counter<20>());
-}
-
-template<class Archive>
-struct get_counter {
-    static const int value = sizeof(adjust_counter(counter<20>()));
-    typedef counter<value> type;
-    typedef counter<value - 1> prior;
-    typedef char (&next)[value+1];
-};
-
-char adjust_counter(counter<0>);
-template<class Serializable>
-void instantiate_ptr_serialization(Serializable*, counter<0>) {}
-
-#define BOOST_SERIALIZATION_REGISTER_ARCHIVE(Archive)                     \
-namespace boost { namespace archive { namespace detail {                  \
-    get_counter<Archive >::next adjust_counter(get_counter<Archive >::type);\
-    template<class Serializable>                                          \
-    void instantiate_ptr_serialization(Serializable* s,                   \
-        get_counter<Archive >::type) {                                    \
-        ptr_serialization_support<Archive, Serializable> x;               \
-        instantiate_ptr_serialization(s, get_counter<Archive >::prior()); \
-    }\
-}}}
-
-
-#else
-
-// This function gets called, but its only purpose is to participate
-// in overload resolution with the functions declared by
-// BOOST_SERIALIZATION_REGISTER_ARCHIVE, below.
-template <class Serializable>
-void instantiate_ptr_serialization(Serializable*, int, adl_tag ) {}
-
-// The function declaration generated by this macro never actually
-// gets called, but its return type gets instantiated, and that's
-// enough to cause registration of serialization functions between
-// Archive and any exported Serializable type.  See also:
-// boost/serialization/export.hpp
-# define BOOST_SERIALIZATION_REGISTER_ARCHIVE(Archive)                  \
-namespace boost { namespace archive { namespace detail {                \
-                                                                        \
-template <class Serializable>                                           \
-typename _ptr_serialization_support<Archive, Serializable>::type  \
-instantiate_ptr_serialization( Serializable*, Archive*, adl_tag );              \
-                                                                        \
-}}}
-#endif
-}}} // namespace boost::archive::detail
-
-#endif // BOOST_ARCHIVE_DETAIL_INSTANTIATE_SERIALIZE_DWA2006521_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/detail/utf8_codecvt_facet.hpp b/contrib/libboost/boost_1_65_0/boost/archive/detail/utf8_codecvt_facet.hpp
deleted file mode 100644
index a40104abea6..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/detail/utf8_codecvt_facet.hpp
+++ /dev/null
@@ -1,39 +0,0 @@
-// Copyright (c) 2001 Ronald Garcia, Indiana University (garcia@osl.iu.edu)
-// Andrew Lumsdaine, Indiana University (lums@osl.iu.edu).
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_ARCHIVE_DETAIL_UTF8_CODECVT_FACET_HPP
-#define BOOST_ARCHIVE_DETAIL_UTF8_CODECVT_FACET_HPP
-
-#include <boost/config.hpp>
-
-#ifdef BOOST_NO_STD_WSTREAMBUF
-#error "wide char i/o not supported on this platform"
-#endif
-
-// std::codecvt_utf8 doesn't seem to work for any versions of msvc
-
-#if defined(_MSC_VER) || defined(BOOST_NO_CXX11_HDR_CODECVT)
-    // use boost's utf8 codecvt facet
-    #include <boost/archive/detail/decl.hpp>
-    #define BOOST_UTF8_BEGIN_NAMESPACE \
-         namespace boost { namespace archive { namespace detail {
-    #define BOOST_UTF8_DECL BOOST_ARCHIVE_DECL
-    #define BOOST_UTF8_END_NAMESPACE }}}
-
-    #include <boost/detail/utf8_codecvt_facet.hpp>
-
-    #undef BOOST_UTF8_END_NAMESPACE
-    #undef BOOST_UTF8_DECL
-    #undef BOOST_UTF8_BEGIN_NAMESPACE
-#else
-    // use the standard vendor supplied facet
-    #include <codecvt>
-    namespace boost { namespace archive { namespace detail {
-        typedef std::codecvt_utf8<wchar_t> utf8_codecvt_facet;
-    } } }
-#endif
-
-#endif // BOOST_ARCHIVE_DETAIL_UTF8_CODECVT_FACET_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/dinkumware.hpp b/contrib/libboost/boost_1_65_0/boost/archive/dinkumware.hpp
deleted file mode 100644
index 90ba6271cdd..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/dinkumware.hpp
+++ /dev/null
@@ -1,224 +0,0 @@
-#ifndef BOOST_ARCHIVE_DINKUMWARE_HPP
-#define BOOST_ARCHIVE_DINKUMWARE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// dinkumware.hpp:
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-// this file adds a couple of things that are missing from the dinkumware
-// implementation of the standard library.
-
-#include <iterator>
-#include <string>
-
-#include <boost/config.hpp>
-#include <boost/cstdint.hpp>
-
-namespace std {
-
-// define i/o operators for 64 bit integers
-template<class CharType>
-basic_ostream<CharType> & 
-operator<<(basic_ostream<CharType> & os, boost::uint64_t t){
-    // octal rendering of 64 bit number would be 22 octets + eos
-    CharType d[23];
-    unsigned int radix;
-
-    if(os.flags() & (int)std::ios_base::hex)
-        radix = 16;
-    else
-    if(os.flags() & (int)std::ios_base::oct)
-        radix = 8;
-    else
-    //if(s.flags() & (int)std::ios_base::dec)
-        radix =  10;
-    unsigned int i = 0;
-    do{
-        unsigned int j = t % radix;
-        d[i++] = j + ((j < 10) ? '0' : ('a' - 10));
-        t /= radix;
-    }
-    while(t > 0);
-    d[i--] = '\0';
-
-    // reverse digits
-    unsigned int j = 0;
-    while(j < i){
-        CharType k = d[i];
-        d[i] = d[j];
-        d[j] = k;
-        --i;++j;
-    }
-    os << d;
-    return os;
-
-}
-
-template<class CharType>
-basic_ostream<CharType> & 
-operator<<(basic_ostream<CharType> &os, boost::int64_t t){
-    if(0 <= t){
-        os << static_cast<boost::uint64_t>(t);
-    }
-    else{
-        os.put('-');
-        os << -t;
-    }
-    return os;
-}
-
-template<class CharType>
-basic_istream<CharType> & 
-operator>>(basic_istream<CharType> &is, boost::int64_t & t){
-    CharType d;
-    do{
-        d = is.get();
-    }
-    while(::isspace(d));
-    bool negative = (d == '-');
-    if(negative)
-        d = is.get();
-    unsigned int radix;
-    if(is.flags() & (int)std::ios_base::hex)
-        radix = 16;
-    else
-    if(is.flags() & (int)std::ios_base::oct)
-        radix = 8;
-    else
-    //if(s.flags() & (int)std::ios_base::dec)
-        radix =  10;
-    t = 0;
-    do{
-        if('0' <= d && d <= '9')
-            t = t * radix + (d - '0');
-        else
-        if('a' <= d && d <= 'f')
-            t = t * radix + (d - 'a' + 10);
-        else
-            break;
-        d = is.get();
-    }
-    while(!is.fail());
-    // restore the delimiter
-    is.putback(d);
-    is.clear();
-    if(negative)
-        t = -t;
-    return is;
-}
-
-template<class CharType>
-basic_istream<CharType> & 
-operator>>(basic_istream<CharType> &is, boost::uint64_t & t){
-    boost::int64_t it;
-    is >> it;
-    t = it;
-    return is;
-}
-
-//#endif
-
-template<>
-class back_insert_iterator<basic_string<char> > : public 
-    iterator<output_iterator_tag, char>
-{
-public:
-    typedef basic_string<char> container_type;
-    typedef container_type::reference reference;
-
-    explicit back_insert_iterator(container_type & s)
-        : container(& s)
-    {}    // construct with container
-    
-    back_insert_iterator<container_type> & operator=(
-        container_type::const_reference Val_
-    ){    // push value into container
-        //container->push_back(Val_);
-        *container += Val_;
-        return (*this);
-    }
-
-    back_insert_iterator<container_type> & operator*(){
-        return (*this);
-    }
-
-    back_insert_iterator<container_type> & operator++(){
-        // pretend to preincrement
-        return (*this);
-    }
-
-    back_insert_iterator<container_type> operator++(int){
-        // pretend to postincrement
-        return (*this);
-    }
-
-protected:
-    container_type *container;    // pointer to container
-};
-
-template<char> 
-inline back_insert_iterator<basic_string<char> > back_inserter(
-    basic_string<char> & s
-){
-    return (std::back_insert_iterator<basic_string<char> >(s));
-}
-
-template<>
-class back_insert_iterator<basic_string<wchar_t> > : public 
-    iterator<output_iterator_tag, wchar_t>
-{
-public:
-    typedef basic_string<wchar_t> container_type;
-    typedef container_type::reference reference;
-
-    explicit back_insert_iterator(container_type & s)
-        : container(& s)
-    {}    // construct with container
-    
-    back_insert_iterator<container_type> & operator=(
-        container_type::const_reference Val_
-    ){    // push value into container
-        //container->push_back(Val_);
-        *container += Val_;
-        return (*this);
-    }
-
-    back_insert_iterator<container_type> & operator*(){
-        return (*this);
-    }
-
-    back_insert_iterator<container_type> & operator++(){
-        // pretend to preincrement
-        return (*this);
-    }
-
-    back_insert_iterator<container_type> operator++(int){
-        // pretend to postincrement
-        return (*this);
-    }
-
-protected:
-    container_type *container;    // pointer to container
-};
-
-template<wchar_t> 
-inline back_insert_iterator<basic_string<wchar_t> > back_inserter(
-    basic_string<wchar_t> & s
-){
-    return (std::back_insert_iterator<basic_string<wchar_t> >(s));
-}
-
-} // namespace std
-
-#endif //BOOST_ARCHIVE_DINKUMWARE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/impl/archive_serializer_map.ipp b/contrib/libboost/boost_1_65_0/boost/archive/impl/archive_serializer_map.ipp
deleted file mode 100644
index 7f163ec4076..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/impl/archive_serializer_map.ipp
+++ /dev/null
@@ -1,75 +0,0 @@
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// archive_serializer_map.ipp:
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-
-//  See http://www.boost.org for updates, documentation, and revision history.
-
-//////////////////////////////////////////////////////////////////////
-// implementation of basic_text_iprimitive overrides for the combination
-// of template parameters used to implement a text_iprimitive
-
-#include <boost/config.hpp>
-#include <boost/archive/detail/archive_serializer_map.hpp>
-#include <boost/archive/detail/basic_serializer_map.hpp>
-#include <boost/serialization/singleton.hpp>
-
-namespace boost {
-namespace archive {
-namespace detail {
-
-#ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable : 4511 4512)
-#endif
-
-namespace extra_detail { // anon
-    template<class Archive>
-    class map : public basic_serializer_map 
-    {};
-}
-
-#ifdef BOOST_MSVC
-#  pragma warning(pop)
-#endif
-
-template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL bool
-archive_serializer_map<Archive>::insert(const basic_serializer * bs){
-    return boost::serialization::singleton<
-        extra_detail::map<Archive>
-    >::get_mutable_instance().insert(bs);
-}
-
-template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-archive_serializer_map<Archive>::erase(const basic_serializer * bs){
-    BOOST_ASSERT(! boost::serialization::singleton<
-            extra_detail::map<Archive>
-        >::is_destroyed()
-    );
-    if(boost::serialization::singleton<
-        extra_detail::map<Archive>
-    >::is_destroyed())
-        return;
-    boost::serialization::singleton<
-        extra_detail::map<Archive>
-    >::get_mutable_instance().erase(bs);
-}
-
-template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL const basic_serializer *
-archive_serializer_map<Archive>::find(
-    const boost::serialization::extended_type_info & eti
-) {
-    return boost::serialization::singleton<
-        extra_detail::map<Archive>
-    >::get_const_instance().find(eti);
-}
-
-} // namespace detail
-} // namespace archive
-} // namespace boost
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/impl/basic_binary_iarchive.ipp b/contrib/libboost/boost_1_65_0/boost/archive/impl/basic_binary_iarchive.ipp
deleted file mode 100644
index d5619ab6cf3..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/impl/basic_binary_iarchive.ipp
+++ /dev/null
@@ -1,134 +0,0 @@
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// basic_binary_iarchive.ipp:
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-#include <string>
-#include <boost/assert.hpp>
-#include <algorithm>
-#include <cstring>
-
-#include <boost/config.hpp>
-#if defined(BOOST_NO_STDC_NAMESPACE)
-namespace std{ 
-    using ::memcpy; 
-    using ::strlen;
-    using ::size_t;
-}
-#endif
-
-#include <boost/detail/workaround.hpp>
-#include <boost/detail/endian.hpp>
-
-#include <boost/archive/basic_binary_iarchive.hpp>
-
-namespace boost {
-namespace archive {
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// implementation of binary_binary_archive
-template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-basic_binary_iarchive<Archive>::load_override(class_name_type & t){
-    std::string cn;
-    cn.reserve(BOOST_SERIALIZATION_MAX_KEY_SIZE);
-    load_override(cn);
-    if(cn.size() > (BOOST_SERIALIZATION_MAX_KEY_SIZE - 1))
-        boost::serialization::throw_exception(
-            archive_exception(archive_exception::invalid_class_name)
-        );
-    std::memcpy(t, cn.data(), cn.size());
-    // borland tweak
-    t.t[cn.size()] = '\0';
-}
-
-template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-basic_binary_iarchive<Archive>::init(void){
-    // read signature in an archive version independent manner
-    std::string file_signature;
-    
-    #if 0 // commented out since it interfers with derivation
-    BOOST_TRY {
-        std::size_t l;
-        this->This()->load(l);
-        if(l == std::strlen(BOOST_ARCHIVE_SIGNATURE())) {
-            // borland de-allocator fixup
-            #if BOOST_WORKAROUND(_RWSTD_VER, BOOST_TESTED_AT(20101))
-            if(NULL != file_signature.data())
-            #endif
-                file_signature.resize(l);
-            // note breaking a rule here - could be a problem on some platform
-            if(0 < l)
-                this->This()->load_binary(&(*file_signature.begin()), l);
-        }
-    }
-    BOOST_CATCH(archive_exception const &) {  // catch stream_error archive exceptions
-        // will cause invalid_signature archive exception to be thrown below
-        file_signature = "";   
-    }
-    BOOST_CATCH_END
-    #else
-    // https://svn.boost.org/trac/boost/ticket/7301
-    * this->This() >> file_signature;
-    #endif
-
-    if(file_signature != BOOST_ARCHIVE_SIGNATURE())
-        boost::serialization::throw_exception(
-            archive_exception(archive_exception::invalid_signature)
-        );
-
-    // make sure the version of the reading archive library can
-    // support the format of the archive being read
-    library_version_type input_library_version;
-    //* this->This() >> input_library_version;
-    {
-        int v = 0;
-        v = this->This()->m_sb.sbumpc();
-        #if defined(BOOST_LITTLE_ENDIAN)
-        if(v < 6){
-            ;
-        }
-        else
-        if(v < 7){
-            // version 6 - next byte should be zero
-            this->This()->m_sb.sbumpc();
-        }
-        else
-        if(v < 8){
-            int x1;
-            // version 7 = might be followed by zero or some other byte
-            x1 = this->This()->m_sb.sgetc();
-            // it's =a zero, push it back
-            if(0 == x1)
-                this->This()->m_sb.sbumpc();
-        }
-        else{
-            // version 8+ followed by a zero
-            this->This()->m_sb.sbumpc();
-        }
-        #elif defined(BOOST_BIG_ENDIAN)
-        if(v == 0)
-            v = this->This()->m_sb.sbumpc();
-        #endif
-        input_library_version = static_cast<library_version_type>(v);
-    }
-    
-    #if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3205))
-    this->set_library_version(input_library_version);
-    #else
-    detail::basic_iarchive::set_library_version(input_library_version);
-    #endif
-    
-    if(BOOST_ARCHIVE_VERSION() < input_library_version)
-        boost::serialization::throw_exception(
-            archive_exception(archive_exception::unsupported_version)
-        );
-}
-
-} // namespace archive
-} // namespace boost
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/impl/basic_binary_iprimitive.ipp b/contrib/libboost/boost_1_65_0/boost/archive/impl/basic_binary_iprimitive.ipp
deleted file mode 100644
index bbe933ccf63..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/impl/basic_binary_iprimitive.ipp
+++ /dev/null
@@ -1,171 +0,0 @@
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// basic_binary_iprimitive.ipp:
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/assert.hpp>
-#include <cstddef> // size_t, NULL
-#include <cstring> // memcpy
-
-#include <boost/config.hpp>
-#if defined(BOOST_NO_STDC_NAMESPACE)
-namespace std{ 
-    using ::size_t;
-    using ::memcpy;
-} // namespace std
-#endif
-
-#include <boost/serialization/throw_exception.hpp>
-#include <boost/core/no_exceptions_support.hpp>
-#include <boost/archive/archive_exception.hpp>
-#include <boost/archive/basic_binary_iprimitive.hpp> 
-
-namespace boost {
-namespace archive {
-
-//////////////////////////////////////////////////////////////////////
-// implementation of basic_binary_iprimitive
-
-template<class Archive, class Elem, class Tr>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-basic_binary_iprimitive<Archive, Elem, Tr>::init()
-{
-    // Detect  attempts to pass native binary archives across
-    // incompatible platforms. This is not fool proof but its
-    // better than nothing.
-    unsigned char size;
-    this->This()->load(size);
-    if(sizeof(int) != size)
-        boost::serialization::throw_exception(
-            archive_exception(
-                archive_exception::incompatible_native_format,
-                "size of int"
-            )
-        );
-    this->This()->load(size);
-    if(sizeof(long) != size)
-        boost::serialization::throw_exception(
-            archive_exception(
-                archive_exception::incompatible_native_format,
-                "size of long"
-            )
-        );
-    this->This()->load(size);
-    if(sizeof(float) != size)
-        boost::serialization::throw_exception(
-            archive_exception(
-                archive_exception::incompatible_native_format,
-                "size of float"
-            )
-        );
-    this->This()->load(size);
-    if(sizeof(double) != size)
-        boost::serialization::throw_exception(
-            archive_exception(
-                archive_exception::incompatible_native_format,
-                "size of double"
-            )
-        );
-
-    // for checking endian
-    int i;
-    this->This()->load(i);
-    if(1 != i)
-        boost::serialization::throw_exception(
-            archive_exception(
-                archive_exception::incompatible_native_format,
-                "endian setting"
-            )
-        );
-}
-
-#ifndef BOOST_NO_CWCHAR
-template<class Archive, class Elem, class Tr>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-basic_binary_iprimitive<Archive, Elem, Tr>::load(wchar_t * ws)
-{
-    std::size_t l; // number of wchar_t !!!
-    this->This()->load(l);
-    load_binary(ws, l * sizeof(wchar_t) / sizeof(char));
-    ws[l] = L'\0';
-}
-#endif
-
-template<class Archive, class Elem, class Tr>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-basic_binary_iprimitive<Archive, Elem, Tr>::load(std::string & s)
-{
-    std::size_t l;
-    this->This()->load(l);
-    // borland de-allocator fixup
-    #if BOOST_WORKAROUND(_RWSTD_VER, BOOST_TESTED_AT(20101))
-    if(NULL != s.data())
-    #endif
-        s.resize(l);
-    // note breaking a rule here - could be a problem on some platform
-    if(0 < l)
-        load_binary(&(*s.begin()), l);
-}
-
-template<class Archive, class Elem, class Tr>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-basic_binary_iprimitive<Archive, Elem, Tr>::load(char * s)
-{
-    std::size_t l;
-    this->This()->load(l);
-    load_binary(s, l);
-    s[l] = '\0';
-}
-
-#ifndef BOOST_NO_STD_WSTRING
-template<class Archive, class Elem, class Tr>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-basic_binary_iprimitive<Archive, Elem, Tr>::load(std::wstring & ws)
-{
-    std::size_t l;
-    this->This()->load(l);
-    // borland de-allocator fixup
-    #if BOOST_WORKAROUND(_RWSTD_VER, BOOST_TESTED_AT(20101))
-    if(NULL != ws.data())
-    #endif
-        ws.resize(l);
-    // note breaking a rule here - is could be a problem on some platform
-    load_binary(const_cast<wchar_t *>(ws.data()), l * sizeof(wchar_t) / sizeof(char));
-}
-#endif
-
-template<class Archive, class Elem, class Tr>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL
-basic_binary_iprimitive<Archive, Elem, Tr>::basic_binary_iprimitive(
-    std::basic_streambuf<Elem, Tr> & sb, 
-    bool no_codecvt
-) :
-#ifndef BOOST_NO_STD_LOCALE
-    m_sb(sb),
-    codecvt_null_facet(1),
-    locale_saver(m_sb),
-    archive_locale(sb.getloc(), & codecvt_null_facet)
-{
-    if(! no_codecvt){
-        m_sb.pubsync();
-        m_sb.pubimbue(archive_locale);
-    }
-}
-#else
-    m_sb(sb)
-{}
-#endif
-
-// scoped_ptr requires that g be a complete type at time of
-// destruction so define destructor here rather than in the header
-template<class Archive, class Elem, class Tr>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL
-basic_binary_iprimitive<Archive, Elem, Tr>::~basic_binary_iprimitive(){}
-
-} // namespace archive
-} // namespace boost
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/impl/basic_binary_oarchive.ipp b/contrib/libboost/boost_1_65_0/boost/archive/impl/basic_binary_oarchive.ipp
deleted file mode 100644
index d5a019d32bc..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/impl/basic_binary_oarchive.ipp
+++ /dev/null
@@ -1,42 +0,0 @@
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// basic_binary_oarchive.ipp:
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-#include <string>
-#include <boost/assert.hpp>
-#include <algorithm>
-#include <cstring>
-
-#include <boost/config.hpp>
-#if defined(BOOST_NO_STDC_NAMESPACE)
-namespace std{ 
-    using ::memcpy; 
-}
-#endif
-
-#include <boost/archive/basic_binary_oarchive.hpp>
-
-namespace boost {
-namespace archive {
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// implementation of binary_binary_oarchive
-
-template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-basic_binary_oarchive<Archive>::init(){
-    // write signature in an archive version independent manner
-    const std::string file_signature(BOOST_ARCHIVE_SIGNATURE());
-    * this->This() << file_signature;
-    // write library version
-    const library_version_type v(BOOST_ARCHIVE_VERSION());
-    * this->This() << v;
-}
-
-} // namespace archive
-} // namespace boost
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/impl/basic_binary_oprimitive.ipp b/contrib/libboost/boost_1_65_0/boost/archive/impl/basic_binary_oprimitive.ipp
deleted file mode 100644
index 7b042173a48..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/impl/basic_binary_oprimitive.ipp
+++ /dev/null
@@ -1,126 +0,0 @@
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// basic_binary_oprimitive.ipp:
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <ostream>
-#include <cstddef> // NULL
-#include <cstring>
-
-#include <boost/config.hpp>
-
-#if defined(BOOST_NO_STDC_NAMESPACE) && ! defined(__LIBCOMO__)
-namespace std{ 
-    using ::strlen; 
-} // namespace std
-#endif
-
-#ifndef BOOST_NO_CWCHAR
-#include <cwchar>
-#ifdef BOOST_NO_STDC_NAMESPACE
-namespace std{ using ::wcslen; }
-#endif
-#endif
-
-#include <boost/archive/basic_binary_oprimitive.hpp>
-#include <boost/core/no_exceptions_support.hpp>
-
-namespace boost {
-namespace archive {
-
-//////////////////////////////////////////////////////////////////////
-// implementation of basic_binary_oprimitive
-
-template<class Archive, class Elem, class Tr>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-basic_binary_oprimitive<Archive, Elem, Tr>::init()
-{
-    // record native sizes of fundamental types
-    // this is to permit detection of attempts to pass
-    // native binary archives accross incompatible machines.
-    // This is not foolproof but its better than nothing.
-    this->This()->save(static_cast<unsigned char>(sizeof(int)));
-    this->This()->save(static_cast<unsigned char>(sizeof(long)));
-    this->This()->save(static_cast<unsigned char>(sizeof(float)));
-    this->This()->save(static_cast<unsigned char>(sizeof(double)));
-    // for checking endianness
-    this->This()->save(int(1));
-}
-
-template<class Archive, class Elem, class Tr>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-basic_binary_oprimitive<Archive, Elem, Tr>::save(const char * s)
-{
-    std::size_t l = std::strlen(s);
-    this->This()->save(l);
-    save_binary(s, l);
-}
-
-template<class Archive, class Elem, class Tr>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-basic_binary_oprimitive<Archive, Elem, Tr>::save(const std::string &s)
-{
-    std::size_t l = static_cast<std::size_t>(s.size());
-    this->This()->save(l);
-    save_binary(s.data(), l);
-}
-
-#ifndef BOOST_NO_CWCHAR
-#ifndef BOOST_NO_INTRINSIC_WCHAR_T
-template<class Archive, class Elem, class Tr>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-basic_binary_oprimitive<Archive, Elem, Tr>::save(const wchar_t * ws)
-{
-    std::size_t l = std::wcslen(ws);
-    this->This()->save(l);
-    save_binary(ws, l * sizeof(wchar_t) / sizeof(char));
-}
-#endif
-
-#ifndef BOOST_NO_STD_WSTRING
-template<class Archive, class Elem, class Tr>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-basic_binary_oprimitive<Archive, Elem, Tr>::save(const std::wstring &ws)
-{
-    std::size_t l = ws.size();
-    this->This()->save(l);
-    save_binary(ws.data(), l * sizeof(wchar_t) / sizeof(char));
-}
-#endif
-#endif // BOOST_NO_CWCHAR
-
-template<class Archive, class Elem, class Tr>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL
-basic_binary_oprimitive<Archive, Elem, Tr>::basic_binary_oprimitive(
-    std::basic_streambuf<Elem, Tr> & sb, 
-    bool no_codecvt
-) : 
-#ifndef BOOST_NO_STD_LOCALE
-    m_sb(sb),
-    codecvt_null_facet(1),
-    locale_saver(m_sb),
-    archive_locale(sb.getloc(), & codecvt_null_facet)
-{
-    if(! no_codecvt){
-        m_sb.pubsync();
-        m_sb.pubimbue(archive_locale);
-    }
-}
-#else
-    m_sb(sb)
-{}
-#endif
-
-// scoped_ptr requires that g be a complete type at time of
-// destruction so define destructor here rather than in the header
-template<class Archive, class Elem, class Tr>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL
-basic_binary_oprimitive<Archive, Elem, Tr>::~basic_binary_oprimitive(){}
-
-} // namespace archive
-} // namespace boost
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/impl/basic_text_iarchive.ipp b/contrib/libboost/boost_1_65_0/boost/archive/impl/basic_text_iarchive.ipp
deleted file mode 100644
index 9ec8c6588c8..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/impl/basic_text_iarchive.ipp
+++ /dev/null
@@ -1,76 +0,0 @@
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// basic_text_iarchive.ipp:
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-#include <string>
-#include <algorithm>
-#include <cstring>
-
-#include <boost/config.hpp>
-#if defined(BOOST_NO_STDC_NAMESPACE)
-namespace std{ 
-    using ::memcpy; 
-}
-#endif
-
-#include <boost/detail/workaround.hpp>
-#include <boost/serialization/string.hpp>
-#include <boost/archive/basic_text_iarchive.hpp>
-
-namespace boost {
-namespace archive {
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// implementation of text_text_archive
-
-template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-basic_text_iarchive<Archive>::load_override(class_name_type & t){
-    std::string cn;
-    cn.reserve(BOOST_SERIALIZATION_MAX_KEY_SIZE);
-    load_override(cn);
-    if(cn.size() > (BOOST_SERIALIZATION_MAX_KEY_SIZE - 1))
-        boost::serialization::throw_exception(
-            archive_exception(archive_exception::invalid_class_name)
-        );
-    std::memcpy(t, cn.data(), cn.size());
-    // borland tweak
-    t.t[cn.size()] = '\0';
-}
-
-template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-basic_text_iarchive<Archive>::init(void){
-    // read signature in an archive version independent manner
-    std::string file_signature;
-    * this->This() >> file_signature;
-    if(file_signature != BOOST_ARCHIVE_SIGNATURE())
-        boost::serialization::throw_exception(
-            archive_exception(archive_exception::invalid_signature)
-        );
-
-    // make sure the version of the reading archive library can
-    // support the format of the archive being read
-    library_version_type input_library_version;
-    * this->This() >> input_library_version;
-
-    #if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3205))
-    this->set_library_version(input_library_version);
-    #else
-    detail::basic_iarchive::set_library_version(input_library_version);
-    #endif
-
-    // extra little .t is to get around borland quirk
-    if(BOOST_ARCHIVE_VERSION() < input_library_version)
-        boost::serialization::throw_exception(
-            archive_exception(archive_exception::unsupported_version)
-        );
-}
-
-} // namespace archive
-} // namespace boost
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/impl/basic_text_iprimitive.ipp b/contrib/libboost/boost_1_65_0/boost/archive/impl/basic_text_iprimitive.ipp
deleted file mode 100644
index 4e44728068d..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/impl/basic_text_iprimitive.ipp
+++ /dev/null
@@ -1,137 +0,0 @@
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// basic_text_iprimitive.ipp:
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-
-//  See http://www.boost.org for updates, documentation, and revision history.
-
-#include <cstddef> // size_t, NULL
-#include <limits> // NULL
-
-#include <boost/config.hpp>
-#if defined(BOOST_NO_STDC_NAMESPACE)
-namespace std{ 
-    using ::size_t; 
-} // namespace std
-#endif
-
-#include <boost/serialization/throw_exception.hpp>
-
-#include <boost/archive/basic_text_iprimitive.hpp>
-
-#include <boost/archive/iterators/remove_whitespace.hpp>
-#include <boost/archive/iterators/istream_iterator.hpp>
-#include <boost/archive/iterators/binary_from_base64.hpp>
-#include <boost/archive/iterators/transform_width.hpp>
-
-namespace boost {
-namespace archive {
-
-namespace detail {
-    template<class CharType>
-    static inline bool is_whitespace(CharType c);
-
-    template<>
-    inline bool is_whitespace(char t){
-        return 0 != std::isspace(t);
-    }
-
-    #ifndef BOOST_NO_CWCHAR
-    template<>
-    inline bool is_whitespace(wchar_t t){
-        return 0 != std::iswspace(t);
-    }
-    #endif
-} // detail
-
-// translate base64 text into binary and copy into buffer
-// until buffer is full.
-template<class IStream>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-basic_text_iprimitive<IStream>::load_binary(
-    void *address, 
-    std::size_t count
-){
-    typedef typename IStream::char_type CharType;
-    
-    if(0 == count)
-        return;
-        
-    BOOST_ASSERT(
-        static_cast<std::size_t>((std::numeric_limits<std::streamsize>::max)())
-        > (count + sizeof(CharType) - 1)/sizeof(CharType)
-    );
-        
-    if(is.fail())
-        boost::serialization::throw_exception(
-            archive_exception(archive_exception::input_stream_error)
-        );
-    // convert from base64 to binary
-    typedef typename
-        iterators::transform_width<
-            iterators::binary_from_base64<
-                iterators::remove_whitespace<
-                    iterators::istream_iterator<CharType>
-                >
-                ,typename IStream::int_type
-            >
-            ,8
-            ,6
-            ,CharType
-        > 
-        binary;
-        
-    binary i = binary(iterators::istream_iterator<CharType>(is));
-
-    char * caddr = static_cast<char *>(address);
-    
-    // take care that we don't increment anymore than necessary
-    while(count-- > 0){
-        *caddr++ = static_cast<char>(*i++);
-    }
-
-    // skip over any excess input
-    for(;;){
-        typename IStream::int_type r;
-        r = is.get();
-        if(is.eof())
-            break;
-        if(detail::is_whitespace(static_cast<CharType>(r)))
-            break;
-    }
-}
-    
-template<class IStream>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL
-basic_text_iprimitive<IStream>::basic_text_iprimitive(
-    IStream  &is_,
-    bool no_codecvt
-) :
-    is(is_),
-    flags_saver(is_),
-    precision_saver(is_),
-#ifndef BOOST_NO_STD_LOCALE
-    codecvt_null_facet(1),
-    archive_locale(is.getloc(), & codecvt_null_facet),
-    locale_saver(is)
-{
-    if(! no_codecvt){
-        is_.sync();
-        is_.imbue(archive_locale);
-    }
-    is_ >> std::noboolalpha;
-}
-#else
-{}
-#endif
-
-template<class IStream>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL
-basic_text_iprimitive<IStream>::~basic_text_iprimitive(){
-}
-
-} // namespace archive
-} // namespace boost
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/impl/basic_text_oarchive.ipp b/contrib/libboost/boost_1_65_0/boost/archive/impl/basic_text_oarchive.ipp
deleted file mode 100644
index 44bc1401fd6..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/impl/basic_text_oarchive.ipp
+++ /dev/null
@@ -1,62 +0,0 @@
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// basic_text_oarchive.ipp:
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-#include <string>
-#include <boost/assert.hpp>
-#include <cstring>
-
-#include <boost/config.hpp>
-#if defined(BOOST_NO_STDC_NAMESPACE)
-namespace std{ 
-    using ::memcpy; 
-}
-#endif
-
-#include <boost/archive/basic_text_oarchive.hpp>
-
-namespace boost {
-namespace archive {
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// implementation of basic_text_oarchive
-
-template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-basic_text_oarchive<Archive>::newtoken()
-{
-    switch(delimiter){
-    default:
-        BOOST_ASSERT(false);
-        break;
-    case eol:
-        this->This()->put('\n');
-        delimiter = space;
-        break;
-    case space:
-        this->This()->put(' ');
-        break;
-    case none:
-        delimiter = space;
-        break;
-    }
-}
-
-template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-basic_text_oarchive<Archive>::init(){
-    // write signature in an archive version independent manner
-    const std::string file_signature(BOOST_ARCHIVE_SIGNATURE());
-    * this->This() << file_signature;
-    // write library version
-    const library_version_type v(BOOST_ARCHIVE_VERSION());
-    * this->This() << v;
-}
-
-} // namespace archive
-} // namespace boost
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/impl/basic_text_oprimitive.ipp b/contrib/libboost/boost_1_65_0/boost/archive/impl/basic_text_oprimitive.ipp
deleted file mode 100644
index 6030fd44c57..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/impl/basic_text_oprimitive.ipp
+++ /dev/null
@@ -1,115 +0,0 @@
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// basic_text_oprimitive.ipp:
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <cstddef> // NULL
-#include <algorithm> // std::copy
-#include <exception> // std::uncaught_exception
-#include <boost/config.hpp>
-#if defined(BOOST_NO_STDC_NAMESPACE)
-namespace std{ 
-    using ::size_t; 
-} // namespace std
-#endif
-
-#include <boost/archive/basic_text_oprimitive.hpp>
-
-#include <boost/archive/iterators/base64_from_binary.hpp>
-#include <boost/archive/iterators/insert_linebreaks.hpp>
-#include <boost/archive/iterators/transform_width.hpp>
-#include <boost/archive/iterators/ostream_iterator.hpp>
-
-namespace boost {
-namespace archive {
-
-// translate to base64 and copy in to buffer.
-template<class OStream>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-basic_text_oprimitive<OStream>::save_binary(
-    const void *address, 
-    std::size_t count
-){
-    typedef typename OStream::char_type CharType;
-    
-    if(0 == count)
-        return;
-    
-    if(os.fail())
-        boost::serialization::throw_exception(
-            archive_exception(archive_exception::output_stream_error)
-        );
-        
-    os.put('\n');
-    
-    typedef 
-        boost::archive::iterators::insert_linebreaks<
-            boost::archive::iterators::base64_from_binary<
-                boost::archive::iterators::transform_width<
-                    const char *,
-                    6,
-                    8
-                >
-            > 
-            ,76
-            ,const char // cwpro8 needs this
-        > 
-        base64_text;
-
-    boost::archive::iterators::ostream_iterator<CharType> oi(os);
-    std::copy(
-        base64_text(static_cast<const char *>(address)),
-        base64_text(
-            static_cast<const char *>(address) + count
-        ),
-        oi
-    );
-    
-    std::size_t tail = count % 3;
-    if(tail > 0){
-        *oi++ = '=';
-        if(tail < 2)
-            *oi = '=';
-    }
-}
-
-template<class OStream>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL
-basic_text_oprimitive<OStream>::basic_text_oprimitive(
-    OStream & os_,
-    bool no_codecvt
-) : 
-    os(os_),
-    flags_saver(os_),
-    precision_saver(os_),
-#ifndef BOOST_NO_STD_LOCALE
-    codecvt_null_facet(1),
-    archive_locale(os.getloc(), & codecvt_null_facet),
-    locale_saver(os)
-{
-    if(! no_codecvt){
-        os_.flush();
-        os_.imbue(archive_locale);
-    }
-    os_ << std::noboolalpha;
-}
-#else
-{}
-#endif
-
-
-template<class OStream>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL
-basic_text_oprimitive<OStream>::~basic_text_oprimitive(){
-    if(std::uncaught_exception())
-        return;
-    os << std::endl;
-}
-
-} //namespace boost 
-} //namespace archive 
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/impl/basic_xml_grammar.hpp b/contrib/libboost/boost_1_65_0/boost/archive/impl/basic_xml_grammar.hpp
deleted file mode 100644
index 6d4e4683f6a..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/impl/basic_xml_grammar.hpp
+++ /dev/null
@@ -1,173 +0,0 @@
-#ifndef BOOST_ARCHIVE_BASIC_XML_GRAMMAR_HPP
-#define BOOST_ARCHIVE_BASIC_XML_GRAMMAR_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// basic_xml_grammar.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-// this module is derived from simplexml.cpp - an example shipped as part of
-// the spirit parser.  This example contains the following notice:
-/*=============================================================================
-    simplexml.cpp
-
-    Spirit V1.3
-    URL: http://spirit.sourceforge.net/
-
-    Copyright (c) 2001, Daniel C. Nuffer
-
-    This software is provided 'as-is', without any express or implied
-    warranty. In no event will the copyright holder be held liable for
-    any damages arising from the use of this software.
-
-    Permission is granted to anyone to use this software for any purpose,
-    including commercial applications, and to alter it and redistribute
-    it freely, subject to the following restrictions:
-
-    1.  The origin of this software must not be misrepresented; you must
-        not claim that you wrote the original software. If you use this
-        software in a product, an acknowledgment in the product documentation
-        would be appreciated but is not required.
-
-    2.  Altered source versions must be plainly marked as such, and must
-        not be misrepresented as being the original software.
-
-    3.  This notice may not be removed or altered from any source
-        distribution.
-=============================================================================*/
-#include <string>
-
-#include <boost/config.hpp>
-#include <boost/detail/workaround.hpp>
-
-#include <boost/spirit/include/classic_rule.hpp>
-#include <boost/spirit/include/classic_chset.hpp>
-
-#include <boost/archive/basic_archive.hpp>
-#include <boost/serialization/tracking.hpp>
-#include <boost/serialization/version.hpp>
-
-namespace boost {
-namespace archive {
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// XML grammar parsing
-
-template<class CharType>
-class basic_xml_grammar {
-public:
-    // The following is not necessary according to DR45, but at least
-    // one compiler (Compaq C++ 6.5 in strict_ansi mode) chokes otherwise.
-    struct return_values;
-    friend struct return_values;
-    
-private:
-    typedef typename std::basic_istream<CharType> IStream;
-    typedef typename std::basic_string<CharType> StringType;
-    typedef typename boost::spirit::classic::chset<CharType> chset_t;
-    typedef typename boost::spirit::classic::chlit<CharType> chlit_t;
-    typedef typename boost::spirit::classic::scanner<
-        typename  std::basic_string<CharType>::iterator
-    > scanner_t;
-    typedef typename boost::spirit::classic::rule<scanner_t> rule_t;
-    // Start grammar definition
-    rule_t    
-        Reference,
-        Eq, 
-        STag,
-        ETag,
-        LetterOrUnderscoreOrColon,
-        AttValue, 
-        CharRef1, 
-        CharRef2, 
-        CharRef, 
-        AmpRef,
-        LTRef,
-        GTRef,
-        AposRef,
-        QuoteRef,
-        CharData,
-        CharDataChars,
-        content,
-        AmpName,
-        LTName,
-        GTName,
-        ClassNameChar,
-        ClassName,
-        Name,
-        XMLDecl,
-        XMLDeclChars,
-        DocTypeDecl,
-        DocTypeDeclChars,
-        ClassIDAttribute,
-        ObjectIDAttribute,
-        ClassNameAttribute,
-        TrackingAttribute,
-        VersionAttribute,
-        UnusedAttribute,
-        Attribute,
-        SignatureAttribute,
-        SerializationWrapper,
-        NameHead,
-        NameTail,
-        AttributeList,
-        S;
-
-    // XML Character classes
-    chset_t
-        BaseChar,
-        Ideographic,
-        Char, 
-        Letter, 
-        Digit,
-        CombiningChar,
-        Extender, 
-        Sch,
-        NameChar;
-
-    void init_chset();
-
-    bool my_parse(
-        IStream & is,
-        const rule_t &rule_, 
-        const CharType delimiter = L'>'
-    ) const ;
-public:
-    struct return_values {
-        StringType object_name;
-        StringType contents;
-        //class_id_type class_id;
-        int_least16_t class_id;
-        //object_id_type object_id;
-        uint_least32_t object_id;
-        //version_type version;
-        unsigned int version;
-        tracking_type tracking_level;
-        StringType class_name;
-        return_values() :
-            version(0),
-            tracking_level(false)
-        {}
-    } rv;
-    bool parse_start_tag(IStream & is) /*const*/;
-    bool parse_end_tag(IStream & is) const;
-    bool parse_string(IStream & is, StringType & s) /*const*/;
-    void init(IStream & is);
-    bool windup(IStream & is);
-    basic_xml_grammar();
-};
-
-} // namespace archive
-} // namespace boost
-
-#endif // BOOST_ARCHIVE_BASIC_XML_GRAMMAR_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/impl/basic_xml_iarchive.ipp b/contrib/libboost/boost_1_65_0/boost/archive/impl/basic_xml_iarchive.ipp
deleted file mode 100644
index 625458b9eb5..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/impl/basic_xml_iarchive.ipp
+++ /dev/null
@@ -1,115 +0,0 @@
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// basic_xml_iarchive.ipp:
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/assert.hpp>
-#include <cstddef> // NULL
-#include <algorithm>
-
-#include <boost/serialization/throw_exception.hpp>
-#include <boost/archive/xml_archive_exception.hpp>
-#include <boost/archive/basic_xml_iarchive.hpp>
-#include <boost/serialization/tracking.hpp>
-
-namespace boost {
-namespace archive {
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// implementation of xml_text_archive
-
-template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-basic_xml_iarchive<Archive>::load_start(const char *name){
-    // if there's no name
-    if(NULL == name)
-        return;
-    bool result = this->This()->gimpl->parse_start_tag(this->This()->get_is());
-    if(true != result){
-        boost::serialization::throw_exception(
-            archive_exception(archive_exception::input_stream_error)
-        );
-    }
-    // don't check start tag at highest level
-    ++depth;
-    return;
-}
-
-template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-basic_xml_iarchive<Archive>::load_end(const char *name){
-    // if there's no name
-    if(NULL == name)
-        return;
-    bool result = this->This()->gimpl->parse_end_tag(this->This()->get_is());
-    if(true != result){
-        boost::serialization::throw_exception(
-            archive_exception(archive_exception::input_stream_error)
-        );
-    }
-    
-    // don't check start tag at highest level
-    if(0 == --depth)
-        return;
-        
-    if(0 == (this->get_flags() & no_xml_tag_checking)){
-        // double check that the tag matches what is expected - useful for debug
-        if(0 != name[this->This()->gimpl->rv.object_name.size()]
-        || ! std::equal(
-                this->This()->gimpl->rv.object_name.begin(),
-                this->This()->gimpl->rv.object_name.end(),
-                name
-            )
-        ){
-            boost::serialization::throw_exception(
-                xml_archive_exception(
-                    xml_archive_exception::xml_archive_tag_mismatch,
-                    name
-                )
-            );
-        }
-    }
-}
-
-template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-basic_xml_iarchive<Archive>::load_override(object_id_type & t){
-    t = object_id_type(this->This()->gimpl->rv.object_id);
-}
-
-template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-basic_xml_iarchive<Archive>::load_override(version_type & t){
-    t = version_type(this->This()->gimpl->rv.version);
-}
-
-template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-basic_xml_iarchive<Archive>::load_override(class_id_type & t){
-    t = class_id_type(this->This()->gimpl->rv.class_id);
-}
-
-template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-basic_xml_iarchive<Archive>::load_override(tracking_type & t){
-    t = this->This()->gimpl->rv.tracking_level;
-}
-
-template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL
-basic_xml_iarchive<Archive>::basic_xml_iarchive(unsigned int flags) :
-    detail::common_iarchive<Archive>(flags),
-    depth(0)
-{}
-template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL
-basic_xml_iarchive<Archive>::~basic_xml_iarchive(){
-}
-
-} // namespace archive
-} // namespace boost
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/impl/basic_xml_oarchive.ipp b/contrib/libboost/boost_1_65_0/boost/archive/impl/basic_xml_oarchive.ipp
deleted file mode 100644
index 3184413f382..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/impl/basic_xml_oarchive.ipp
+++ /dev/null
@@ -1,272 +0,0 @@
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// basic_xml_oarchive.ipp:
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-
-//  See http://www.boost.org for updates, documentation, and revision history.
-
-#include <algorithm>
-#include <cstddef> // NULL
-#include <cstring>
-#if defined(BOOST_NO_STDC_NAMESPACE) && ! defined(__LIBCOMO__)
-namespace std{
-    using ::strlen;
-} // namespace std
-#endif
-
-#include <boost/archive/basic_xml_archive.hpp>
-#include <boost/archive/basic_xml_oarchive.hpp>
-#include <boost/archive/xml_archive_exception.hpp>
-#include <boost/core/no_exceptions_support.hpp>
-
-namespace boost {
-namespace archive {
-
-namespace detail {
-template<class CharType>
-struct XML_name {
-    void operator()(CharType t) const{
-        const unsigned char lookup_table[] = {
-            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,0,0,0,0,0,0,0,0,0,0,0,1,1,0, // -.
-            1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0, // 0-9
-            0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, // A-
-            1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,1, // -Z _
-            0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, // a-
-            1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0, // -z
-            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
-        };
-        if((unsigned)t > 127)
-            return;
-        if(0 == lookup_table[(unsigned)t])
-            boost::serialization::throw_exception(
-                xml_archive_exception(
-                    xml_archive_exception::xml_archive_tag_name_error
-                )
-            );
-    }
-};
-
-} // namespace detail
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// implemenations of functions common to both types of xml output
-
-template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-basic_xml_oarchive<Archive>::write_attribute(
-    const char *attribute_name,
-    int t,
-    const char *conjunction
-){
-    this->This()->put(' ');
-    this->This()->put(attribute_name);
-    this->This()->put(conjunction);
-    this->This()->save(t);
-    this->This()->put('"');
-}
-
-template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-basic_xml_oarchive<Archive>::write_attribute(
-    const char *attribute_name,
-    const char *key
-){
-    this->This()->put(' ');
-    this->This()->put(attribute_name);
-    this->This()->put("=\"");
-    this->This()->save(key);
-    this->This()->put('"');
-}
-
-template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-basic_xml_oarchive<Archive>::indent(){
-    int i;
-    for(i = depth; i-- > 0;)
-        this->This()->put('\t');
-}
-
-template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-basic_xml_oarchive<Archive>::save_start(const char *name)
-{
-    if(NULL == name)
-        return;
-
-    // be sure name has no invalid characters
-    std::for_each(name, name + std::strlen(name), detail::XML_name<const char>());
-
-    end_preamble();
-    if(depth > 0){
-        this->This()->put('\n');
-        indent();
-    }
-    ++depth;
-    this->This()->put('<');
-    this->This()->save(name);
-    pending_preamble = true;
-    indent_next = false;
-}
-
-template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-basic_xml_oarchive<Archive>::save_end(const char *name)
-{
-    if(NULL == name)
-        return;
-
-    // be sure name has no invalid characters
-    std::for_each(name, name + std::strlen(name), detail::XML_name<const char>());
-
-    end_preamble();
-    --depth;
-    if(indent_next){
-        this->This()->put('\n');
-        indent();
-    }
-    indent_next = true;
-    this->This()->put("</");
-    this->This()->save(name);
-    this->This()->put('>');
-    if(0 == depth)
-        this->This()->put('\n');
-}
-
-template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-basic_xml_oarchive<Archive>::end_preamble(){
-    if(pending_preamble){
-        this->This()->put('>');
-        pending_preamble = false;
-    }
-}
-#if 0
-template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-basic_xml_oarchive<Archive>::save_override(const object_id_type & t)
-{
-    int i = t.t; // extra .t is for borland
-    write_attribute(BOOST_ARCHIVE_XML_OBJECT_ID(), i, "=\"_");
-}
-template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-basic_xml_oarchive<Archive>::save_override(
-    const object_reference_type & t,
-    int
-){
-    int i = t.t; // extra .t is for borland
-    write_attribute(BOOST_ARCHIVE_XML_OBJECT_REFERENCE(), i, "=\"_");
-}
-template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-basic_xml_oarchive<Archive>::save_override(const version_type & t)
-{
-    int i = t.t; // extra .t is for borland
-    write_attribute(BOOST_ARCHIVE_XML_VERSION(), i);
-}
-#endif
-
-template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-basic_xml_oarchive<Archive>::save_override(const object_id_type & t)
-{
-    // borland doesn't do conversion of STRONG_TYPEDEFs very well
-    const unsigned int i = t;
-    write_attribute(BOOST_ARCHIVE_XML_OBJECT_ID(), i, "=\"_");
-}
-template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-basic_xml_oarchive<Archive>::save_override(
-    const object_reference_type & t
-){
-    const unsigned int i = t;
-    write_attribute(BOOST_ARCHIVE_XML_OBJECT_REFERENCE(), i, "=\"_");
-}
-template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-basic_xml_oarchive<Archive>::save_override(const version_type & t)
-{
-    const unsigned int i = t;
-    write_attribute(BOOST_ARCHIVE_XML_VERSION(), i);
-}
-
-template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-basic_xml_oarchive<Archive>::save_override(const class_id_type & t)
-{
-    write_attribute(BOOST_ARCHIVE_XML_CLASS_ID(), t);
-}
-template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-basic_xml_oarchive<Archive>::save_override(
-    const class_id_reference_type & t
-){
-    write_attribute(BOOST_ARCHIVE_XML_CLASS_ID_REFERENCE(), t);
-}
-template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-basic_xml_oarchive<Archive>::save_override(
-    const class_id_optional_type & t
-){
-    write_attribute(BOOST_ARCHIVE_XML_CLASS_ID(), t);
-}
-template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-basic_xml_oarchive<Archive>::save_override(const class_name_type & t)
-{
-    const char * key = t;
-    if(NULL == key)
-        return;
-    write_attribute(BOOST_ARCHIVE_XML_CLASS_NAME(), key);
-}
-
-template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-basic_xml_oarchive<Archive>::save_override(const tracking_type & t)
-{
-    write_attribute(BOOST_ARCHIVE_XML_TRACKING(), t.t);
-}
-
-template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-basic_xml_oarchive<Archive>::init(){
-    // xml header
-    this->This()->put("<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\" ?>\n");
-    this->This()->put("<!DOCTYPE boost_serialization>\n");
-    // xml document wrapper - outer root
-    this->This()->put("<boost_serialization");
-    write_attribute("signature", BOOST_ARCHIVE_SIGNATURE());
-    write_attribute("version", BOOST_ARCHIVE_VERSION());
-    this->This()->put(">\n");
-}
-
-template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL void
-basic_xml_oarchive<Archive>::windup(){
-    // xml_trailer
-    this->This()->put("</boost_serialization>\n");
-}
-
-template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL
-basic_xml_oarchive<Archive>::basic_xml_oarchive(unsigned int flags) :
-    detail::common_oarchive<Archive>(flags),
-    depth(0),
-    pending_preamble(false),
-    indent_next(false)
-{
-}
-
-template<class Archive>
-BOOST_ARCHIVE_OR_WARCHIVE_DECL
-basic_xml_oarchive<Archive>::~basic_xml_oarchive(){
-}
-
-} // namespace archive
-} // namespace boost
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/impl/text_iarchive_impl.ipp b/contrib/libboost/boost_1_65_0/boost/archive/impl/text_iarchive_impl.ipp
deleted file mode 100644
index ae4e2750ce8..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/impl/text_iarchive_impl.ipp
+++ /dev/null
@@ -1,128 +0,0 @@
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// text_iarchive_impl.ipp:
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-
-//  See http://www.boost.org for updates, documentation, and revision history.
-
-//////////////////////////////////////////////////////////////////////
-// implementation of basic_text_iprimitive overrides for the combination
-// of template parameters used to implement a text_iprimitive
-
-#include <cstddef> // size_t, NULL
-#include <boost/config.hpp>
-#if defined(BOOST_NO_STDC_NAMESPACE)
-namespace std{ 
-    using ::size_t; 
-} // namespace std
-#endif
-
-#include <boost/detail/workaround.hpp> // RogueWave
-
-#include <boost/archive/text_iarchive.hpp>
-
-namespace boost {
-namespace archive {
-
-template<class Archive>
-BOOST_ARCHIVE_DECL void
-text_iarchive_impl<Archive>::load(char *s)
-{
-    std::size_t size;
-    * this->This() >> size;
-    // skip separating space
-    is.get();
-    // Works on all tested platforms
-    is.read(s, size);
-    s[size] = '\0';
-}
-
-template<class Archive>
-BOOST_ARCHIVE_DECL void
-text_iarchive_impl<Archive>::load(std::string &s)
-{
-    std::size_t size;
-    * this->This() >> size;
-    // skip separating space
-    is.get();
-    // borland de-allocator fixup
-    #if BOOST_WORKAROUND(_RWSTD_VER, BOOST_TESTED_AT(20101))
-    if(NULL != s.data())
-    #endif
-        s.resize(size);
-    if(0 < size)
-        is.read(&(*s.begin()), size);
-}
-
-#ifndef BOOST_NO_CWCHAR
-#ifndef BOOST_NO_INTRINSIC_WCHAR_T
-template<class Archive>
-BOOST_ARCHIVE_DECL void
-text_iarchive_impl<Archive>::load(wchar_t *ws)
-{
-    std::size_t size;
-    * this->This() >> size;
-    // skip separating space
-    is.get();
-    is.read((char *)ws, size * sizeof(wchar_t)/sizeof(char));
-    ws[size] = L'\0';
-}
-#endif // BOOST_NO_INTRINSIC_WCHAR_T
-
-#ifndef BOOST_NO_STD_WSTRING
-template<class Archive>
-BOOST_ARCHIVE_DECL void
-text_iarchive_impl<Archive>::load(std::wstring &ws)
-{
-    std::size_t size;
-    * this->This() >> size;
-    // borland de-allocator fixup
-    #if BOOST_WORKAROUND(_RWSTD_VER, BOOST_TESTED_AT(20101))
-    if(NULL != ws.data())
-    #endif
-        ws.resize(size);
-    // skip separating space
-    is.get();
-    is.read((char *)ws.data(), size * sizeof(wchar_t)/sizeof(char));
-}
-
-#endif // BOOST_NO_STD_WSTRING
-#endif // BOOST_NO_CWCHAR
-
-template<class Archive>
-BOOST_ARCHIVE_DECL void
-text_iarchive_impl<Archive>::load_override(class_name_type & t){
-    basic_text_iarchive<Archive>::load_override(t);
-}
-
-template<class Archive>
-BOOST_ARCHIVE_DECL void
-text_iarchive_impl<Archive>::init(){
-    basic_text_iarchive<Archive>::init();
-}
-
-template<class Archive>
-BOOST_ARCHIVE_DECL 
-text_iarchive_impl<Archive>::text_iarchive_impl(
-    std::istream & is, 
-    unsigned int flags
-) :
-    basic_text_iprimitive<std::istream>(
-        is, 
-        0 != (flags & no_codecvt)
-    ),
-    basic_text_iarchive<Archive>(flags)
-{
-    if(0 == (flags & no_header))
-        #if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3205))
-        this->init();
-        #else
-        this->basic_text_iarchive<Archive>::init();
-        #endif
-}
-
-} // namespace archive
-} // namespace boost
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/impl/text_oarchive_impl.ipp b/contrib/libboost/boost_1_65_0/boost/archive/impl/text_oarchive_impl.ipp
deleted file mode 100644
index 37d8664a98c..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/impl/text_oarchive_impl.ipp
+++ /dev/null
@@ -1,122 +0,0 @@
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// text_oarchive_impl.ipp:
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-
-//  See http://www.boost.org for updates, documentation, and revision history.
-
-#include <string>
-#include <boost/config.hpp>
-#include <cstddef> // size_t
-
-#include <boost/config.hpp>
-#if defined(BOOST_NO_STDC_NAMESPACE)
-namespace std{ 
-    using ::size_t; 
-} // namespace std
-#endif
-
-#ifndef BOOST_NO_CWCHAR
-#include <cwchar>
-#ifdef BOOST_NO_STDC_NAMESPACE
-namespace std{ using ::wcslen; }
-#endif
-#endif
-
-#include <boost/archive/text_oarchive.hpp>
-
-namespace boost { 
-namespace archive {
-
-//////////////////////////////////////////////////////////////////////
-// implementation of basic_text_oprimitive overrides for the combination
-// of template parameters used to create a text_oprimitive
-
-template<class Archive>
-BOOST_ARCHIVE_DECL void
-text_oarchive_impl<Archive>::save(const char * s)
-{
-    const std::size_t len = std::ostream::traits_type::length(s);
-    *this->This() << len;
-    this->This()->newtoken();
-    os << s;
-}
-
-template<class Archive>
-BOOST_ARCHIVE_DECL void
-text_oarchive_impl<Archive>::save(const std::string &s)
-{
-    const std::size_t size = s.size();
-    *this->This() << size;
-    this->This()->newtoken();
-    os << s;
-}
-
-#ifndef BOOST_NO_CWCHAR
-#ifndef BOOST_NO_INTRINSIC_WCHAR_T
-template<class Archive>
-BOOST_ARCHIVE_DECL void
-text_oarchive_impl<Archive>::save(const wchar_t * ws)
-{
-    const std::size_t l = std::wcslen(ws);
-    * this->This() << l;
-    this->This()->newtoken();
-    os.write((const char *)ws, l * sizeof(wchar_t)/sizeof(char));
-}
-#endif
-
-#ifndef BOOST_NO_STD_WSTRING
-template<class Archive>
-BOOST_ARCHIVE_DECL void
-text_oarchive_impl<Archive>::save(const std::wstring &ws)
-{
-    const std::size_t l = ws.size();
-    * this->This() << l;
-    this->This()->newtoken();
-    os.write((const char *)(ws.data()), l * sizeof(wchar_t)/sizeof(char));
-}
-#endif
-#endif // BOOST_NO_CWCHAR
-
-template<class Archive>
-BOOST_ARCHIVE_DECL 
-text_oarchive_impl<Archive>::text_oarchive_impl(
-    std::ostream & os, 
-    unsigned int flags
-) :
-    basic_text_oprimitive<std::ostream>(
-        os, 
-        0 != (flags & no_codecvt)
-    ),
-    basic_text_oarchive<Archive>(flags)
-{
-    if(0 == (flags & no_header))
-        #if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3205))
-        this->init();
-        #else
-        this->basic_text_oarchive<Archive>::init();
-        #endif
-}
-
-template<class Archive>
-BOOST_ARCHIVE_DECL void
-text_oarchive_impl<Archive>::save_binary(const void *address, std::size_t count){
-    put('\n');
-    this->end_preamble();
-    #if ! defined(__MWERKS__)
-    this->basic_text_oprimitive<std::ostream>::save_binary(
-    #else
-    this->basic_text_oprimitive::save_binary(
-    #endif
-        address, 
-        count
-    );
-    this->delimiter = this->eol;
-}
-
-} // namespace archive
-} // namespace boost
-
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/impl/text_wiarchive_impl.ipp b/contrib/libboost/boost_1_65_0/boost/archive/impl/text_wiarchive_impl.ipp
deleted file mode 100644
index e85625ac326..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/impl/text_wiarchive_impl.ipp
+++ /dev/null
@@ -1,118 +0,0 @@
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// text_text_wiarchive_impl.ipp:
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-
-//  See http://www.boost.org for updates, documentation, and revision history.
-
-#include <cstddef> // size_t, NULL
-
-#include <boost/config.hpp>
-#if defined(BOOST_NO_STDC_NAMESPACE)
-namespace std{ 
-    using ::size_t; 
-} // namespace std
-#endif
-
-#include <boost/detail/workaround.hpp>  // fixup for RogueWave
-
-#ifndef BOOST_NO_STD_WSTREAMBUF
-#include <boost/archive/basic_text_iprimitive.hpp>
-
-namespace boost { 
-namespace archive {
-
-//////////////////////////////////////////////////////////////////////
-// implementation of wiprimtives functions
-//
-template<class Archive>
-BOOST_WARCHIVE_DECL void
-text_wiarchive_impl<Archive>::load(char *s)
-{
-    std::size_t size;
-    * this->This() >> size;
-    // skip separating space
-    is.get();
-    while(size-- > 0){
-        *s++ = is.narrow(is.get(), '\0');
-    }
-    *s = '\0';
-}
-
-template<class Archive>
-BOOST_WARCHIVE_DECL void
-text_wiarchive_impl<Archive>::load(std::string &s)
-{
-    std::size_t size;
-    * this->This() >> size;
-    // skip separating space
-    is.get();
-    #if BOOST_WORKAROUND(_RWSTD_VER, BOOST_TESTED_AT(20101))
-    if(NULL != s.data())
-    #endif
-        s.resize(0);
-    s.reserve(size);
-    while(size-- > 0){
-        char x = is.narrow(is.get(), '\0');
-        s += x;
-    }
-}
-
-#ifndef BOOST_NO_INTRINSIC_WCHAR_T
-template<class Archive>
-BOOST_WARCHIVE_DECL void
-text_wiarchive_impl<Archive>::load(wchar_t *s)
-{
-    std::size_t size;
-    * this->This() >> size;
-    // skip separating space
-    is.get();
-    // Works on all tested platforms
-    is.read(s, size);
-    s[size] = L'\0';
-}
-#endif
-
-#ifndef BOOST_NO_STD_WSTRING
-template<class Archive>
-BOOST_WARCHIVE_DECL void
-text_wiarchive_impl<Archive>::load(std::wstring &ws)
-{
-    std::size_t size;
-    * this->This() >> size;
-    // skip separating space
-    is.get();
-    // borland complains about resize
-    // borland de-allocator fixup
-    #if BOOST_WORKAROUND(_RWSTD_VER, BOOST_TESTED_AT(20101))
-    if(NULL != ws.data())
-    #endif
-        ws.resize(size);
-    // note breaking a rule here - is this a problem on some platform
-    is.read(const_cast<wchar_t *>(ws.data()), size);
-}
-#endif
-
-template<class Archive>
-BOOST_WARCHIVE_DECL 
-text_wiarchive_impl<Archive>::text_wiarchive_impl(
-    std::wistream & is, 
-    unsigned int flags
-) :
-    basic_text_iprimitive<std::wistream>(
-        is, 
-        0 != (flags & no_codecvt)
-    ),
-    basic_text_iarchive<Archive>(flags)
-{
-    if(0 == (flags & no_header))
-        basic_text_iarchive<Archive>::init();
-}
-
-} // archive
-} // boost
-
-#endif // BOOST_NO_STD_WSTREAMBUF
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/impl/text_woarchive_impl.ipp b/contrib/libboost/boost_1_65_0/boost/archive/impl/text_woarchive_impl.ipp
deleted file mode 100644
index 2b6d427cd3a..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/impl/text_woarchive_impl.ipp
+++ /dev/null
@@ -1,85 +0,0 @@
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// text_woarchive_impl.ipp:
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-
-//  See http://www.boost.org for updates, documentation, and revision history.
-
-#include <boost/config.hpp>
-#ifndef BOOST_NO_STD_WSTREAMBUF
-
-#include <cstring>
-#include <cstddef> // size_t
-#if defined(BOOST_NO_STDC_NAMESPACE) && ! defined(__LIBCOMO__)
-namespace std{ 
-    using ::strlen;
-    using ::size_t; 
-} // namespace std
-#endif
-
-#include <ostream>
-
-#include <boost/archive/text_woarchive.hpp>
-
-namespace boost {
-namespace archive {
-
-//////////////////////////////////////////////////////////////////////
-// implementation of woarchive functions
-//
-template<class Archive>
-BOOST_WARCHIVE_DECL void
-text_woarchive_impl<Archive>::save(const char *s)
-{
-    // note: superfluous local variable fixes borland warning
-    const std::size_t size = std::strlen(s);
-    * this->This() << size;
-    this->This()->newtoken();
-    while(*s != '\0')
-        os.put(os.widen(*s++));
-}
-
-template<class Archive>
-BOOST_WARCHIVE_DECL void
-text_woarchive_impl<Archive>::save(const std::string &s)
-{
-    const std::size_t size = s.size();
-    * this->This() << size;
-    this->This()->newtoken();
-    const char * cptr = s.data();
-    for(std::size_t i = size; i-- > 0;)
-        os.put(os.widen(*cptr++));
-}
-
-#ifndef BOOST_NO_INTRINSIC_WCHAR_T
-template<class Archive>
-BOOST_WARCHIVE_DECL void
-text_woarchive_impl<Archive>::save(const wchar_t *ws)
-{
-    const std::size_t size = std::wostream::traits_type::length(ws);
-    * this->This() << size;
-    this->This()->newtoken();
-    os.write(ws, size);
-}
-#endif
-
-#ifndef BOOST_NO_STD_WSTRING
-template<class Archive>
-BOOST_WARCHIVE_DECL void
-text_woarchive_impl<Archive>::save(const std::wstring &ws)
-{
-    const std::size_t size = ws.length();
-    * this->This() << size;
-    this->This()->newtoken();
-    os.write(ws.data(), size);
-}
-#endif
-
-} // namespace archive
-} // namespace boost
-
-#endif
-
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/impl/xml_iarchive_impl.ipp b/contrib/libboost/boost_1_65_0/boost/archive/impl/xml_iarchive_impl.ipp
deleted file mode 100644
index efc32e01632..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/impl/xml_iarchive_impl.ipp
+++ /dev/null
@@ -1,199 +0,0 @@
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// xml_iarchive_impl.cpp:
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-
-//  See http://www.boost.org for updates, documentation, and revision history.
-
-#include <boost/config.hpp>
-#include <cstring> // memcpy
-#include <cstddef> // NULL
-#include <exception>
-
-#if defined(BOOST_NO_STDC_NAMESPACE)
-namespace std{ 
-    using ::memcpy;
-} // namespace std
-#endif
-
-#ifndef BOOST_NO_CWCHAR
-#include <cwchar> // mbstate_t and mbrtowc
-#if defined(BOOST_NO_STDC_NAMESPACE)
-namespace std{ 
-    using ::mbstate_t;
-    using ::mbrtowc;
- } // namespace std
-#endif
-#endif // BOOST_NO_CWCHAR
-
-#include <boost/detail/workaround.hpp> // RogueWave and Dinkumware
-#if BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, == 1)
-#include <boost/archive/dinkumware.hpp>
-#endif
-
-#include <boost/core/no_exceptions_support.hpp>
-
-#include <boost/archive/xml_archive_exception.hpp>
-#include <boost/archive/iterators/dataflow_exception.hpp>
-#include <boost/archive/basic_xml_archive.hpp>
-#include <boost/archive/xml_iarchive.hpp>
-
-#include "basic_xml_grammar.hpp"
-
-namespace boost {
-namespace archive {
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// implemenations of functions specific to char archives
-
-// wide char stuff used by char archives
-
-#ifndef BOOST_NO_CWCHAR
-#ifndef BOOST_NO_STD_WSTRING
-template<class Archive>
-BOOST_ARCHIVE_DECL void
-xml_iarchive_impl<Archive>::load(std::wstring &ws){
-    std::string s;
-    bool result = gimpl->parse_string(is, s);
-    if(! result)
-        boost::serialization::throw_exception(
-            xml_archive_exception(xml_archive_exception::xml_archive_parsing_error)
-        );
-    
-    #if BOOST_WORKAROUND(_RWSTD_VER, BOOST_TESTED_AT(20101))
-    if(NULL != ws.data())
-    #endif
-    ws.resize(0);
-    std::mbstate_t mbs = std::mbstate_t();
-    const char * start = s.data();
-    const char * end = start + s.size();
-    while(start < end){
-        wchar_t wc;
-        std::size_t count = std::mbrtowc(&wc, start, end - start, &mbs);
-        if(count == static_cast<std::size_t>(-1))
-            boost::serialization::throw_exception(
-                iterators::dataflow_exception(
-                    iterators::dataflow_exception::invalid_conversion
-                )
-            );
-        if(count == static_cast<std::size_t>(-2))
-            continue;
-        start += count;
-        ws += wc;
-    }
-}
-#endif // BOOST_NO_STD_WSTRING
-
-#ifndef BOOST_NO_INTRINSIC_WCHAR_T
-template<class Archive>
-BOOST_ARCHIVE_DECL void
-xml_iarchive_impl<Archive>::load(wchar_t * ws){
-    std::string s;
-    bool result = gimpl->parse_string(is, s);
-    if(! result)
-        boost::serialization::throw_exception(
-            xml_archive_exception(
-                xml_archive_exception::xml_archive_parsing_error
-            )
-        );
-        
-    std::mbstate_t mbs = std::mbstate_t();
-    const char * start = s.data();
-    const char * end = start + s.size();
-    while(start < end){
-        wchar_t wc;
-        std::size_t length = std::mbrtowc(&wc, start, end - start, &mbs);
-        if(static_cast<std::size_t>(-1) == length)
-            boost::serialization::throw_exception(
-                iterators::dataflow_exception(
-                    iterators::dataflow_exception::invalid_conversion
-                )
-            );
-        if(static_cast<std::size_t>(-2) == length)
-            continue;
-
-        start += length;
-        *ws++ = wc;
-    }
-    *ws = L'\0';
-}
-#endif // BOOST_NO_INTRINSIC_WCHAR_T
-
-#endif // BOOST_NO_CWCHAR
-
-template<class Archive>
-BOOST_ARCHIVE_DECL void
-xml_iarchive_impl<Archive>::load(std::string &s){
-    bool result = gimpl->parse_string(is, s);
-    if(! result)
-        boost::serialization::throw_exception(
-            xml_archive_exception(xml_archive_exception::xml_archive_parsing_error)
-        );
-}
-
-template<class Archive>
-BOOST_ARCHIVE_DECL void
-xml_iarchive_impl<Archive>::load(char * s){
-    std::string tstring;
-    bool result = gimpl->parse_string(is, tstring);
-    if(! result)
-        boost::serialization::throw_exception(
-            xml_archive_exception(xml_archive_exception::xml_archive_parsing_error)
-        );
-    std::memcpy(s, tstring.data(), tstring.size());
-    s[tstring.size()] = 0;
-}
-
-template<class Archive>
-BOOST_ARCHIVE_DECL void
-xml_iarchive_impl<Archive>::load_override(class_name_type & t){
-    const std::string & s = gimpl->rv.class_name;
-    if(s.size() > BOOST_SERIALIZATION_MAX_KEY_SIZE - 1)
-        boost::serialization::throw_exception(
-            archive_exception(archive_exception::invalid_class_name)
-       );
-    char * tptr = t;
-    std::memcpy(tptr, s.data(), s.size());
-    tptr[s.size()] = '\0';
-}
-
-template<class Archive>
-BOOST_ARCHIVE_DECL void
-xml_iarchive_impl<Archive>::init(){
-    gimpl->init(is);
-    this->set_library_version(
-        library_version_type(gimpl->rv.version)
-    );
-}
-
-template<class Archive>
-BOOST_ARCHIVE_DECL
-xml_iarchive_impl<Archive>::xml_iarchive_impl(
-    std::istream &is_,
-    unsigned int flags
-) :
-    basic_text_iprimitive<std::istream>(
-        is_, 
-        0 != (flags & no_codecvt)
-    ),
-    basic_xml_iarchive<Archive>(flags),
-    gimpl(new xml_grammar())
-{
-    if(0 == (flags & no_header))
-        init();
-}
-
-template<class Archive>
-BOOST_ARCHIVE_DECL
-xml_iarchive_impl<Archive>::~xml_iarchive_impl(){
-    if(std::uncaught_exception())
-        return;
-    if(0 == (this->get_flags() & no_header)){
-        gimpl->windup(is);
-    }
-}
-} // namespace archive
-} // namespace boost
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/impl/xml_oarchive_impl.ipp b/contrib/libboost/boost_1_65_0/boost/archive/impl/xml_oarchive_impl.ipp
deleted file mode 100644
index 5ebd454e722..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/impl/xml_oarchive_impl.ipp
+++ /dev/null
@@ -1,142 +0,0 @@
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// xml_oarchive_impl.ipp:
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.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)
-
-#include <ostream>
-#include <iomanip>
-#include <algorithm> // std::copy
-#include <string>
-#include <exception>
-
-#include <cstring> // strlen
-#include <boost/config.hpp> // msvc 6.0 needs this to suppress warnings
-#if defined(BOOST_NO_STDC_NAMESPACE)
-namespace std{ 
-    using ::strlen; 
-} // namespace std
-#endif
-
-#include <boost/archive/iterators/xml_escape.hpp>
-#include <boost/archive/iterators/ostream_iterator.hpp>
-
-#ifndef BOOST_NO_CWCHAR
-#include <boost/archive/wcslen.hpp>
-#include <boost/archive/iterators/mb_from_wchar.hpp>
-#endif
-
-namespace boost {
-namespace archive {
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// implemenations of functions specific to char archives
-
-// wide char stuff used by char archives
-#ifndef BOOST_NO_CWCHAR
-// copy chars to output escaping to xml and translating wide chars to mb chars
-template<class InputIterator>
-void save_iterator(std::ostream &os, InputIterator begin, InputIterator end){
-    typedef boost::archive::iterators::mb_from_wchar<
-        boost::archive::iterators::xml_escape<InputIterator>
-    > translator;
-    std::copy(
-        translator(begin),
-        translator(end),
-        boost::archive::iterators::ostream_iterator<char>(os)
-    );
-}
-
-#ifndef BOOST_NO_STD_WSTRING
-template<class Archive>
-BOOST_ARCHIVE_DECL void
-xml_oarchive_impl<Archive>::save(const std::wstring & ws){
-//  at least one library doesn't typedef value_type for strings
-//  so rather than using string directly make a pointer iterator out of it
-//    save_iterator(os, ws.data(), ws.data() + std::wcslen(ws.data()));
-    save_iterator(os, ws.data(), ws.data() + ws.size());
-}
-#endif
-
-#ifndef BOOST_NO_INTRINSIC_WCHAR_T
-template<class Archive>
-BOOST_ARCHIVE_DECL void
-xml_oarchive_impl<Archive>::save(const wchar_t * ws){
-    save_iterator(os, ws, ws + std::wcslen(ws));
-}
-#endif
-
-#endif // BOOST_NO_CWCHAR
-
-template<class Archive>
-BOOST_ARCHIVE_DECL void
-xml_oarchive_impl<Archive>::save(const std::string & s){
-//  at least one library doesn't typedef value_type for strings
-//  so rather than using string directly make a pointer iterator out of it
-    typedef boost::archive::iterators::xml_escape<
-        const char * 
-    > xml_escape_translator;
-    std::copy(
-        xml_escape_translator(s.data()),
-        xml_escape_translator(s.data()+ s.size()),
-        boost::archive::iterators::ostream_iterator<char>(os)
-    );
-}
-
-template<class Archive>
-BOOST_ARCHIVE_DECL void
-xml_oarchive_impl<Archive>::save(const char * s){
-    typedef boost::archive::iterators::xml_escape<
-        const char * 
-    > xml_escape_translator;
-    std::copy(
-        xml_escape_translator(s),
-        xml_escape_translator(s + std::strlen(s)),
-        boost::archive::iterators::ostream_iterator<char>(os)
-    );
-}
-
-template<class Archive>
-BOOST_ARCHIVE_DECL
-xml_oarchive_impl<Archive>::xml_oarchive_impl(
-    std::ostream & os_, 
-    unsigned int flags
-) : 
-    basic_text_oprimitive<std::ostream>(
-        os_,
-        0 != (flags & no_codecvt)
-    ),
-    basic_xml_oarchive<Archive>(flags)
-{
-    if(0 == (flags & no_header))
-        this->init();
-}
-
-template<class Archive>
-BOOST_ARCHIVE_DECL void
-xml_oarchive_impl<Archive>::save_binary(const void *address, std::size_t count){
-    this->end_preamble();
-    #if ! defined(__MWERKS__)
-    this->basic_text_oprimitive<std::ostream>::save_binary(
-    #else
-    this->basic_text_oprimitive::save_binary(
-    #endif
-        address, 
-        count
-    );
-    this->indent_next = true;
-}
-
-template<class Archive>
-BOOST_ARCHIVE_DECL
-xml_oarchive_impl<Archive>::~xml_oarchive_impl(){
-    if(std::uncaught_exception())
-        return;
-    if(0 == (this->get_flags() & no_header))
-        this->windup();
-}
-
-} // namespace archive
-} // namespace boost
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/impl/xml_wiarchive_impl.ipp b/contrib/libboost/boost_1_65_0/boost/archive/impl/xml_wiarchive_impl.ipp
deleted file mode 100644
index ee66c1263e6..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/impl/xml_wiarchive_impl.ipp
+++ /dev/null
@@ -1,189 +0,0 @@
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// xml_wiarchive_impl.ipp:
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-
-//  See http://www.boost.org for updates, documentation, and revision history.
-
-#include <cstring>
-#if defined(BOOST_NO_STDC_NAMESPACE)
-namespace std{ 
-    using ::memcpy; 
-} //std
-#endif
-
-#include <boost/config.hpp> // msvc 6.0 needs this to suppress warnings
-#ifndef BOOST_NO_STD_WSTREAMBUF
-
-#include <boost/assert.hpp>
-#include <algorithm> // std::copy
-#include <exception> // uncaught exception
-#include <boost/detail/workaround.hpp> // Dinkumware and RogueWave
-#if BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, == 1)
-#include <boost/archive/dinkumware.hpp>
-#endif
-
-#include <boost/io/ios_state.hpp>
-#include <boost/core/no_exceptions_support.hpp>
-#include <boost/serialization/string.hpp>
-
-#include <boost/archive/basic_xml_archive.hpp>
-#include <boost/archive/xml_wiarchive.hpp>
-
-#include <boost/archive/xml_archive_exception.hpp>
-#include <boost/archive/iterators/mb_from_wchar.hpp>
-
-#include <boost/archive/detail/utf8_codecvt_facet.hpp>
-
-#include "basic_xml_grammar.hpp"
-
-namespace boost {
-namespace archive {
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// implemenations of functions specific to wide char archives
-
-namespace { // anonymous
-
-void copy_to_ptr(char * s, const std::wstring & ws){
-    std::copy(
-        iterators::mb_from_wchar<std::wstring::const_iterator>(
-            ws.begin()
-        ), 
-        iterators::mb_from_wchar<std::wstring::const_iterator>(
-            ws.end()
-        ), 
-        s
-    );
-    s[ws.size()] = 0;
-}
-
-} // anonymous
-
-template<class Archive>
-BOOST_WARCHIVE_DECL void
-xml_wiarchive_impl<Archive>::load(std::string & s){
-    std::wstring ws;
-    bool result = gimpl->parse_string(is, ws);
-    if(! result)
-        boost::serialization::throw_exception(
-            xml_archive_exception(xml_archive_exception::xml_archive_parsing_error)
-        );
-    #if BOOST_WORKAROUND(_RWSTD_VER, BOOST_TESTED_AT(20101))
-    if(NULL != s.data())
-    #endif
-        s.resize(0);
-    s.reserve(ws.size());
-    std::copy(
-        iterators::mb_from_wchar<std::wstring::iterator>(
-            ws.begin()
-        ), 
-        iterators::mb_from_wchar<std::wstring::iterator>(
-            ws.end()
-        ), 
-        std::back_inserter(s)
-    );
-}
-
-#ifndef BOOST_NO_STD_WSTRING
-template<class Archive>
-BOOST_WARCHIVE_DECL void
-xml_wiarchive_impl<Archive>::load(std::wstring & ws){
-    bool result = gimpl->parse_string(is, ws);
-    if(! result)
-        boost::serialization::throw_exception(
-            xml_archive_exception(xml_archive_exception::xml_archive_parsing_error)
-        );
-}
-#endif
-
-template<class Archive>
-BOOST_WARCHIVE_DECL void
-xml_wiarchive_impl<Archive>::load(char * s){
-    std::wstring ws;
-    bool result = gimpl->parse_string(is, ws);
-    if(! result)
-        boost::serialization::throw_exception(
-            xml_archive_exception(xml_archive_exception::xml_archive_parsing_error)
-        );
-    copy_to_ptr(s, ws);
-}
-
-#ifndef BOOST_NO_INTRINSIC_WCHAR_T
-template<class Archive>
-BOOST_WARCHIVE_DECL void
-xml_wiarchive_impl<Archive>::load(wchar_t * ws){
-    std::wstring twstring;
-    bool result = gimpl->parse_string(is, twstring);
-    if(! result)
-        boost::serialization::throw_exception(
-            xml_archive_exception(xml_archive_exception::xml_archive_parsing_error)
-        );
-    std::memcpy(ws, twstring.c_str(), twstring.size());
-    ws[twstring.size()] = L'\0';
-}
-#endif
-
-template<class Archive>
-BOOST_WARCHIVE_DECL void
-xml_wiarchive_impl<Archive>::load_override(class_name_type & t){
-    const std::wstring & ws = gimpl->rv.class_name;
-    if(ws.size() > BOOST_SERIALIZATION_MAX_KEY_SIZE - 1)
-        boost::serialization::throw_exception(
-            archive_exception(archive_exception::invalid_class_name)
-        );
-    copy_to_ptr(t, ws);
-}
-
-template<class Archive>
-BOOST_WARCHIVE_DECL void
-xml_wiarchive_impl<Archive>::init(){
-    gimpl->init(is);
-    this->set_library_version(
-        library_version_type(gimpl->rv.version)
-    );
-}
-
-template<class Archive>
-BOOST_WARCHIVE_DECL
-xml_wiarchive_impl<Archive>::xml_wiarchive_impl(
-    std::wistream &is_,
-    unsigned int flags
-) :
-    basic_text_iprimitive<std::wistream>(
-        is_, 
-        true // don't change the codecvt - use the one below
-    ),
-    basic_xml_iarchive<Archive>(flags),
-    gimpl(new xml_wgrammar())
-{
-    if(0 == (flags & no_codecvt)){
-        std::locale l = std::locale(
-            is_.getloc(),
-            new boost::archive::detail::utf8_codecvt_facet
-        );
-        // libstdc++ crashes without this
-        is_.sync();
-        is_.imbue(l);
-    }
-    if(0 == (flags & no_header))
-        init();
-}
-
-template<class Archive>
-BOOST_WARCHIVE_DECL
-xml_wiarchive_impl<Archive>::~xml_wiarchive_impl(){
-    if(std::uncaught_exception())
-        return;
-    if(0 == (this->get_flags() & no_header)){
-        gimpl->windup(is);
-    }
-}
-
-} // namespace archive
-} // namespace boost
-
-#endif  // BOOST_NO_STD_WSTREAMBUF
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/impl/xml_woarchive_impl.ipp b/contrib/libboost/boost_1_65_0/boost/archive/impl/xml_woarchive_impl.ipp
deleted file mode 100644
index 01b1a052d51..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/impl/xml_woarchive_impl.ipp
+++ /dev/null
@@ -1,171 +0,0 @@
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// xml_woarchive_impl.ipp:
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.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)
-
-#include <boost/config.hpp>
-#ifndef BOOST_NO_STD_WSTREAMBUF
-
-#include <ostream>
-#include <string>
-#include <algorithm> // std::copy
-#include <locale>
-#include <exception>
-
-#include <cstring> // strlen
-#include <cstdlib> // mbtowc
-#ifndef BOOST_NO_CWCHAR
-#include <cwchar>  // wcslen
-#endif
-
-#include <boost/config.hpp>
-#if defined(BOOST_NO_STDC_NAMESPACE)
-namespace std{ 
-    using ::strlen; 
-    #if ! defined(BOOST_NO_INTRINSIC_WCHAR_T)
-        using ::mbtowc; 
-        using ::wcslen;
-    #endif
-} // namespace std
-#endif
-
-#include <boost/archive/xml_woarchive.hpp>
-#include <boost/archive/detail/utf8_codecvt_facet.hpp>
-
-#include <boost/serialization/throw_exception.hpp>
-
-#include <boost/archive/iterators/xml_escape.hpp>
-#include <boost/archive/iterators/wchar_from_mb.hpp>
-#include <boost/archive/iterators/ostream_iterator.hpp>
-#include <boost/archive/iterators/dataflow_exception.hpp>
-
-namespace boost {
-namespace archive {
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// implemenations of functions specific to wide char archives
-
-// copy chars to output escaping to xml and widening characters as we go
-template<class InputIterator>
-void save_iterator(std::wostream &os, InputIterator begin, InputIterator end){
-    typedef iterators::wchar_from_mb<
-        iterators::xml_escape<InputIterator>
-    > xmbtows;
-    std::copy(
-        xmbtows(begin),
-        xmbtows(end),
-        boost::archive::iterators::ostream_iterator<wchar_t>(os)
-    );
-}
-
-template<class Archive>
-BOOST_WARCHIVE_DECL void
-xml_woarchive_impl<Archive>::save(const std::string & s){
-    // note: we don't use s.begin() and s.end() because dinkumware
-    // doesn't have string::value_type defined. So use a wrapper
-    // around these values to implement the definitions.
-    const char * begin = s.data();
-    const char * end = begin + s.size();
-    save_iterator(os, begin, end);
-}
-
-#ifndef BOOST_NO_STD_WSTRING
-template<class Archive>
-BOOST_WARCHIVE_DECL void
-xml_woarchive_impl<Archive>::save(const std::wstring & ws){
-#if 0
-    typedef iterators::xml_escape<std::wstring::const_iterator> xmbtows;
-    std::copy(
-        xmbtows(ws.begin()),
-        xmbtows(ws.end()),
-        boost::archive::iterators::ostream_iterator<wchar_t>(os)
-    );
-#endif
-    typedef iterators::xml_escape<const wchar_t *> xmbtows;
-    std::copy(
-        xmbtows(ws.data()),
-        xmbtows(ws.data() + ws.size()),
-        boost::archive::iterators::ostream_iterator<wchar_t>(os)
-    );
-}
-#endif //BOOST_NO_STD_WSTRING
-
-template<class Archive>
-BOOST_WARCHIVE_DECL void
-xml_woarchive_impl<Archive>::save(const char * s){
-   save_iterator(os, s, s + std::strlen(s));
-}
-
-#ifndef BOOST_NO_INTRINSIC_WCHAR_T
-template<class Archive>
-BOOST_WARCHIVE_DECL void
-xml_woarchive_impl<Archive>::save(const wchar_t * ws){
-    os << ws;
-    typedef iterators::xml_escape<const wchar_t *> xmbtows;
-    std::copy(
-        xmbtows(ws),
-        xmbtows(ws + std::wcslen(ws)),
-        boost::archive::iterators::ostream_iterator<wchar_t>(os)
-    );
-}
-#endif
-
-template<class Archive>
-BOOST_WARCHIVE_DECL
-xml_woarchive_impl<Archive>::xml_woarchive_impl(
-    std::wostream & os_,
-    unsigned int flags
-) :
-    basic_text_oprimitive<std::wostream>(
-        os_,
-        true // don't change the codecvt - use the one below
-    ),
-    basic_xml_oarchive<Archive>(flags)
-{
-    if(0 == (flags & no_codecvt)){
-        std::locale l = std::locale(
-            os_.getloc(),
-            new boost::archive::detail::utf8_codecvt_facet
-        );
-        os_.flush();
-        os_.imbue(l);
-    }
-    if(0 == (flags & no_header))
-        this->init();
-}
-
-template<class Archive>
-BOOST_WARCHIVE_DECL
-xml_woarchive_impl<Archive>::~xml_woarchive_impl(){
-    if(std::uncaught_exception())
-        return;
-    if(0 == (this->get_flags() & no_header)){
-        save(L"</boost_serialization>\n");
-    }
-}
-
-template<class Archive>
-BOOST_WARCHIVE_DECL void
-xml_woarchive_impl<Archive>::save_binary(
-    const void *address,
-    std::size_t count
-){
-    this->end_preamble();
-    #if ! defined(__MWERKS__)
-    this->basic_text_oprimitive<std::wostream>::save_binary(
-    #else
-    this->basic_text_oprimitive::save_binary(
-    #endif
-        address, 
-        count
-    );
-    this->indent_next = true;
-}
-
-} // namespace archive
-} // namespace boost
-
-#endif //BOOST_NO_STD_WSTREAMBUF
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/iterators/base64_exception.hpp b/contrib/libboost/boost_1_65_0/boost/archive/iterators/base64_exception.hpp
deleted file mode 100644
index 8f9208b60ea..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/iterators/base64_exception.hpp
+++ /dev/null
@@ -1,68 +0,0 @@
-#ifndef BOOST_ARCHIVE_ITERATORS_BASE64_EXCEPTION_HPP
-#define BOOST_ARCHIVE_ITERATORS_BASE64_EXCEPTION_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// base64_exception.hpp:
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/config.hpp>
-#ifndef BOOST_NO_EXCEPTIONS
-#include <exception>
-
-#include <boost/assert.hpp>
-
-namespace boost {
-namespace archive {
-namespace iterators {
-
-//////////////////////////////////////////////////////////////////////
-// exceptions thrown by base64s
-//
-class base64_exception : public std::exception
-{
-public:
-    typedef enum {
-        invalid_code,       // attempt to encode a value > 6 bits
-        invalid_character,  // decode a value not in base64 char set
-        other_exception
-    } exception_code;
-    exception_code code;
-
-    base64_exception(exception_code c = other_exception) : code(c)
-    {}
-
-    virtual const char *what( ) const throw( )
-    {
-        const char *msg = "unknown exception code";
-        switch(code){
-        case invalid_code:
-            msg = "attempt to encode a value > 6 bits";
-            break;
-        case invalid_character:
-            msg = "attempt to decode a value not in base64 char set";
-            break;
-        default:
-            BOOST_ASSERT(false);
-            break;
-        }
-        return msg;
-    }
-};
-
-} // namespace iterators
-} // namespace archive
-} // namespace boost
-
-#endif //BOOST_NO_EXCEPTIONS
-#endif //BOOST_ARCHIVE_ITERATORS_ARCHIVE_EXCEPTION_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/iterators/base64_from_binary.hpp b/contrib/libboost/boost_1_65_0/boost/archive/iterators/base64_from_binary.hpp
deleted file mode 100644
index ee849944397..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/iterators/base64_from_binary.hpp
+++ /dev/null
@@ -1,109 +0,0 @@
-#ifndef BOOST_ARCHIVE_ITERATORS_BASE64_FROM_BINARY_HPP
-#define BOOST_ARCHIVE_ITERATORS_BASE64_FROM_BINARY_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// base64_from_binary.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/assert.hpp>
-
-#include <cstddef> // size_t
-#if defined(BOOST_NO_STDC_NAMESPACE)
-namespace std{ 
-    using ::size_t; 
-} // namespace std
-#endif
-
-#include <boost/iterator/transform_iterator.hpp>
-#include <boost/archive/iterators/dataflow_exception.hpp>
-
-namespace boost { 
-namespace archive {
-namespace iterators {
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// convert binary integers to base64 characters
-
-namespace detail {
-
-template<class CharType>
-struct from_6_bit {
-    typedef CharType result_type;
-    CharType operator()(CharType t) const{
-        static const char * lookup_table =
-            "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
-            "abcdefghijklmnopqrstuvwxyz"
-            "0123456789"
-            "+/";
-        BOOST_ASSERT(t < 64);
-        return lookup_table[static_cast<size_t>(t)];
-    }
-};
-
-} // namespace detail
-
-// note: what we would like to do is
-// template<class Base, class CharType = typename Base::value_type>
-//  typedef transform_iterator<
-//      from_6_bit<CharType>,
-//      transform_width<Base, 6, sizeof(Base::value_type) * 8, CharType>
-//  > base64_from_binary;
-// but C++ won't accept this.  Rather than using a "type generator" and
-// using a different syntax, make a derivation which should be equivalent.
-//
-// Another issue addressed here is that the transform_iterator doesn't have
-// a templated constructor.  This makes it incompatible with the dataflow
-// ideal.  This is also addressed here.
-
-//template<class Base, class CharType = typename Base::value_type>
-template<
-    class Base, 
-    class CharType = typename boost::iterator_value<Base>::type
->
-class base64_from_binary : 
-    public transform_iterator<
-        detail::from_6_bit<CharType>,
-        Base
-    >
-{
-    friend class boost::iterator_core_access;
-    typedef transform_iterator<
-        typename detail::from_6_bit<CharType>,
-        Base
-    > super_t;
-
-public:
-    // make composible buy using templated constructor
-    template<class T>
-    base64_from_binary(T start) :
-        super_t(
-            Base(static_cast< T >(start)),
-            detail::from_6_bit<CharType>()
-        )
-    {}
-    // intel 7.1 doesn't like default copy constructor
-    base64_from_binary(const base64_from_binary & rhs) : 
-        super_t(
-            Base(rhs.base_reference()),
-            detail::from_6_bit<CharType>()
-        )
-    {}
-//    base64_from_binary(){};
-};
-
-} // namespace iterators
-} // namespace archive
-} // namespace boost
-
-#endif // BOOST_ARCHIVE_ITERATORS_BASE64_FROM_BINARY_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/iterators/binary_from_base64.hpp b/contrib/libboost/boost_1_65_0/boost/archive/iterators/binary_from_base64.hpp
deleted file mode 100644
index 89b8f889da3..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/iterators/binary_from_base64.hpp
+++ /dev/null
@@ -1,118 +0,0 @@
-#ifndef BOOST_ARCHIVE_ITERATORS_BINARY_FROM_BASE64_HPP
-#define BOOST_ARCHIVE_ITERATORS_BINARY_FROM_BASE64_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// binary_from_base64.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/assert.hpp>
-
-#include <boost/serialization/throw_exception.hpp>
-#include <boost/static_assert.hpp>
-
-#include <boost/iterator/transform_iterator.hpp>
-#include <boost/archive/iterators/dataflow_exception.hpp>
-
-namespace boost { 
-namespace archive {
-namespace iterators {
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// convert base64 characters to binary data
-
-namespace detail {
-
-template<class CharType>
-struct to_6_bit {
-    typedef CharType result_type;
-    CharType operator()(CharType t) const{
-        static const signed char lookup_table[] = {
-            -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
-            -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
-            -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,62,-1,-1,-1,63,
-            52,53,54,55,56,57,58,59,60,61,-1,-1,-1, 0,-1,-1, // render '=' as 0
-            -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,
-            15,16,17,18,19,20,21,22,23,24,25,-1,-1,-1,-1,-1,
-            -1,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,
-            41,42,43,44,45,46,47,48,49,50,51,-1,-1,-1,-1,-1
-        };
-        // metrowerks trips this assertion - how come?
-        #if ! defined(__MWERKS__)
-        BOOST_STATIC_ASSERT(128 == sizeof(lookup_table));
-        #endif
-        signed char value = -1;
-        if((unsigned)t <= 127)
-            value = lookup_table[(unsigned)t];
-        if(-1 == value)
-            boost::serialization::throw_exception(
-                dataflow_exception(dataflow_exception::invalid_base64_character)
-            );
-        return value;
-    }
-};
-
-} // namespace detail
-
-// note: what we would like to do is
-// template<class Base, class CharType = typename Base::value_type>
-//  typedef transform_iterator<
-//      from_6_bit<CharType>,
-//      transform_width<Base, 6, sizeof(Base::value_type) * 8, CharType>
-//  > base64_from_binary;
-// but C++ won't accept this.  Rather than using a "type generator" and
-// using a different syntax, make a derivation which should be equivalent.
-//
-// Another issue addressed here is that the transform_iterator doesn't have
-// a templated constructor.  This makes it incompatible with the dataflow
-// ideal.  This is also addressed here.
-
-template<
-    class Base, 
-    class CharType = typename boost::iterator_value<Base>::type
->
-class binary_from_base64 : public
-    transform_iterator<
-        detail::to_6_bit<CharType>,
-        Base
-    >
-{
-    friend class boost::iterator_core_access;
-    typedef transform_iterator<
-        detail::to_6_bit<CharType>,
-        Base
-    > super_t;
-public:
-    // make composible buy using templated constructor
-    template<class T>
-    binary_from_base64(T  start) :
-        super_t(
-            Base(static_cast< T >(start)),
-            detail::to_6_bit<CharType>()
-        )
-    {}
-    // intel 7.1 doesn't like default copy constructor
-    binary_from_base64(const binary_from_base64 & rhs) : 
-        super_t(
-            Base(rhs.base_reference()),
-            detail::to_6_bit<CharType>()
-        )
-    {}
-//    binary_from_base64(){};
-};
-
-} // namespace iterators
-} // namespace archive
-} // namespace boost
-
-#endif // BOOST_ARCHIVE_ITERATORS_BINARY_FROM_BASE64_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/iterators/dataflow.hpp b/contrib/libboost/boost_1_65_0/boost/archive/iterators/dataflow.hpp
deleted file mode 100644
index 07733d5fd62..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/iterators/dataflow.hpp
+++ /dev/null
@@ -1,102 +0,0 @@
-#ifndef BOOST_ARCHIVE_ITERATORS_DATAFLOW_HPP
-#define BOOST_ARCHIVE_ITERATORS_DATAFLOW_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// dataflow.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/assert.hpp>
-
-#include <boost/mpl/eval_if.hpp>
-#include <boost/mpl/if.hpp>
-#include <boost/mpl/apply.hpp>
-#include <boost/mpl/plus.hpp>
-#include <boost/mpl/int.hpp>
-
-#include <boost/type_traits/is_convertible.hpp>
-#include <boost/type_traits/is_base_and_derived.hpp>
-#include <boost/type_traits/is_pointer.hpp>
-#include <boost/iterator/iterator_adaptor.hpp>
-#include <boost/iterator/iterator_traits.hpp>
-#include <boost/static_assert.hpp>
-
-namespace boost { 
-namespace archive {
-namespace iterators {
-
-// poor man's tri-state
-struct tri_state {
-    enum state_enum {
-        is_false = false,
-        is_true = true,
-        is_indeterminant
-    } m_state;
-    // convert to bool
-    operator bool (){
-        BOOST_ASSERT(is_indeterminant != m_state);
-        return is_true == m_state ? true : false;
-    }
-    // assign from bool
-    tri_state & operator=(bool rhs) {
-        m_state = rhs ? is_true : is_false;
-        return *this;
-    }
-    tri_state(bool rhs) :
-        m_state(rhs ? is_true : is_false)
-    {}
-    tri_state(state_enum state) :
-        m_state(state)
-    {}
-    bool operator==(const tri_state & rhs) const {
-        return m_state == rhs.m_state;
-    }
-    bool operator!=(const tri_state & rhs) const {
-        return m_state != rhs.m_state;
-    }
-};
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// implement functions common to dataflow iterators
-template<class Derived>
-class dataflow {
-    bool m_eoi;
-protected:
-    // test for iterator equality
-    tri_state equal(const Derived & rhs) const {
-        if(m_eoi && rhs.m_eoi)
-            return true;
-        if(m_eoi || rhs.m_eoi)
-            return false;
-        return tri_state(tri_state::is_indeterminant);
-    }
-    void eoi(bool tf){
-        m_eoi = tf;
-    }
-    bool eoi() const {
-        return m_eoi;
-    }
-public:
-    dataflow(bool tf) :
-        m_eoi(tf)
-    {}
-    dataflow() : // used for iterator end
-        m_eoi(true)
-    {}
-};
-
-} // namespace iterators
-} // namespace archive
-} // namespace boost
-
-#endif // BOOST_ARCHIVE_ITERATORS_DATAFLOW_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/iterators/dataflow_exception.hpp b/contrib/libboost/boost_1_65_0/boost/archive/iterators/dataflow_exception.hpp
deleted file mode 100644
index e3e18605b38..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/iterators/dataflow_exception.hpp
+++ /dev/null
@@ -1,80 +0,0 @@
-#ifndef BOOST_ARCHIVE_ITERATORS_DATAFLOW_EXCEPTION_HPP
-#define BOOST_ARCHIVE_ITERATORS_DATAFLOW_EXCEPTION_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// dataflow_exception.hpp:
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/config.hpp>
-#ifndef BOOST_NO_EXCEPTIONS
-#include <exception>
-#endif //BOOST_NO_EXCEPTIONS
-
-#include <boost/assert.hpp>
-
-namespace boost {
-namespace archive {
-namespace iterators {
-
-//////////////////////////////////////////////////////////////////////
-// exceptions thrown by dataflows
-//
-class dataflow_exception : public std::exception
-{
-public:
-    typedef enum {
-        invalid_6_bitcode,
-        invalid_base64_character,
-        invalid_xml_escape_sequence,
-        comparison_not_permitted,
-        invalid_conversion,
-        other_exception
-    } exception_code;
-    exception_code code;
-
-    dataflow_exception(exception_code c = other_exception) : code(c)
-    {}
-
-    virtual const char *what( ) const throw( )
-    {
-        const char *msg = "unknown exception code";
-        switch(code){
-        case invalid_6_bitcode:
-            msg = "attempt to encode a value > 6 bits";
-            break;
-        case invalid_base64_character:
-            msg = "attempt to decode a value not in base64 char set";
-            break;
-        case invalid_xml_escape_sequence:
-            msg = "invalid xml escape_sequence";
-            break;
-        case comparison_not_permitted:
-            msg = "cannot invoke iterator comparison now";
-            break;
-        case invalid_conversion:
-            msg = "invalid multbyte/wide char conversion";
-            break;
-        default:
-            BOOST_ASSERT(false);
-            break;
-        }
-        return msg;
-    }
-};
-
-} // namespace iterators
-} // namespace archive
-} // namespace boost
-
-#endif //BOOST_ARCHIVE_ITERATORS_DATAFLOW_EXCEPTION_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/iterators/escape.hpp b/contrib/libboost/boost_1_65_0/boost/archive/iterators/escape.hpp
deleted file mode 100644
index 103b31e0fef..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/iterators/escape.hpp
+++ /dev/null
@@ -1,115 +0,0 @@
-#ifndef BOOST_ARCHIVE_ITERATORS_ESCAPE_HPP
-#define BOOST_ARCHIVE_ITERATORS_ESCAPE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// escape.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/assert.hpp>
-#include <cstddef> // NULL
-
-#include <boost/iterator/iterator_adaptor.hpp>
-#include <boost/iterator/iterator_traits.hpp>
-
-namespace boost { 
-namespace archive {
-namespace iterators {
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// insert escapes into text
-
-template<class Derived, class Base>
-class escape : 
-    public boost::iterator_adaptor<
-        Derived, 
-        Base, 
-        typename boost::iterator_value<Base>::type,
-        single_pass_traversal_tag,
-        typename boost::iterator_value<Base>::type
-    >
-{
-    typedef typename boost::iterator_value<Base>::type base_value_type;
-    typedef typename boost::iterator_reference<Base>::type reference_type;
-    friend class boost::iterator_core_access;
-
-    typedef typename boost::iterator_adaptor<
-        Derived, 
-        Base, 
-        base_value_type,
-        single_pass_traversal_tag,
-        base_value_type
-    > super_t;
-
-    typedef escape<Derived, Base> this_t;
-
-    void dereference_impl() {
-        m_current_value = static_cast<Derived *>(this)->fill(m_bnext, m_bend);
-        m_full = true;
-    }
-
-    //Access the value referred to 
-    reference_type dereference() const {
-        if(!m_full)
-            const_cast<this_t *>(this)->dereference_impl();
-        return m_current_value;
-    }
-
-    bool equal(const this_t & rhs) const {
-        if(m_full){
-            if(! rhs.m_full)
-                const_cast<this_t *>(& rhs)->dereference_impl();
-        }
-        else{
-            if(rhs.m_full)
-                const_cast<this_t *>(this)->dereference_impl();
-        }
-        if(m_bnext != rhs.m_bnext)
-            return false;
-        if(this->base_reference() != rhs.base_reference())
-            return false;
-        return true;
-    }
-
-   void increment(){
-        if(++m_bnext < m_bend){
-            m_current_value = *m_bnext;
-            return;
-        }
-        ++(this->base_reference());
-        m_bnext = NULL;
-        m_bend = NULL;
-        m_full = false;
-    }
-
-    // buffer to handle pending characters
-    const base_value_type *m_bnext;
-    const base_value_type *m_bend;
-    bool m_full;
-    base_value_type m_current_value;
-public:
-    escape(Base base) : 
-        super_t(base),
-        m_bnext(NULL),
-        m_bend(NULL),
-        m_full(false),
-        m_current_value(0)
-    {
-    }
-};
-
-} // namespace iterators
-} // namespace archive
-} // namespace boost
-
-#endif // BOOST_ARCHIVE_ITERATORS_ESCAPE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/iterators/insert_linebreaks.hpp b/contrib/libboost/boost_1_65_0/boost/archive/iterators/insert_linebreaks.hpp
deleted file mode 100644
index 2504b030db1..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/iterators/insert_linebreaks.hpp
+++ /dev/null
@@ -1,99 +0,0 @@
-#ifndef BOOST_ARCHIVE_ITERATORS_INSERT_LINEBREAKS_HPP
-#define BOOST_ARCHIVE_ITERATORS_INSERT_LINEBREAKS_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// insert_linebreaks.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/assert.hpp>
-
-#include <boost/config.hpp>
-#if defined(BOOST_NO_STDC_NAMESPACE)
-namespace std{ using ::memcpy; }
-#endif
-
-#include <boost/iterator/iterator_adaptor.hpp>
-#include <boost/iterator/iterator_traits.hpp>
-
-namespace boost { 
-namespace archive {
-namespace iterators {
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// insert line break every N characters
-template<
-    class Base, 
-    int N, 
-    class CharType = typename boost::iterator_value<Base>::type
->
-class insert_linebreaks : 
-    public iterator_adaptor<
-        insert_linebreaks<Base, N, CharType>,
-        Base,
-        CharType,
-        single_pass_traversal_tag,
-        CharType
-    >
-{
-private:
-    friend class boost::iterator_core_access;
-    typedef iterator_adaptor<
-        insert_linebreaks<Base, N, CharType>,
-        Base,
-        CharType,
-        single_pass_traversal_tag,
-        CharType
-    > super_t;
-
-    bool equal(const insert_linebreaks<Base, N, CharType> & rhs) const {
-        return
-//            m_count == rhs.m_count
-//            && base_reference() == rhs.base_reference()
-            this->base_reference() == rhs.base_reference()
-        ;
-    }
-
-    void increment() {
-        if(m_count == N){
-            m_count = 0;
-            return;
-        }
-        ++m_count;
-        ++(this->base_reference());
-    }
-    CharType dereference() const {
-        if(m_count == N)
-            return '\n';
-        return * (this->base_reference());
-    }
-    unsigned int m_count;
-public:
-    // make composible buy using templated constructor
-    template<class T>
-    insert_linebreaks(T  start) :
-        super_t(Base(static_cast< T >(start))),
-        m_count(0)
-    {}
-    // intel 7.1 doesn't like default copy constructor
-    insert_linebreaks(const insert_linebreaks & rhs) : 
-        super_t(rhs.base_reference()),
-        m_count(rhs.m_count)
-    {}
-};
-
-} // namespace iterators
-} // namespace archive
-} // namespace boost
-
-#endif // BOOST_ARCHIVE_ITERATORS_INSERT_LINEBREAKS_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/iterators/istream_iterator.hpp b/contrib/libboost/boost_1_65_0/boost/archive/iterators/istream_iterator.hpp
deleted file mode 100644
index a187f605e69..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/iterators/istream_iterator.hpp
+++ /dev/null
@@ -1,92 +0,0 @@
-#ifndef BOOST_ARCHIVE_ITERATORS_ISTREAM_ITERATOR_HPP
-#define BOOST_ARCHIVE_ITERATORS_ISTREAM_ITERATOR_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// istream_iterator.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-// note: this is a custom version of the standard istream_iterator.
-// This is necessary as the standard version doesn't work as expected
-// for wchar_t based streams on systems for which wchar_t not a true
-// type but rather a synonym for some integer type.
-
-#include <cstddef> // NULL
-#include <istream>
-#include <boost/iterator/iterator_facade.hpp>
-
-namespace boost { 
-namespace archive {
-namespace iterators {
-
-// given a type, make an input iterator based on a pointer to that type
-template<class Elem = char>
-class istream_iterator :  
-    public boost::iterator_facade<
-        istream_iterator<Elem>,
-        Elem,
-        std::input_iterator_tag,
-        Elem
-    >
-{
-    friend class boost::iterator_core_access;
-    typedef istream_iterator this_t ;
-    typedef typename boost::iterator_facade<
-        istream_iterator<Elem>,
-        Elem,
-        std::input_iterator_tag,
-        Elem
-    > super_t;
-    typedef typename std::basic_istream<Elem> istream_type;
- 
-    bool equal(const this_t & rhs) const {
-        // note: only  works for comparison against end of stream
-        return m_istream == rhs.m_istream;
-    }
-
-    //Access the value referred to 
-    Elem dereference() const {
-        return static_cast<Elem>(m_istream->peek());
-    }
-
-    void increment(){
-        if(NULL != m_istream){
-            m_istream->ignore(1);
-        }
-    }
-
-    istream_type *m_istream;
-    Elem m_current_value;
-public:
-    istream_iterator(istream_type & is) :
-        m_istream(& is)
-    {
-        //increment();
-    }
-
-    istream_iterator() :
-        m_istream(NULL),
-        m_current_value(NULL)
-    {}
-
-    istream_iterator(const istream_iterator<Elem> & rhs) :
-        m_istream(rhs.m_istream),
-        m_current_value(rhs.m_current_value)
-    {}
-};
-
-} // namespace iterators
-} // namespace archive
-} // namespace boost
-
-#endif // BOOST_ARCHIVE_ITERATORS_ISTREAM_ITERATOR_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/iterators/mb_from_wchar.hpp b/contrib/libboost/boost_1_65_0/boost/archive/iterators/mb_from_wchar.hpp
deleted file mode 100644
index 05df71c258e..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/iterators/mb_from_wchar.hpp
+++ /dev/null
@@ -1,139 +0,0 @@
-#ifndef BOOST_ARCHIVE_ITERATORS_MB_FROM_WCHAR_HPP
-#define BOOST_ARCHIVE_ITERATORS_MB_FROM_WCHAR_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// mb_from_wchar.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/assert.hpp>
-#include <cstddef> // size_t
-#ifndef BOOST_NO_CWCHAR
-#include <cwchar> //  mbstate_t
-#endif
-#include <boost/config.hpp>
-#if defined(BOOST_NO_STDC_NAMESPACE)
-namespace std{ 
-    using ::mbstate_t;
-} // namespace std
-#endif
-
-#include <boost/archive/detail/utf8_codecvt_facet.hpp>
-#include <boost/iterator/iterator_adaptor.hpp>
-
-namespace boost { 
-namespace archive {
-namespace iterators {
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// class used by text archives to translate wide strings and to char
-// strings of the currently selected locale
-template<class Base>    // the input iterator
-class mb_from_wchar
-    : public boost::iterator_adaptor<
-        mb_from_wchar<Base>, 
-        Base, 
-        wchar_t,
-        single_pass_traversal_tag,
-        char
-    >
-{
-    friend class boost::iterator_core_access;
-
-    typedef typename boost::iterator_adaptor<
-        mb_from_wchar<Base>, 
-        Base, 
-        wchar_t,
-        single_pass_traversal_tag,
-        char
-    > super_t;
-
-    typedef mb_from_wchar<Base> this_t;
-
-    char dereference_impl() {
-        if(! m_full){
-            fill();
-            m_full = true;
-        }
-        return m_buffer[m_bnext];
-    }
-
-    char dereference() const {
-        return (const_cast<this_t *>(this))->dereference_impl();
-    }
-    // test for iterator equality
-    bool equal(const mb_from_wchar<Base> & rhs) const {
-        // once the value is filled, the base_reference has been incremented
-        // so don't permit comparison anymore.
-        return 
-            0 == m_bend
-            && 0 == m_bnext
-            && this->base_reference() == rhs.base_reference()
-        ;
-    }
-
-    void fill(){
-        wchar_t value = * this->base_reference();
-        const wchar_t *wend;
-        char *bend;
-        std::codecvt_base::result r = m_codecvt_facet.out(
-            m_mbs,
-            & value, & value + 1, wend,
-            m_buffer, m_buffer + sizeof(m_buffer), bend
-        );
-        BOOST_ASSERT(std::codecvt_base::ok == r);
-        m_bnext = 0;
-        m_bend = bend - m_buffer;
-    }
-
-    void increment(){
-        if(++m_bnext < m_bend)
-            return;
-        m_bend = 
-        m_bnext = 0;
-        ++(this->base_reference());
-        m_full = false;
-    }
-
-    boost::archive::detail::utf8_codecvt_facet m_codecvt_facet;
-    std::mbstate_t m_mbs;
-    // buffer to handle pending characters
-    char m_buffer[9 /* MB_CUR_MAX */];
-    std::size_t m_bend;
-    std::size_t m_bnext;
-    bool m_full;
-
-public:
-    // make composible buy using templated constructor
-    template<class T>
-    mb_from_wchar(T start) :
-        super_t(Base(static_cast< T >(start))),
-        m_mbs(std::mbstate_t()),
-        m_bend(0),
-        m_bnext(0),
-        m_full(false)
-    {}
-    // intel 7.1 doesn't like default copy constructor
-    mb_from_wchar(const mb_from_wchar & rhs) : 
-        super_t(rhs.base_reference()),
-        m_bend(rhs.m_bend),
-        m_bnext(rhs.m_bnext),
-        m_full(rhs.m_full)
-    {}
-};
-
-} // namespace iterators
-} // namespace archive
-} // namespace boost
-
-#endif // BOOST_ARCHIVE_ITERATORS_MB_FROM_WCHAR_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/iterators/ostream_iterator.hpp b/contrib/libboost/boost_1_65_0/boost/archive/iterators/ostream_iterator.hpp
deleted file mode 100644
index 49a9b99034b..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/iterators/ostream_iterator.hpp
+++ /dev/null
@@ -1,83 +0,0 @@
-#ifndef BOOST_ARCHIVE_ITERATORS_OSTREAM_ITERATOR_HPP
-#define BOOST_ARCHIVE_ITERATORS_OSTREAM_ITERATOR_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// ostream_iterator.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-// note: this is a custom version of the standard ostream_iterator.
-// This is necessary as the standard version doesn't work as expected
-// for wchar_t based streams on systems for which wchar_t not a true
-// type but rather a synonym for some integer type.
-
-#include <ostream>
-#include <boost/iterator/iterator_facade.hpp>
-
-namespace boost { 
-namespace archive {
-namespace iterators {
-
-// given a type, make an input iterator based on a pointer to that type
-template<class Elem>
-class ostream_iterator :  
-    public boost::iterator_facade<
-        ostream_iterator<Elem>,
-        Elem,
-        std::output_iterator_tag,
-        ostream_iterator<Elem> &
-    >
-{
-    friend class boost::iterator_core_access;
-    typedef ostream_iterator this_t ;
-    typedef Elem char_type;
-    typedef std::basic_ostream<char_type> ostream_type;
-
-    //emulate the behavior of std::ostream 
-    ostream_iterator & dereference() const {
-        return const_cast<ostream_iterator &>(*this);
-    }
-    bool equal(const this_t & rhs) const {
-        return m_ostream == rhs.m_ostream;
-    }
-    void increment(){}
-protected:
-    ostream_type *m_ostream;
-    void put_val(char_type e){
-        if(NULL != m_ostream){
-            m_ostream->put(e);
-            if(! m_ostream->good())
-                m_ostream = NULL;
-        }
-    }
-public:
-    this_t & operator=(char_type c){
-        put_val(c);
-        return *this;
-    }
-    ostream_iterator(ostream_type & os) :
-        m_ostream (& os)
-    {}
-    ostream_iterator() :
-        m_ostream (NULL)
-    {}
-    ostream_iterator(const ostream_iterator & rhs) :
-        m_ostream (rhs.m_ostream)
-    {}
-};
-
-} // namespace iterators
-} // namespace archive
-} // namespace boost
-
-#endif // BOOST_ARCHIVE_ITERATORS_OSTREAM_ITERATOR_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/iterators/remove_whitespace.hpp b/contrib/libboost/boost_1_65_0/boost/archive/iterators/remove_whitespace.hpp
deleted file mode 100644
index c3580ab258a..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/iterators/remove_whitespace.hpp
+++ /dev/null
@@ -1,167 +0,0 @@
-#ifndef BOOST_ARCHIVE_ITERATORS_REMOVE_WHITESPACE_HPP
-#define BOOST_ARCHIVE_ITERATORS_REMOVE_WHITESPACE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// remove_whitespace.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/assert.hpp>
-
-#include <boost/iterator/iterator_adaptor.hpp>
-#include <boost/iterator/filter_iterator.hpp>
-#include <boost/iterator/iterator_traits.hpp>
-
-// here is the default standard implementation of the functor used
-// by the filter iterator to remove spaces.  Unfortunately usage
-// of this implementation in combination with spirit trips a bug
-// VC 6.5.  The only way I can find to work around it is to 
-// implement a special non-standard version for this platform
-
-#ifndef BOOST_NO_CWCTYPE
-#include <cwctype> // iswspace
-#if defined(BOOST_NO_STDC_NAMESPACE)
-namespace std{ using ::iswspace; }
-#endif
-#endif
-
-#include <cctype> // isspace
-#if defined(BOOST_NO_STDC_NAMESPACE)
-namespace std{ using ::isspace; }
-#endif
-
-#if defined(__STD_RWCOMPILER_H__) || defined(_RWSTD_VER)
-// this is required for the RW STL on Linux and Tru64.
-#undef isspace
-#undef iswspace
-#endif
-
-namespace { // anonymous
-
-template<class CharType>
-struct remove_whitespace_predicate;
-
-template<>
-struct remove_whitespace_predicate<char>
-{
-    bool operator()(unsigned char t){
-        return ! std::isspace(t);
-    }
-};
-
-#ifndef BOOST_NO_CWCHAR
-template<>
-struct remove_whitespace_predicate<wchar_t>
-{
-    bool operator()(wchar_t t){
-        return ! std::iswspace(t);
-    }
-};
-#endif
-
-} // namespace anonymous
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// convert base64 file data (including whitespace and padding) to binary
-
-namespace boost { 
-namespace archive {
-namespace iterators {
-
-// custom version of filter iterator which doesn't look ahead further than
-// necessary
-
-template<class Predicate, class Base>
-class filter_iterator
-    : public boost::iterator_adaptor<
-        filter_iterator<Predicate, Base>,
-        Base,
-        use_default,
-        single_pass_traversal_tag
-    >
-{
-    friend class boost::iterator_core_access;
-    typedef typename boost::iterator_adaptor<
-        filter_iterator<Predicate, Base>,
-        Base,
-        use_default,
-        single_pass_traversal_tag
-    > super_t;
-    typedef filter_iterator<Predicate, Base> this_t;
-    typedef typename super_t::reference reference_type;
-
-    reference_type dereference_impl(){
-        if(! m_full){
-            while(! m_predicate(* this->base_reference()))
-                ++(this->base_reference());
-            m_full = true;
-        }
-        return * this->base_reference();
-    }
-
-    reference_type dereference() const {
-        return const_cast<this_t *>(this)->dereference_impl();
-    }
-
-    Predicate m_predicate;
-    bool m_full;
-public:
-    // note: this function is public only because comeau compiler complained
-    // I don't know if this is because the compiler is wrong or what
-    void increment(){
-        m_full = false;
-        ++(this->base_reference());
-    }
-    filter_iterator(Base start) : 
-        super_t(start), 
-        m_full(false)
-    {}
-    filter_iterator(){}
-};
-
-template<class Base>
-class remove_whitespace : 
-    public filter_iterator<
-        remove_whitespace_predicate<
-            typename boost::iterator_value<Base>::type
-            //typename Base::value_type
-        >,
-        Base
-    >
-{
-    friend class boost::iterator_core_access;
-    typedef filter_iterator<
-        remove_whitespace_predicate<
-            typename boost::iterator_value<Base>::type
-            //typename Base::value_type
-        >,
-        Base
-    > super_t;
-public:
-//    remove_whitespace(){} // why is this needed?
-    // make composible buy using templated constructor
-    template<class T>
-    remove_whitespace(T start) :
-        super_t(Base(static_cast< T >(start)))
-    {}
-    // intel 7.1 doesn't like default copy constructor
-    remove_whitespace(const remove_whitespace & rhs) : 
-        super_t(rhs.base_reference())
-    {}
-};
-
-} // namespace iterators
-} // namespace archive
-} // namespace boost
-
-#endif // BOOST_ARCHIVE_ITERATORS_REMOVE_WHITESPACE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/iterators/transform_width.hpp b/contrib/libboost/boost_1_65_0/boost/archive/iterators/transform_width.hpp
deleted file mode 100644
index 09c050a9274..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/iterators/transform_width.hpp
+++ /dev/null
@@ -1,177 +0,0 @@
-#ifndef BOOST_ARCHIVE_ITERATORS_TRANSFORM_WIDTH_HPP
-#define BOOST_ARCHIVE_ITERATORS_TRANSFORM_WIDTH_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// transform_width.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-// iterator which takes elements of x bits and returns elements of y bits.
-// used to change streams of 8 bit characters into streams of 6 bit characters.
-// and vice-versa for implementing base64 encodeing/decoding. Be very careful
-// when using and end iterator.  end is only reliable detected when the input
-// stream length is some common multiple of x and y.  E.G. Base64 6 bit
-// character and 8 bit bytes. Lowest common multiple is 24 => 4 6 bit characters
-// or 3 8 bit characters
-
-#include <boost/iterator/iterator_adaptor.hpp>
-#include <boost/iterator/iterator_traits.hpp>
-
-#include <algorithm> // std::min
-
-namespace boost { 
-namespace archive {
-namespace iterators {
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// class used by text archives to translate char strings to wchar_t
-// strings of the currently selected locale
-template<
-    class Base, 
-    int BitsOut, 
-    int BitsIn, 
-    class CharType = typename boost::iterator_value<Base>::type // output character
->
-class transform_width : 
-    public boost::iterator_adaptor<
-        transform_width<Base, BitsOut, BitsIn, CharType>,
-        Base,
-        CharType,
-        single_pass_traversal_tag,
-        CharType
-    >
-{
-    friend class boost::iterator_core_access;
-    typedef typename boost::iterator_adaptor<
-        transform_width<Base, BitsOut, BitsIn, CharType>,
-        Base,
-        CharType,
-        single_pass_traversal_tag,
-        CharType
-    > super_t;
-
-    typedef transform_width<Base, BitsOut, BitsIn, CharType> this_t;
-    typedef typename iterator_value<Base>::type base_value_type;
-
-    void fill();
-
-    CharType dereference() const {
-        if(!m_buffer_out_full)
-            const_cast<this_t *>(this)->fill();
-        return m_buffer_out;
-    }
-
-    bool equal_impl(const this_t & rhs){
-        if(BitsIn < BitsOut) // discard any left over bits
-            return this->base_reference() == rhs.base_reference();
-        else{
-            // BitsIn > BitsOut  // zero fill
-            if(this->base_reference() == rhs.base_reference()){
-                m_end_of_sequence = true;
-                return 0 == m_remaining_bits;
-            }
-            return false;
-        }
-    }
-
-    // standard iterator interface
-    bool equal(const this_t & rhs) const {
-        return const_cast<this_t *>(this)->equal_impl(rhs);
-    }
-
-    void increment(){
-        m_buffer_out_full = false;
-    }
-
-    bool m_buffer_out_full;
-    CharType m_buffer_out;
-
-    // last read element from input
-    base_value_type m_buffer_in;
-
-    // number of bits to left in the input buffer.
-    unsigned int m_remaining_bits;
-
-    // flag to indicate we've reached end of data.
-    bool m_end_of_sequence;
-
-public:
-    // make composible buy using templated constructor
-    template<class T>
-    transform_width(T start) : 
-        super_t(Base(static_cast< T >(start))),
-        m_buffer_out_full(false),
-        m_buffer_out(0),
-        // To disable GCC warning, but not truly necessary 
-	    //(m_buffer_in will be initialized later before being 
-	    //used because m_remaining_bits == 0)
-        m_buffer_in(0), 
-        m_remaining_bits(0),
-        m_end_of_sequence(false)
-    {}
-    // intel 7.1 doesn't like default copy constructor
-    transform_width(const transform_width & rhs) : 
-        super_t(rhs.base_reference()),
-        m_buffer_out_full(rhs.m_buffer_out_full),
-        m_buffer_out(rhs.m_buffer_out),
-        m_buffer_in(rhs.m_buffer_in),
-        m_remaining_bits(rhs.m_remaining_bits),
-        m_end_of_sequence(false)
-    {}
-};
-
-template<
-    class Base, 
-    int BitsOut, 
-    int BitsIn, 
-    class CharType
->
-void transform_width<Base, BitsOut, BitsIn, CharType>::fill() {
-    unsigned int missing_bits = BitsOut;
-    m_buffer_out = 0;
-    do{
-        if(0 == m_remaining_bits){
-            if(m_end_of_sequence){
-                m_buffer_in = 0;
-                m_remaining_bits = missing_bits;
-            }
-            else{
-                m_buffer_in = * this->base_reference()++;
-                m_remaining_bits = BitsIn;
-            }
-        }
-
-        // append these bits to the next output
-        // up to the size of the output
-        unsigned int i = (std::min)(missing_bits, m_remaining_bits);
-        // shift interesting bits to least significant position
-        base_value_type j = m_buffer_in >> (m_remaining_bits - i);
-        // and mask off the un interesting higher bits
-        // note presumption of twos complement notation
-        j &= (1 << i) - 1;
-        // append then interesting bits to the output value
-        m_buffer_out <<= i;
-        m_buffer_out |= j;
-
-        // and update counters
-        missing_bits -= i;
-        m_remaining_bits -= i;
-    }while(0 < missing_bits);
-    m_buffer_out_full = true;
-}
-
-} // namespace iterators
-} // namespace archive
-} // namespace boost
-
-#endif // BOOST_ARCHIVE_ITERATORS_TRANSFORM_WIDTH_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/iterators/unescape.hpp b/contrib/libboost/boost_1_65_0/boost/archive/iterators/unescape.hpp
deleted file mode 100644
index abf62406088..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/iterators/unescape.hpp
+++ /dev/null
@@ -1,89 +0,0 @@
-#ifndef BOOST_ARCHIVE_ITERATORS_UNESCAPE_HPP
-#define BOOST_ARCHIVE_ITERATORS_UNESCAPE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// unescape.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/assert.hpp>
-
-#include <boost/iterator/iterator_adaptor.hpp>
-#include <boost/pointee.hpp>
-
-namespace boost { 
-namespace archive {
-namespace iterators {
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// class used by text archives to translate char strings to wchar_t
-// strings of the currently selected locale
-template<class Derived, class Base>
-class unescape 
-    : public boost::iterator_adaptor<
-        unescape<Derived, Base>,
-        Base, 
-        typename pointee<Base>::type,
-        single_pass_traversal_tag,
-        typename pointee<Base>::type
-    >
-{
-    friend class boost::iterator_core_access;
-    typedef typename boost::iterator_adaptor<
-        unescape<Derived, Base>, 
-        Base, 
-        typename pointee<Base>::type,
-        single_pass_traversal_tag,
-        typename pointee<Base>::type
-    > super_t;
-
-    typedef unescape<Derived, Base> this_t;
-public:
-    typedef typename this_t::value_type value_type;
-    typedef typename this_t::reference reference;
-private:
-    value_type dereference_impl() {
-        if(! m_full){
-            m_current_value = static_cast<Derived *>(this)->drain();
-            m_full = true;
-        }
-        return m_current_value;
-    }
-
-    reference dereference() const {
-        return const_cast<this_t *>(this)->dereference_impl();
-    }
-
-    value_type m_current_value;
-    bool m_full;
-
-    void increment(){
-        ++(this->base_reference());
-        dereference_impl();
-        m_full = false;
-    };
-
-public:
-
-    unescape(Base base) : 
-        super_t(base),
-        m_full(false)
-    {}
-
-};
-
-} // namespace iterators
-} // namespace archive
-} // namespace boost
-
-#endif // BOOST_ARCHIVE_ITERATORS_UNESCAPE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/iterators/wchar_from_mb.hpp b/contrib/libboost/boost_1_65_0/boost/archive/iterators/wchar_from_mb.hpp
deleted file mode 100644
index 2af8f6401f2..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/iterators/wchar_from_mb.hpp
+++ /dev/null
@@ -1,194 +0,0 @@
-#ifndef BOOST_ARCHIVE_ITERATORS_WCHAR_FROM_MB_HPP
-#define BOOST_ARCHIVE_ITERATORS_WCHAR_FROM_MB_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// wchar_from_mb.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/assert.hpp>
-#include <cctype>
-#include <cstddef> // size_t
-#ifndef BOOST_NO_CWCHAR
-#include <cwchar>  // mbstate_t
-#endif
-#include <algorithm> // copy
-
-#include <boost/config.hpp>
-#if defined(BOOST_NO_STDC_NAMESPACE)
-namespace std{ 
-    using ::mbstate_t;
-} // namespace std
-#endif
-#include <boost/array.hpp>
-#include <boost/iterator/iterator_adaptor.hpp>
-#include <boost/archive/detail/utf8_codecvt_facet.hpp>
-#include <boost/archive/iterators/dataflow_exception.hpp>
-#include <boost/serialization/throw_exception.hpp>
-
-#include <iostream>
-
-namespace boost { 
-namespace archive {
-namespace iterators {
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// class used by text archives to translate char strings to wchar_t
-// strings of the currently selected locale
-template<class Base>
-class wchar_from_mb 
-    : public boost::iterator_adaptor<
-        wchar_from_mb<Base>, 
-        Base, 
-        wchar_t,
-        single_pass_traversal_tag,
-        wchar_t
-    >
-{
-    friend class boost::iterator_core_access;
-    typedef typename boost::iterator_adaptor<
-        wchar_from_mb<Base>, 
-        Base, 
-        wchar_t,
-        single_pass_traversal_tag,
-        wchar_t
-    > super_t;
-
-    typedef wchar_from_mb<Base> this_t;
-
-    void drain();
-
-    wchar_t dereference() const {
-        if(m_output.m_next == m_output.m_next_available)
-            return static_cast<wchar_t>(0);
-        return * m_output.m_next;
-    }
-
-    void increment(){
-        if(m_output.m_next == m_output.m_next_available)
-            return;
-        if(++m_output.m_next == m_output.m_next_available){
-            if(m_input.m_done)
-                return;
-            drain();
-        }
-    }
-
-    bool equal(this_t const & rhs) const {
-        return dereference() == rhs.dereference();
-    }
-
-    boost::archive::detail::utf8_codecvt_facet m_codecvt_facet;
-    std::mbstate_t m_mbs;
-
-    template<typename T>
-    struct sliding_buffer {
-        boost::array<T, 32> m_buffer;
-        typename boost::array<T, 32>::const_iterator m_next_available;
-        typename boost::array<T, 32>::iterator m_next;
-        bool m_done;
-        // default ctor
-        sliding_buffer() :
-            m_next_available(m_buffer.begin()),
-            m_next(m_buffer.begin()),
-            m_done(false)
-        {}
-        // copy ctor
-        sliding_buffer(const sliding_buffer & rhs) :
-            m_next_available(
-                std::copy(
-                    rhs.m_buffer.begin(),
-                    rhs.m_next_available,
-                    m_buffer.begin()
-                )
-            ),
-            m_next(
-                m_buffer.begin() + (rhs.m_next - rhs.m_buffer.begin())
-            ),
-            m_done(rhs.m_done)
-        {}
-    };
-
-    sliding_buffer<typename iterator_value<Base>::type> m_input;
-    sliding_buffer<typename iterator_value<this_t>::type> m_output;
-
-public:
-    // make composible buy using templated constructor
-    template<class T>
-    wchar_from_mb(T start) : 
-        super_t(Base(static_cast< T >(start))),
-        m_mbs(std::mbstate_t())
-    {
-        BOOST_ASSERT(std::mbsinit(&m_mbs));
-        drain();
-    }
-    // default constructor used as an end iterator
-    wchar_from_mb(){}
-
-    // copy ctor
-    wchar_from_mb(const wchar_from_mb & rhs) :
-        super_t(rhs.base_reference()),
-        m_mbs(rhs.m_mbs),
-        m_input(rhs.m_input),
-        m_output(rhs.m_output)
-    {}
-};
-
-template<class Base>
-void wchar_from_mb<Base>::drain(){
-    BOOST_ASSERT(! m_input.m_done);
-    for(;;){
-        typename boost::iterators::iterator_reference<Base>::type c = *(this->base_reference());
-        // a null character in a multibyte stream is takes as end of string
-        if(0 == c){
-            m_input.m_done = true;
-            break;
-        }
-        ++(this->base_reference());
-        * const_cast<typename iterator_value<Base>::type *>(
-            (m_input.m_next_available++)
-        ) = c;
-        // if input buffer is full - we're done for now
-        if(m_input.m_buffer.end() == m_input.m_next_available)
-            break;
-    }
-    const typename boost::iterators::iterator_value<Base>::type * input_new_start;
-    typename iterator_value<this_t>::type * next_available;
-
-    std::codecvt_base::result r = m_codecvt_facet.in(
-        m_mbs,
-        m_input.m_buffer.begin(),
-        m_input.m_next_available,
-        input_new_start,
-        m_output.m_buffer.begin(),
-        m_output.m_buffer.end(),
-        next_available
-    );
-    BOOST_ASSERT(std::codecvt_base::ok == r);
-    m_output.m_next_available = next_available;
-    m_output.m_next = m_output.m_buffer.begin();
-
-    // we're done with some of the input so shift left.
-    m_input.m_next_available = std::copy(
-        input_new_start,
-        m_input.m_next_available,
-        m_input.m_buffer.begin()
-    );
-    m_input.m_next = m_input.m_buffer.begin();
-}
-
-} // namespace iterators
-} // namespace archive
-} // namespace boost
-
-#endif // BOOST_ARCHIVE_ITERATORS_WCHAR_FROM_MB_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/iterators/xml_escape.hpp b/contrib/libboost/boost_1_65_0/boost/archive/iterators/xml_escape.hpp
deleted file mode 100644
index c838a73b864..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/iterators/xml_escape.hpp
+++ /dev/null
@@ -1,121 +0,0 @@
-#ifndef BOOST_ARCHIVE_ITERATORS_XML_ESCAPE_HPP
-#define BOOST_ARCHIVE_ITERATORS_XML_ESCAPE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// xml_escape.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/assert.hpp>
-#include <boost/archive/iterators/escape.hpp>
-
-namespace boost { 
-namespace archive {
-namespace iterators {
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// insert escapes into xml text
-
-template<class Base>
-class xml_escape 
-    : public escape<xml_escape<Base>, Base>
-{
-    friend class boost::iterator_core_access;
-
-    typedef escape<xml_escape<Base>, Base> super_t;
-
-public:
-    char fill(const char * & bstart, const char * & bend);
-    wchar_t fill(const wchar_t * & bstart, const wchar_t * & bend);
-
-    template<class T>
-    xml_escape(T start) :
-        super_t(Base(static_cast< T >(start)))
-    {}
-    // intel 7.1 doesn't like default copy constructor
-    xml_escape(const xml_escape & rhs) : 
-        super_t(rhs.base_reference())
-    {}
-};
-
-template<class Base>
-char xml_escape<Base>::fill(
-    const char * & bstart, 
-    const char * & bend
-){
-    char current_value = * this->base_reference();
-    switch(current_value){
-    case '<':
-        bstart = "&lt;";
-        bend = bstart + 4;
-        break;
-    case '>':
-        bstart = "&gt;";
-        bend = bstart + 4;
-        break;
-    case '&':
-        bstart = "&amp;";
-        bend = bstart + 5;
-        break;
-    case '"':
-        bstart = "&quot;";
-        bend = bstart + 6;
-        break;
-    case '\'':
-        bstart = "&apos;";
-        bend = bstart + 6;
-        break;
-    default:
-        return current_value;
-    }
-    return *bstart;
-}
-
-template<class Base>
-wchar_t xml_escape<Base>::fill(
-    const wchar_t * & bstart, 
-    const wchar_t * & bend
-){
-    wchar_t current_value = * this->base_reference();
-    switch(current_value){
-    case '<':
-        bstart = L"&lt;";
-        bend = bstart + 4;
-        break;
-    case '>':
-        bstart = L"&gt;";
-        bend = bstart + 4;
-        break;
-    case '&':
-        bstart = L"&amp;";
-        bend = bstart + 5;
-        break;
-    case '"':
-        bstart = L"&quot;";
-        bend = bstart + 6;
-        break;
-    case '\'':
-        bstart = L"&apos;";
-        bend = bstart + 6;
-        break;
-    default:
-        return current_value;
-    }
-    return *bstart;
-}
-
-} // namespace iterators
-} // namespace archive
-} // namespace boost
-
-#endif // BOOST_ARCHIVE_ITERATORS_XML_ESCAPE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/iterators/xml_unescape.hpp b/contrib/libboost/boost_1_65_0/boost/archive/iterators/xml_unescape.hpp
deleted file mode 100644
index 69977404567..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/iterators/xml_unescape.hpp
+++ /dev/null
@@ -1,125 +0,0 @@
-#ifndef BOOST_ARCHIVE_ITERATORS_XML_UNESCAPE_HPP
-#define BOOST_ARCHIVE_ITERATORS_XML_UNESCAPE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// xml_unescape.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/assert.hpp>
-
-#include <boost/serialization/throw_exception.hpp>
-
-#include <boost/archive/iterators/unescape.hpp>
-#include <boost/archive/iterators/dataflow_exception.hpp>
-
-namespace boost { 
-namespace archive {
-namespace iterators {
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// replace &??? xml escape sequences with the corresponding characters
-template<class Base>
-class xml_unescape 
-    : public unescape<xml_unescape<Base>, Base>
-{
-    friend class boost::iterator_core_access;
-    typedef xml_unescape<Base> this_t;
-    typedef unescape<this_t, Base> super_t;
-    typedef typename boost::iterator_reference<this_t> reference_type;
-
-    reference_type dereference() const {
-        return unescape<xml_unescape<Base>, Base>::dereference();
-    }
-public:
-    // workaround msvc 7.1 ICU crash
-    #if defined(BOOST_MSVC)
-        typedef int value_type;
-    #else
-        typedef typename this_t::value_type value_type;
-    #endif
-
-    void drain_residue(const char *literal);
-    value_type drain();
-
-    template<class T>
-    xml_unescape(T start) : 
-        super_t(Base(static_cast< T >(start)))
-    {}
-    // intel 7.1 doesn't like default copy constructor
-    xml_unescape(const xml_unescape & rhs) : 
-        super_t(rhs.base_reference())
-    {}
-};
-
-template<class Base>
-void xml_unescape<Base>::drain_residue(const char * literal){
-    do{
-        if(* literal != * ++(this->base_reference()))
-            boost::serialization::throw_exception(
-                dataflow_exception(
-                    dataflow_exception::invalid_xml_escape_sequence
-                )
-            );
-    }
-    while('\0' != * ++literal);
-}
-
-// note key constraint on this function is that can't "look ahead" any
-// more than necessary into base iterator.  Doing so would alter the base
-// iterator refenence which would make subsequent iterator comparisons
-// incorrect and thereby break the composiblity of iterators.
-template<class Base>
-typename xml_unescape<Base>::value_type 
-//int 
-xml_unescape<Base>::drain(){
-    value_type retval = * this->base_reference();
-    if('&' != retval){
-        return retval;
-    }
-    retval = * ++(this->base_reference());
-    switch(retval){
-    case 'l': // &lt;
-        drain_residue("t;");
-        retval = '<';
-        break;
-    case 'g': // &gt;
-        drain_residue("t;");
-        retval = '>';
-        break;
-    case 'a':
-        retval = * ++(this->base_reference());
-        switch(retval){
-        case 'p': // &apos;
-            drain_residue("os;");
-            retval = '\'';
-            break;
-        case 'm': // &amp;
-            drain_residue("p;");
-            retval = '&';
-            break;
-        }
-        break;
-    case 'q':
-        drain_residue("uot;");
-        retval = '"';
-        break;
-    }
-    return retval;
-}
-
-} // namespace iterators
-} // namespace archive
-} // namespace boost
-
-#endif // BOOST_ARCHIVE_ITERATORS_XML_UNESCAPE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/iterators/xml_unescape_exception.hpp b/contrib/libboost/boost_1_65_0/boost/archive/iterators/xml_unescape_exception.hpp
deleted file mode 100644
index 71a64378c20..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/iterators/xml_unescape_exception.hpp
+++ /dev/null
@@ -1,49 +0,0 @@
-#ifndef BOOST_ARCHIVE_ITERATORS_XML_UNESCAPE_EXCEPTION_HPP
-#define BOOST_ARCHIVE_ITERATORS_XML_UNESCAPE_EXCEPTION_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// xml_unescape_exception.hpp:
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/config.hpp>
-#ifndef BOOST_NO_EXCEPTIONS
-#include <exception>
-
-#include <boost/assert.hpp>
-
-namespace boost {
-namespace archive {
-namespace iterators {
-
-//////////////////////////////////////////////////////////////////////
-// exceptions thrown by xml_unescapes
-//
-class xml_unescape_exception : public std::exception
-{
-public:
-    xml_unescape_exception()
-    {}
-
-    virtual const char *what( ) const throw( )
-    {
-        return "xml contained un-recognized escape code";
-    }
-};
-
-} // namespace iterators
-} // namespace archive
-} // namespace boost
-
-#endif //BOOST_NO_EXCEPTIONS
-#endif //BOOST_ARCHIVE_ITERATORS_XML_UNESCAPE_EXCEPTION_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/polymorphic_binary_iarchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/polymorphic_binary_iarchive.hpp
deleted file mode 100644
index 4a898a8ad16..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/polymorphic_binary_iarchive.hpp
+++ /dev/null
@@ -1,54 +0,0 @@
-#ifndef BOOST_ARCHIVE_POLYMORPHIC_BINARY_IARCHIVE_HPP
-#define BOOST_ARCHIVE_POLYMORPHIC_BINARY_IARCHIVE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// polymorphic_binary_iarchive.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/config.hpp>
-#include <boost/archive/binary_iarchive.hpp>
-#include <boost/archive/detail/polymorphic_iarchive_route.hpp>
-
-#ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable : 4511 4512)
-#endif
-
-namespace boost { 
-namespace archive {
-
-class polymorphic_binary_iarchive : 
-    public detail::polymorphic_iarchive_route<binary_iarchive>
-{
-public:
-    polymorphic_binary_iarchive(std::istream & is, unsigned int flags = 0) :
-        detail::polymorphic_iarchive_route<binary_iarchive>(is, flags)
-    {}
-    ~polymorphic_binary_iarchive(){}
-};
-
-} // namespace archive
-} // namespace boost
-
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
-
-// required by export
-BOOST_SERIALIZATION_REGISTER_ARCHIVE(
-    boost::archive::polymorphic_binary_iarchive
-)
-
-#endif // BOOST_ARCHIVE_POLYMORPHIC_BINARY_IARCHIVE_HPP
-
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/polymorphic_binary_oarchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/polymorphic_binary_oarchive.hpp
deleted file mode 100644
index 931b243feb8..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/polymorphic_binary_oarchive.hpp
+++ /dev/null
@@ -1,43 +0,0 @@
-#ifndef BOOST_ARCHIVE_POLYMORPHIC_BINARY_OARCHIVE_HPP
-#define BOOST_ARCHIVE_POLYMORPHIC_BINARY_OARCHIVE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// polymorphic_binary_oarchive.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/config.hpp>
-#include <boost/archive/binary_oarchive.hpp>
-#include <boost/archive/detail/polymorphic_oarchive_route.hpp>
-
-namespace boost { 
-namespace archive {
-
-typedef detail::polymorphic_oarchive_route<
-    binary_oarchive_impl<
-        binary_oarchive, 
-        std::ostream::char_type, 
-        std::ostream::traits_type
-    >
- > polymorphic_binary_oarchive;
-
-} // namespace archive
-} // namespace boost
-
-// required by export
-BOOST_SERIALIZATION_REGISTER_ARCHIVE(
-    boost::archive::polymorphic_binary_oarchive
-)
-
-#endif // BOOST_ARCHIVE_POLYMORPHIC_BINARY_OARCHIVE_HPP
-
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/polymorphic_iarchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/polymorphic_iarchive.hpp
deleted file mode 100644
index d3c59a9f0f4..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/polymorphic_iarchive.hpp
+++ /dev/null
@@ -1,168 +0,0 @@
-#ifndef BOOST_ARCHIVE_POLYMORPHIC_IARCHIVE_HPP
-#define BOOST_ARCHIVE_POLYMORPHIC_IARCHIVE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// polymorphic_iarchive.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <cstddef> // std::size_t
-#include <climits> // ULONG_MAX 
-#include <string>
-
-#include <boost/config.hpp>
-#if defined(BOOST_NO_STDC_NAMESPACE)
-namespace std{
-    using ::size_t;
-} // namespace std
-#endif
-
-#include <boost/cstdint.hpp>
-
-#include <boost/archive/detail/iserializer.hpp>
-#include <boost/archive/detail/interface_iarchive.hpp>
-#include <boost/serialization/nvp.hpp>
-#include <boost/archive/detail/register_archive.hpp>
-
-#include <boost/archive/detail/decl.hpp>
-#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
-
-namespace boost {
-namespace serialization {
-    class extended_type_info;
-} // namespace serialization
-namespace archive {
-namespace detail {
-    class basic_iarchive;
-    class basic_iserializer;
-}
-
-class polymorphic_iarchive;
-
-class BOOST_SYMBOL_VISIBLE polymorphic_iarchive_impl :
-    public detail::interface_iarchive<polymorphic_iarchive>
-{
-#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
-public:
-#else
-    friend class detail::interface_iarchive<polymorphic_iarchive>;
-    friend class load_access;
-#endif
-    // primitive types the only ones permitted by polymorphic archives
-    virtual void load(bool & t) = 0;
-
-    virtual void load(char & t) = 0;
-    virtual void load(signed char & t) = 0;
-    virtual void load(unsigned char & t) = 0;
-    #ifndef BOOST_NO_CWCHAR
-    #ifndef BOOST_NO_INTRINSIC_WCHAR_T
-    virtual void load(wchar_t & t) = 0;
-    #endif
-    #endif
-    virtual void load(short & t) = 0;
-    virtual void load(unsigned short & t) = 0;
-    virtual void load(int & t) = 0;
-    virtual void load(unsigned int & t) = 0;
-    virtual void load(long & t) = 0;
-    virtual void load(unsigned long & t) = 0;
-
-    #if defined(BOOST_HAS_LONG_LONG)
-    virtual void load(boost::long_long_type & t) = 0;
-    virtual void load(boost::ulong_long_type & t) = 0;
-    #elif defined(BOOST_HAS_MS_INT64)
-    virtual void load(__int64 & t) = 0;
-    virtual void load(unsigned __int64 & t) = 0;
-    #endif
-
-    virtual void load(float & t) = 0;
-    virtual void load(double & t) = 0;
-
-    // string types are treated as primitives
-    virtual void load(std::string & t) = 0;
-    #ifndef BOOST_NO_STD_WSTRING
-    virtual void load(std::wstring & t) = 0;
-    #endif
-
-    // used for xml and other tagged formats
-    virtual void load_start(const char * name) = 0;
-    virtual void load_end(const char * name) = 0;
-    virtual void register_basic_serializer(const detail::basic_iserializer & bis) = 0;
-    virtual detail::helper_collection & get_helper_collection() = 0;
-
-    // msvc and borland won't automatically pass these to the base class so
-    // make it explicit here
-    template<class T>
-    void load_override(T & t)
-    {
-        archive::load(* this->This(), t);
-    }
-    // special treatment for name-value pairs.
-    template<class T>
-    void load_override(
-        const boost::serialization::nvp< T > & t
-    ){
-        load_start(t.name());
-        archive::load(* this->This(), t.value());
-        load_end(t.name());
-    }
-protected:
-    virtual ~polymorphic_iarchive_impl(){};
-public:
-    // utility function implemented by all legal archives
-    virtual void set_library_version(library_version_type archive_library_version) = 0;
-    virtual library_version_type get_library_version() const = 0;
-    virtual unsigned int get_flags() const = 0;
-    virtual void delete_created_pointers() = 0;
-    virtual void reset_object_address(
-        const void * new_address,
-        const void * old_address
-    ) = 0;
-
-    virtual void load_binary(void * t, std::size_t size) = 0;
-
-    // these are used by the serialization library implementation.
-    virtual void load_object(
-        void *t,
-        const detail::basic_iserializer & bis
-    ) = 0;
-    virtual const detail::basic_pointer_iserializer * load_pointer(
-        void * & t,
-        const detail::basic_pointer_iserializer * bpis_ptr,
-        const detail::basic_pointer_iserializer * (*finder)(
-            const boost::serialization::extended_type_info & type
-        )
-    ) = 0;
-};
-
-} // namespace archive
-} // namespace boost
-
-#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
-
-namespace boost {
-namespace archive {
-
-class BOOST_SYMBOL_VISIBLE polymorphic_iarchive :
-    public polymorphic_iarchive_impl
-{
-public:
-    virtual ~polymorphic_iarchive(){};
-};
-
-} // namespace archive
-} // namespace boost
-
-// required by export
-BOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::polymorphic_iarchive)
-
-#endif // BOOST_ARCHIVE_POLYMORPHIC_IARCHIVE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/polymorphic_oarchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/polymorphic_oarchive.hpp
deleted file mode 100644
index edac4edb1e8..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/polymorphic_oarchive.hpp
+++ /dev/null
@@ -1,154 +0,0 @@
-#ifndef BOOST_ARCHIVE_POLYMORPHIC_OARCHIVE_HPP
-#define BOOST_ARCHIVE_POLYMORPHIC_OARCHIVE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// polymorphic_oarchive.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <cstddef> // size_t
-#include <climits> // ULONG_MAX 
-#include <string>
-
-#include <boost/config.hpp>
-#if defined(BOOST_NO_STDC_NAMESPACE)
-namespace std{
-    using ::size_t;
-} // namespace std
-#endif
-
-#include <boost/cstdint.hpp>
-#include <boost/archive/detail/oserializer.hpp>
-#include <boost/archive/detail/interface_oarchive.hpp>
-#include <boost/serialization/nvp.hpp>
-#include <boost/archive/detail/register_archive.hpp>
-
-#include <boost/archive/detail/decl.hpp>
-#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
-
-namespace boost {
-namespace serialization {
-    class extended_type_info;
-} // namespace serialization
-namespace archive {
-namespace detail {
-    class basic_oarchive;
-    class basic_oserializer;
-}
-
-class polymorphic_oarchive;
-
-class BOOST_SYMBOL_VISIBLE polymorphic_oarchive_impl :
-    public detail::interface_oarchive<polymorphic_oarchive>
-{
-#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
-public:
-#else
-    friend class detail::interface_oarchive<polymorphic_oarchive>;
-    friend class save_access;
-#endif
-    // primitive types the only ones permitted by polymorphic archives
-    virtual void save(const bool t) = 0;
-
-    virtual void save(const char t) = 0;
-    virtual void save(const signed char t) = 0;
-    virtual void save(const unsigned char t) = 0;
-    #ifndef BOOST_NO_CWCHAR
-    #ifndef BOOST_NO_INTRINSIC_WCHAR_T
-    virtual void save(const wchar_t t) = 0;
-    #endif
-    #endif
-    virtual void save(const short t) = 0;
-    virtual void save(const unsigned short t) = 0;
-    virtual void save(const int t) = 0;
-    virtual void save(const unsigned int t) = 0;
-    virtual void save(const long t) = 0;
-    virtual void save(const unsigned long t) = 0;
-
-    #if defined(BOOST_HAS_LONG_LONG)
-    virtual void save(const boost::long_long_type t) = 0;
-    virtual void save(const boost::ulong_long_type t) = 0;
-    #elif defined(BOOST_HAS_MS_INT64)
-    virtual void save(const __int64 t) = 0;
-    virtual void save(const unsigned __int64 t) = 0;
-    #endif
-
-    virtual void save(const float t) = 0;
-    virtual void save(const double t) = 0;
-
-    // string types are treated as primitives
-    virtual void save(const std::string & t) = 0;
-    #ifndef BOOST_NO_STD_WSTRING
-    virtual void save(const std::wstring & t) = 0;
-    #endif
-
-    virtual void save_null_pointer() = 0;
-    // used for xml and other tagged formats
-    virtual void save_start(const char * name) = 0;
-    virtual void save_end(const char * name) = 0;
-    virtual void register_basic_serializer(const detail::basic_oserializer & bos) = 0;
-    virtual detail::helper_collection & get_helper_collection() = 0;
-
-    virtual void end_preamble() = 0;
-
-    // msvc and borland won't automatically pass these to the base class so
-    // make it explicit here
-    template<class T>
-    void save_override(T & t)
-    {
-        archive::save(* this->This(), t);
-    }
-    // special treatment for name-value pairs.
-    template<class T>
-    void save_override(
-            const ::boost::serialization::nvp< T > & t
-        ){
-        save_start(t.name());
-        archive::save(* this->This(), t.const_value());
-        save_end(t.name());
-    }
-protected:
-    virtual ~polymorphic_oarchive_impl(){};
-public:
-    // utility functions implemented by all legal archives
-    virtual unsigned int get_flags() const = 0;
-    virtual library_version_type get_library_version() const = 0;
-    virtual void save_binary(const void * t, std::size_t size) = 0;
-
-    virtual void save_object(
-        const void *x,
-        const detail::basic_oserializer & bos
-    ) = 0;
-    virtual void save_pointer(
-        const void * t,
-        const detail::basic_pointer_oserializer * bpos_ptr
-    ) = 0;
-};
-
-// note: preserve naming symmetry
-class BOOST_SYMBOL_VISIBLE polymorphic_oarchive : 
-    public polymorphic_oarchive_impl
-{
-public:
-    virtual ~polymorphic_oarchive(){};
-};
-
-} // namespace archive
-} // namespace boost
-
-// required by export
-BOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::polymorphic_oarchive)
-
-#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
-
-#endif // BOOST_ARCHIVE_POLYMORPHIC_OARCHIVE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/polymorphic_text_iarchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/polymorphic_text_iarchive.hpp
deleted file mode 100644
index 7bef2927865..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/polymorphic_text_iarchive.hpp
+++ /dev/null
@@ -1,54 +0,0 @@
-#ifndef BOOST_ARCHIVE_POLYMORPHIC_TEXT_IARCHIVE_HPP
-#define BOOST_ARCHIVE_POLYMORPHIC_TEXT_IARCHIVE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// polymorphic_text_iarchive.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/config.hpp>
-#include <boost/archive/text_iarchive.hpp>
-#include <boost/archive/detail/polymorphic_iarchive_route.hpp>
-
-#ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable : 4511 4512)
-#endif
-
-namespace boost { 
-namespace archive {
-
-class polymorphic_text_iarchive : 
-    public detail::polymorphic_iarchive_route<text_iarchive>
-{
-public:
-    polymorphic_text_iarchive(std::istream & is, unsigned int flags = 0) :
-        detail::polymorphic_iarchive_route<text_iarchive>(is, flags)
-    {}
-    ~polymorphic_text_iarchive(){}
-};
-
-} // namespace archive
-} // namespace boost
-
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
-
-// required by export
-BOOST_SERIALIZATION_REGISTER_ARCHIVE(
-    boost::archive::polymorphic_text_iarchive
-)
-
-#endif // BOOST_ARCHIVE_POLYMORPHIC_TEXT_IARCHIVE_HPP
-
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/polymorphic_text_oarchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/polymorphic_text_oarchive.hpp
deleted file mode 100644
index 457aad9fd75..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/polymorphic_text_oarchive.hpp
+++ /dev/null
@@ -1,39 +0,0 @@
-#ifndef BOOST_ARCHIVE_POLYMORPHIC_TEXT_OARCHIVE_HPP
-#define BOOST_ARCHIVE_POLYMORPHIC_TEXT_OARCHIVE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// polymorphic_text_oarchive.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/config.hpp>
-#include <boost/archive/text_oarchive.hpp>
-#include <boost/archive/detail/polymorphic_oarchive_route.hpp>
-
-namespace boost { 
-namespace archive {
-
-typedef detail::polymorphic_oarchive_route<
-    text_oarchive_impl<text_oarchive> 
-> polymorphic_text_oarchive;
-
-} // namespace archive
-} // namespace boost
-
-// required by export
-BOOST_SERIALIZATION_REGISTER_ARCHIVE(
-    boost::archive::polymorphic_text_oarchive
-)
-
-#endif // BOOST_ARCHIVE_POLYMORPHIC_TEXT_OARCHIVE_HPP
-
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/polymorphic_text_wiarchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/polymorphic_text_wiarchive.hpp
deleted file mode 100644
index 8466f05d6a6..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/polymorphic_text_wiarchive.hpp
+++ /dev/null
@@ -1,59 +0,0 @@
-#ifndef BOOST_ARCHIVE_POLYMORPHIC_TEXT_WIARCHIVE_HPP
-#define BOOST_ARCHIVE_POLYMORPHIC_TEXT_WIARCHIVE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// polymorphic_text_wiarchive.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/config.hpp>
-#ifdef BOOST_NO_STD_WSTREAMBUF
-#error "wide char i/o not supported on this platform"
-#else
-
-#include <boost/archive/text_wiarchive.hpp>
-#include <boost/archive/detail/polymorphic_iarchive_route.hpp>
-
-#ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable : 4511 4512)
-#endif
-
-namespace boost { 
-namespace archive {
-
-class polymorphic_text_wiarchive : 
-    public detail::polymorphic_iarchive_route<text_wiarchive>
-{
-public:
-    polymorphic_text_wiarchive(std::wistream & is, unsigned int flags = 0) :
-        detail::polymorphic_iarchive_route<text_wiarchive>(is, flags)
-    {}
-    ~polymorphic_text_wiarchive(){}
-};
-
-} // namespace archive
-} // namespace boost
-
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
-
-// required by export
-BOOST_SERIALIZATION_REGISTER_ARCHIVE(
-    boost::archive::polymorphic_text_wiarchive
-)
-
-#endif // BOOST_NO_STD_WSTREAMBUF
-#endif // BOOST_ARCHIVE_POLYMORPHIC_TEXT_WIARCHIVE_HPP
-
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/polymorphic_text_woarchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/polymorphic_text_woarchive.hpp
deleted file mode 100644
index 295625d1bcf..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/polymorphic_text_woarchive.hpp
+++ /dev/null
@@ -1,44 +0,0 @@
-#ifndef BOOST_ARCHIVE_POLYMORPHIC_TEXT_WOARCHIVE_HPP
-#define BOOST_ARCHIVE_POLYMORPHIC_TEXT_WOARCHIVE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// polymorphic_text_oarchive.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/config.hpp>
-#ifdef BOOST_NO_STD_WSTREAMBUF
-#error "wide char i/o not supported on this platform"
-#else
-
-#include <boost/archive/text_woarchive.hpp>
-#include <boost/archive/detail/polymorphic_oarchive_route.hpp>
-
-namespace boost { 
-namespace archive {
-
-typedef detail::polymorphic_oarchive_route<
-    text_woarchive_impl<text_woarchive> 
-> polymorphic_text_woarchive;
-
-} // namespace archive
-} // namespace boost
-
-// required by export
-BOOST_SERIALIZATION_REGISTER_ARCHIVE(
-    boost::archive::polymorphic_text_woarchive
-)
-
-#endif // BOOST_NO_STD_WSTREAMBUF 
-#endif // BOOST_ARCHIVE_POLYMORPHIC_TEXT_WOARCHIVE_HPP
-
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/polymorphic_xml_iarchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/polymorphic_xml_iarchive.hpp
deleted file mode 100644
index 4dc3f894b38..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/polymorphic_xml_iarchive.hpp
+++ /dev/null
@@ -1,54 +0,0 @@
-#ifndef BOOST_ARCHIVE_POLYMORPHIC_XML_IARCHIVE_HPP
-#define BOOST_ARCHIVE_POLYMORPHIC_XML_IARCHIVE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// polymorphic_xml_iarchive.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/config.hpp>
-#include <boost/archive/xml_iarchive.hpp>
-#include <boost/archive/detail/polymorphic_iarchive_route.hpp>
-
-#ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable : 4511 4512)
-#endif
-
-namespace boost { 
-namespace archive {
-
-class polymorphic_xml_iarchive : 
-    public detail::polymorphic_iarchive_route<xml_iarchive>
-{
-public:
-    polymorphic_xml_iarchive(std::istream & is, unsigned int flags = 0) :
-        detail::polymorphic_iarchive_route<xml_iarchive>(is, flags)
-    {}
-    ~polymorphic_xml_iarchive(){}
-};
-
-} // namespace archive
-} // namespace boost
-
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
-
-// required by export
-BOOST_SERIALIZATION_REGISTER_ARCHIVE(
-    boost::archive::polymorphic_xml_iarchive
-)
-
-#endif // BOOST_ARCHIVE_POLYMORPHIC_XML_IARCHIVE_HPP
-
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/polymorphic_xml_oarchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/polymorphic_xml_oarchive.hpp
deleted file mode 100644
index 514f9e530a8..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/polymorphic_xml_oarchive.hpp
+++ /dev/null
@@ -1,39 +0,0 @@
-#ifndef BOOST_ARCHIVE_POLYMORPHIC_XML_OARCHIVE_HPP
-#define BOOST_ARCHIVE_POLYMORPHIC_XML_OARCHIVE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// polymorphic_xml_oarchive.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/config.hpp>
-#include <boost/archive/xml_oarchive.hpp>
-#include <boost/archive/detail/polymorphic_oarchive_route.hpp>
-
-namespace boost { 
-namespace archive {
-
-typedef detail::polymorphic_oarchive_route<
-    xml_oarchive_impl<xml_oarchive> 
-> polymorphic_xml_oarchive;
-
-} // namespace archive
-} // namespace boost
-
-// required by export
-BOOST_SERIALIZATION_REGISTER_ARCHIVE(
-    boost::archive::polymorphic_xml_oarchive
-)
-
-#endif // BOOST_ARCHIVE_POLYMORPHIC_XML_OARCHIVE_HPP
-
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/polymorphic_xml_wiarchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/polymorphic_xml_wiarchive.hpp
deleted file mode 100644
index d4ab731267f..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/polymorphic_xml_wiarchive.hpp
+++ /dev/null
@@ -1,50 +0,0 @@
-#ifndef BOOST_ARCHIVE_POLYMORPHIC_XML_WIARCHIVE_HPP
-#define BOOST_ARCHIVE_POLYMORPHIC_XML_WIARCHIVE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// polymorphic_xml_wiarchive.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/config.hpp>
-#ifdef BOOST_NO_STD_WSTREAMBUF
-#error "wide char i/o not supported on this platform"
-#else
-
-#include <boost/archive/xml_wiarchive.hpp>
-#include <boost/archive/detail/polymorphic_iarchive_route.hpp>
-
-namespace boost { 
-namespace archive {
-
-class polymorphic_xml_wiarchive : 
-    public detail::polymorphic_iarchive_route<xml_wiarchive>
-{
-public:
-    polymorphic_xml_wiarchive(std::wistream & is, unsigned int flags = 0) :
-        detail::polymorphic_iarchive_route<xml_wiarchive>(is, flags)
-    {}
-    ~polymorphic_xml_wiarchive(){}
-};
-
-} // namespace archive
-} // namespace boost
-
-// required by export
-BOOST_SERIALIZATION_REGISTER_ARCHIVE(
-    boost::archive::polymorphic_xml_wiarchive
-)
-
-#endif // BOOST_NO_STD_WSTREAMBUF 
-#endif // BOOST_ARCHIVE_POLYMORPHIC_XML_WIARCHIVE_HPP
-
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/polymorphic_xml_woarchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/polymorphic_xml_woarchive.hpp
deleted file mode 100644
index dd8963fbb14..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/polymorphic_xml_woarchive.hpp
+++ /dev/null
@@ -1,44 +0,0 @@
-#ifndef BOOST_ARCHIVE_POLYMORPHIC_XML_WOARCHIVE_HPP
-#define BOOST_ARCHIVE_POLYMORPHIC_XML_WOARCHIVE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// polymorphic_xml_oarchive.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/config.hpp>
-#ifdef BOOST_NO_STD_WSTREAMBUF
-#error "wide char i/o not supported on this platform"
-#else
-
-#include <boost/archive/xml_woarchive.hpp>
-#include <boost/archive/detail/polymorphic_oarchive_route.hpp>
-
-namespace boost { 
-namespace archive {
-
-typedef detail::polymorphic_oarchive_route<
-        xml_woarchive_impl<xml_woarchive> 
-> polymorphic_xml_woarchive;
-
-} // namespace archive
-} // namespace boost
-
-// required by export
-BOOST_SERIALIZATION_REGISTER_ARCHIVE(
-    boost::archive::polymorphic_xml_woarchive
-)
-
-#endif // BOOST_NO_STD_WSTREAMBUF
-#endif // BOOST_ARCHIVE_POLYMORPHIC_XML_WOARCHIVE_HPP
-
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/text_iarchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/text_iarchive.hpp
deleted file mode 100644
index d9d60adf0b8..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/text_iarchive.hpp
+++ /dev/null
@@ -1,132 +0,0 @@
-#ifndef BOOST_ARCHIVE_TEXT_IARCHIVE_HPP
-#define BOOST_ARCHIVE_TEXT_IARCHIVE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// text_iarchive.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <istream>
-
-#include <boost/config.hpp>
-#include <boost/archive/detail/auto_link_archive.hpp>
-#include <boost/archive/basic_text_iprimitive.hpp>
-#include <boost/archive/basic_text_iarchive.hpp>
-#include <boost/archive/detail/register_archive.hpp>
-#include <boost/serialization/item_version_type.hpp>
-
-#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
-
-#ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable : 4511 4512)
-#endif
-
-namespace boost { 
-namespace archive {
-
-namespace detail {
-    template<class Archive> class interface_iarchive;
-} // namespace detail
-
-template<class Archive>
-class BOOST_SYMBOL_VISIBLE text_iarchive_impl :
-    public basic_text_iprimitive<std::istream>,
-    public basic_text_iarchive<Archive>
-{
-#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
-public:
-#else
-protected:
-    friend class detail::interface_iarchive<Archive>;
-    friend class load_access;
-#endif
-    template<class T>
-    void load(T & t){
-        basic_text_iprimitive<std::istream>::load(t);
-    }
-    void load(version_type & t){
-        unsigned int v;
-        load(v);
-        t = version_type(v);
-    }
-    void load(boost::serialization::item_version_type & t){
-        unsigned int v;
-        load(v);
-        t = boost::serialization::item_version_type(v);
-    }
-    BOOST_ARCHIVE_DECL void 
-    load(char * t);
-    #ifndef BOOST_NO_INTRINSIC_WCHAR_T
-    BOOST_ARCHIVE_DECL void 
-    load(wchar_t * t);
-    #endif
-    BOOST_ARCHIVE_DECL void 
-    load(std::string &s);
-    #ifndef BOOST_NO_STD_WSTRING
-    BOOST_ARCHIVE_DECL void 
-    load(std::wstring &ws);
-    #endif
-    template<class T>
-    void load_override(T & t){
-        basic_text_iarchive<Archive>::load_override(t);
-    }
-    BOOST_ARCHIVE_DECL void
-    load_override(class_name_type & t);
-    BOOST_ARCHIVE_DECL void
-    init();
-    BOOST_ARCHIVE_DECL 
-    text_iarchive_impl(std::istream & is, unsigned int flags);
-    // don't import inline definitions! leave this as a reminder.
-    //BOOST_ARCHIVE_DECL 
-    ~text_iarchive_impl(){};
-};
-
-} // namespace archive
-} // namespace boost
-
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
-
-#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
-
-#ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable : 4511 4512)
-#endif
-
-namespace boost { 
-namespace archive {
-
-class BOOST_SYMBOL_VISIBLE text_iarchive : 
-    public text_iarchive_impl<text_iarchive>{
-public:
-    text_iarchive(std::istream & is_, unsigned int flags = 0) :
-        // note: added _ to suppress useless gcc warning
-        text_iarchive_impl<text_iarchive>(is_, flags)
-    {}
-    ~text_iarchive(){}
-};
-
-} // namespace archive
-} // namespace boost
-
-// required by export
-BOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::text_iarchive)
-
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
-
-#endif // BOOST_ARCHIVE_TEXT_IARCHIVE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/text_oarchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/text_oarchive.hpp
deleted file mode 100644
index 9ba0dafffb4..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/text_oarchive.hpp
+++ /dev/null
@@ -1,121 +0,0 @@
-#ifndef BOOST_ARCHIVE_TEXT_OARCHIVE_HPP
-#define BOOST_ARCHIVE_TEXT_OARCHIVE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// text_oarchive.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <ostream>
-#include <cstddef> // std::size_t
-
-#include <boost/config.hpp>
-#if defined(BOOST_NO_STDC_NAMESPACE)
-namespace std{ 
-    using ::size_t; 
-} // namespace std
-#endif
-
-#include <boost/archive/detail/auto_link_archive.hpp>
-#include <boost/archive/basic_text_oprimitive.hpp>
-#include <boost/archive/basic_text_oarchive.hpp>
-#include <boost/archive/detail/register_archive.hpp>
-#include <boost/serialization/item_version_type.hpp>
-
-#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
-
-#ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable : 4511 4512)
-#endif
-
-namespace boost { 
-namespace archive {
-
-namespace detail {
-    template<class Archive> class interface_oarchive;
-} // namespace detail
-
-template<class Archive>
-class BOOST_SYMBOL_VISIBLE text_oarchive_impl :
-     /* protected ? */ public basic_text_oprimitive<std::ostream>,
-     public basic_text_oarchive<Archive>
-{
-#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
-public:
-#else
-protected:
-    friend class detail::interface_oarchive<Archive>;
-    friend class basic_text_oarchive<Archive>;
-    friend class save_access;
-#endif
-    template<class T>
-    void save(const T & t){
-        this->newtoken();
-        basic_text_oprimitive<std::ostream>::save(t);
-    }
-    void save(const version_type & t){
-        save(static_cast<const unsigned int>(t));
-    }
-    void save(const boost::serialization::item_version_type & t){
-        save(static_cast<const unsigned int>(t));
-    }
-    BOOST_ARCHIVE_DECL void 
-    save(const char * t);
-    #ifndef BOOST_NO_INTRINSIC_WCHAR_T
-    BOOST_ARCHIVE_DECL void 
-    save(const wchar_t * t);
-    #endif
-    BOOST_ARCHIVE_DECL void 
-    save(const std::string &s);
-    #ifndef BOOST_NO_STD_WSTRING
-    BOOST_ARCHIVE_DECL void 
-    save(const std::wstring &ws);
-    #endif
-    BOOST_ARCHIVE_DECL 
-    text_oarchive_impl(std::ostream & os, unsigned int flags);
-    // don't import inline definitions! leave this as a reminder.
-    //BOOST_ARCHIVE_DECL 
-    ~text_oarchive_impl(){};
-public:
-    BOOST_ARCHIVE_DECL void 
-    save_binary(const void *address, std::size_t count);
-};
-
-// do not derive from this class.  If you want to extend this functionality
-// via inhertance, derived from text_oarchive_impl instead.  This will
-// preserve correct static polymorphism.
-class BOOST_SYMBOL_VISIBLE text_oarchive : 
-    public text_oarchive_impl<text_oarchive>
-{
-public:
-    text_oarchive(std::ostream & os_, unsigned int flags = 0) :
-        // note: added _ to suppress useless gcc warning
-        text_oarchive_impl<text_oarchive>(os_, flags)
-    {}
-    ~text_oarchive(){}
-};
-
-} // namespace archive
-} // namespace boost
-
-// required by export
-BOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::text_oarchive)
-
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
-
-#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
-
-#endif // BOOST_ARCHIVE_TEXT_OARCHIVE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/text_wiarchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/text_wiarchive.hpp
deleted file mode 100644
index 3adf068a51a..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/text_wiarchive.hpp
+++ /dev/null
@@ -1,137 +0,0 @@
-#ifndef BOOST_ARCHIVE_TEXT_WIARCHIVE_HPP
-#define BOOST_ARCHIVE_TEXT_WIARCHIVE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// text_wiarchive.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/config.hpp>
-#ifdef BOOST_NO_STD_WSTREAMBUF
-#error "wide char i/o not supported on this platform"
-#else
-
-#include <istream>
-
-#include <boost/archive/detail/auto_link_warchive.hpp>
-#include <boost/archive/basic_text_iprimitive.hpp>
-#include <boost/archive/basic_text_iarchive.hpp>
-#include <boost/archive/detail/register_archive.hpp>
-#include <boost/serialization/item_version_type.hpp>
-
-#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
-
-#ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable : 4511 4512)
-#endif
-
-namespace boost { 
-namespace archive {
-
-namespace detail {
-    template<class Archive> class interface_iarchive;
-} // namespace detail
-
-template<class Archive>
-class BOOST_SYMBOL_VISIBLE text_wiarchive_impl :
-    public basic_text_iprimitive<std::wistream>,
-    public basic_text_iarchive<Archive>
-{
-#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
-public:
-#else
-protected:
-    #if BOOST_WORKAROUND(BOOST_MSVC, < 1500)
-        // for some inexplicable reason insertion of "class" generates compile erro
-        // on msvc 7.1
-        friend detail::interface_iarchive<Archive>;
-        friend load_access;
-    #else
-        friend class detail::interface_iarchive<Archive>;
-        friend class load_access;
-    #endif
-#endif
-    template<class T>
-    void load(T & t){
-        basic_text_iprimitive<std::wistream>::load(t);
-    }
-    void load(version_type & t){
-        unsigned int v;
-        load(v);
-        t = version_type(v);
-    }
-    void load(boost::serialization::item_version_type & t){
-        unsigned int v;
-        load(v);
-        t = boost::serialization::item_version_type(v);
-    }
-    BOOST_WARCHIVE_DECL void
-    load(char * t);
-    #ifndef BOOST_NO_INTRINSIC_WCHAR_T
-    BOOST_WARCHIVE_DECL void
-    load(wchar_t * t);
-    #endif
-    BOOST_WARCHIVE_DECL void
-    load(std::string &s);
-    #ifndef BOOST_NO_STD_WSTRING
-    BOOST_WARCHIVE_DECL void
-    load(std::wstring &ws);
-    #endif
-    template<class T>
-    void load_override(T & t){
-        basic_text_iarchive<Archive>::load_override(t);
-    }
-    BOOST_WARCHIVE_DECL 
-    text_wiarchive_impl(std::wistream & is, unsigned int flags);
-    ~text_wiarchive_impl(){};
-};
-
-} // namespace archive
-} // namespace boost
-
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
-
-#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
-
-#ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable : 4511 4512)
-#endif
-
-namespace boost { 
-namespace archive {
-
-class BOOST_SYMBOL_VISIBLE text_wiarchive : 
-    public text_wiarchive_impl<text_wiarchive>{
-public:
-    text_wiarchive(std::wistream & is, unsigned int flags = 0) :
-        text_wiarchive_impl<text_wiarchive>(is, flags)
-    {}
-    ~text_wiarchive(){}
-};
-
-} // namespace archive
-} // namespace boost
-
-// required by export
-BOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::text_wiarchive)
-
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
-
-#endif // BOOST_NO_STD_WSTREAMBUF
-#endif // BOOST_ARCHIVE_TEXT_WIARCHIVE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/text_woarchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/text_woarchive.hpp
deleted file mode 100644
index b6b4f8ed59a..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/text_woarchive.hpp
+++ /dev/null
@@ -1,155 +0,0 @@
-#ifndef BOOST_ARCHIVE_TEXT_WOARCHIVE_HPP
-#define BOOST_ARCHIVE_TEXT_WOARCHIVE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// text_woarchive.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/config.hpp>
-
-#ifdef BOOST_NO_STD_WSTREAMBUF
-#error "wide char i/o not supported on this platform"
-#else
-
-#include <ostream>
-#include <cstddef> // size_t
-
-#if defined(BOOST_NO_STDC_NAMESPACE)
-namespace std{ 
-    using ::size_t; 
-} // namespace std
-#endif
-
-#include <boost/archive/detail/auto_link_warchive.hpp>
-#include <boost/archive/basic_text_oprimitive.hpp>
-#include <boost/archive/basic_text_oarchive.hpp>
-#include <boost/archive/detail/register_archive.hpp>
-#include <boost/serialization/item_version_type.hpp>
-
-#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
-
-#ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable : 4511 4512)
-#endif
-
-namespace boost { 
-namespace archive {
-
-namespace detail {
-    template<class Archive> class interface_oarchive;
-} // namespace detail
-
-template<class Archive>
-class BOOST_SYMBOL_VISIBLE text_woarchive_impl :
-    public basic_text_oprimitive<std::wostream>,
-    public basic_text_oarchive<Archive>
-{
-#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
-public:
-#else
-protected:
-    #if BOOST_WORKAROUND(BOOST_MSVC, < 1500)
-        // for some inexplicable reason insertion of "class" generates compile erro
-        // on msvc 7.1
-        friend detail::interface_oarchive<Archive>;
-        friend basic_text_oarchive<Archive>;
-        friend save_access;
-    #else
-        friend class detail::interface_oarchive<Archive>;
-        friend class basic_text_oarchive<Archive>;
-        friend class save_access;
-    #endif
-#endif
-    template<class T>
-    void save(const T & t){
-        this->newtoken();
-        basic_text_oprimitive<std::wostream>::save(t);
-    }
-    void save(const version_type & t){
-        save(static_cast<const unsigned int>(t));
-    }
-    void save(const boost::serialization::item_version_type & t){
-        save(static_cast<const unsigned int>(t));
-    }
-    BOOST_WARCHIVE_DECL void
-    save(const char * t);
-    #ifndef BOOST_NO_INTRINSIC_WCHAR_T
-    BOOST_WARCHIVE_DECL void
-    save(const wchar_t * t);
-    #endif
-    BOOST_WARCHIVE_DECL void
-    save(const std::string &s);
-    #ifndef BOOST_NO_STD_WSTRING
-    BOOST_WARCHIVE_DECL void
-    save(const std::wstring &ws);
-    #endif
-    text_woarchive_impl(std::wostream & os, unsigned int flags) :
-        basic_text_oprimitive<std::wostream>(
-            os, 
-            0 != (flags & no_codecvt)
-        ),
-        basic_text_oarchive<Archive>(flags)
-    {
-        if(0 == (flags & no_header))
-            basic_text_oarchive<Archive>::init();
-    }
-public:
-    void save_binary(const void *address, std::size_t count){
-        put(static_cast<wchar_t>('\n'));
-        this->end_preamble();
-        #if ! defined(__MWERKS__)
-        this->basic_text_oprimitive<std::wostream>::save_binary(
-        #else
-        this->basic_text_oprimitive::save_binary(
-        #endif
-            address, 
-            count
-        );
-        put(static_cast<wchar_t>('\n'));
-        this->delimiter = this->none;
-    }
-
-};
-
-// we use the following because we can't use
-// typedef text_oarchive_impl<text_oarchive_impl<...> > text_oarchive;
-
-// do not derive from this class.  If you want to extend this functionality
-// via inhertance, derived from text_oarchive_impl instead.  This will
-// preserve correct static polymorphism.
-class BOOST_SYMBOL_VISIBLE text_woarchive : 
-    public text_woarchive_impl<text_woarchive>
-{
-public:
-    text_woarchive(std::wostream & os, unsigned int flags = 0) :
-        text_woarchive_impl<text_woarchive>(os, flags)
-    {}
-    ~text_woarchive(){}
-};
-
-} // namespace archive
-} // namespace boost
-
-// required by export
-BOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::text_woarchive)
-
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
-
-#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
-
-#endif // BOOST_NO_STD_WSTREAMBUF
-#endif // BOOST_ARCHIVE_TEXT_WOARCHIVE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/tmpdir.hpp b/contrib/libboost/boost_1_65_0/boost/archive/tmpdir.hpp
deleted file mode 100644
index 400d23b9f68..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/tmpdir.hpp
+++ /dev/null
@@ -1,50 +0,0 @@
-#ifndef BOOST_ARCHIVE_TMPDIR_HPP
-#define BOOST_ARCHIVE_TMPDIR_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// tmpdir.hpp:
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <cstdlib> // getenv
-#include <cstddef> // NULL
-//#include <boost/assert.hpp>
-
-#include <boost/config.hpp>
-#ifdef BOOST_NO_STDC_NAMESPACE
-namespace std {
-    using ::getenv;
-}
-#endif
-
-namespace boost {
-namespace archive {
-
-inline const char * tmpdir(){
-    const char *dirname;
-    dirname = std::getenv("TMP");
-    if(NULL == dirname)
-        dirname = std::getenv("TMPDIR");
-    if(NULL == dirname)
-        dirname = std::getenv("TEMP");
-    if(NULL == dirname){
-        //BOOST_ASSERT(false); // no temp directory found
-        dirname = ".";
-    }
-    return dirname;
-}
-
-} // archive
-} // boost
-
-#endif // BOOST_ARCHIVE_TMPDIR_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/wcslen.hpp b/contrib/libboost/boost_1_65_0/boost/archive/wcslen.hpp
deleted file mode 100644
index 0b60004f095..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/wcslen.hpp
+++ /dev/null
@@ -1,58 +0,0 @@
-#ifndef BOOST_ARCHIVE_WCSLEN_HPP
-#define BOOST_ARCHIVE_WCSLEN_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// wcslen.hpp:
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <cstddef> // size_t
-#include <boost/config.hpp>
-#if defined(BOOST_NO_STDC_NAMESPACE)
-namespace std{ 
-    using ::size_t; 
-} // namespace std
-#endif
-
-#ifndef BOOST_NO_CWCHAR
-
-// a couple of libraries which include wchar_t don't include
-// wcslen
-
-#if defined(BOOST_DINKUMWARE_STDLIB) && BOOST_DINKUMWARE_STDLIB < 306 \
-|| defined(__LIBCOMO__) 
-
-namespace std {
-inline std::size_t wcslen(const wchar_t * ws)
-{
-    const wchar_t * eows = ws;
-    while(* eows != 0)
-        ++eows;
-    return eows - ws;
-}
-} // namespace std
-
-#else
-
-#ifndef BOOST_NO_CWCHAR
-#include <cwchar>
-#endif
-#ifdef BOOST_NO_STDC_NAMESPACE
-namespace std{ using ::wcslen; }
-#endif
-
-#endif // wcslen
-
-#endif //BOOST_NO_CWCHAR
-
-#endif //BOOST_ARCHIVE_WCSLEN_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/xml_archive_exception.hpp b/contrib/libboost/boost_1_65_0/boost/archive/xml_archive_exception.hpp
deleted file mode 100644
index 82c53ef5d3e..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/xml_archive_exception.hpp
+++ /dev/null
@@ -1,57 +0,0 @@
-#ifndef BOOST_ARCHIVE_XML_ARCHIVE_EXCEPTION_HPP
-#define BOOST_ARCHIVE_XML_ARCHIVE_EXCEPTION_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// xml_archive_exception.hpp:
-
-// (C) Copyright 2007 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <exception>
-#include <boost/assert.hpp>
-
-#include <boost/config.hpp> 
-#include <boost/archive/detail/decl.hpp>
-#include <boost/archive/archive_exception.hpp>
-
-#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
-
-namespace boost {
-namespace archive {
-
-//////////////////////////////////////////////////////////////////////
-// exceptions thrown by xml archives
-//
-class BOOST_SYMBOL_VISIBLE xml_archive_exception : 
-    public virtual boost::archive::archive_exception
-{
-public:
-    typedef enum {
-        xml_archive_parsing_error,    // see save_register
-        xml_archive_tag_mismatch,
-        xml_archive_tag_name_error
-    } exception_code;
-    BOOST_ARCHIVE_DECL xml_archive_exception(
-        exception_code c, 
-        const char * e1 = NULL,
-        const char * e2 = NULL
-    );
-    BOOST_ARCHIVE_DECL xml_archive_exception(xml_archive_exception const &) ;
-    virtual BOOST_ARCHIVE_DECL ~xml_archive_exception() BOOST_NOEXCEPT_OR_NOTHROW ;
-};
-
-}// namespace archive
-}// namespace boost
-
-#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
-
-#endif //BOOST_XML_ARCHIVE_ARCHIVE_EXCEPTION_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/xml_iarchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/xml_iarchive.hpp
deleted file mode 100644
index abd2f9fc4e3..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/xml_iarchive.hpp
+++ /dev/null
@@ -1,142 +0,0 @@
-#ifndef BOOST_ARCHIVE_XML_IARCHIVE_HPP
-#define BOOST_ARCHIVE_XML_IARCHIVE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// xml_iarchive.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <istream>
-
-#include <boost/scoped_ptr.hpp>
-#include <boost/archive/detail/auto_link_archive.hpp>
-#include <boost/archive/basic_text_iprimitive.hpp>
-#include <boost/archive/basic_xml_iarchive.hpp>
-#include <boost/archive/detail/register_archive.hpp>
-#include <boost/serialization/item_version_type.hpp>
-
-#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
-
-#ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable : 4511 4512)
-#endif
-
-namespace boost { 
-namespace archive {
-
-namespace detail {
-    template<class Archive> class interface_iarchive;
-} // namespace detail
-
-template<class CharType>
-class basic_xml_grammar;
-typedef basic_xml_grammar<char> xml_grammar;
-
-template<class Archive>
-class BOOST_SYMBOL_VISIBLE xml_iarchive_impl : 
-    public basic_text_iprimitive<std::istream>,
-    public basic_xml_iarchive<Archive>
-{
-#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
-public:
-#else
-protected:
-    friend class detail::interface_iarchive<Archive>;
-    friend class basic_xml_iarchive<Archive>;
-    friend class load_access;
-#endif
-    // use boost:scoped_ptr to implement automatic deletion;
-    boost::scoped_ptr<xml_grammar> gimpl;
-
-    std::istream & get_is(){
-        return is;
-    }
-    template<class T>
-    void load(T & t){
-        basic_text_iprimitive<std::istream>::load(t);
-    }
-    void 
-    load(version_type & t){
-        unsigned int v;
-        load(v);
-        t = version_type(v);
-    }
-    void 
-    load(boost::serialization::item_version_type & t){
-        unsigned int v;
-        load(v);
-        t = boost::serialization::item_version_type(v);
-    }
-    BOOST_ARCHIVE_DECL void
-    load(char * t);
-    #ifndef BOOST_NO_INTRINSIC_WCHAR_T
-    BOOST_ARCHIVE_DECL void
-    load(wchar_t * t);
-    #endif
-    BOOST_ARCHIVE_DECL void
-    load(std::string &s);
-    #ifndef BOOST_NO_STD_WSTRING
-    BOOST_ARCHIVE_DECL void
-    load(std::wstring &ws);
-    #endif
-    template<class T>
-    void load_override(T & t){
-        basic_xml_iarchive<Archive>::load_override(t);
-    }
-    BOOST_ARCHIVE_DECL void
-    load_override(class_name_type & t);
-    BOOST_ARCHIVE_DECL void
-    init();
-    BOOST_ARCHIVE_DECL 
-    xml_iarchive_impl(std::istream & is, unsigned int flags);
-    BOOST_ARCHIVE_DECL
-    ~xml_iarchive_impl();
-};
-
-} // namespace archive
-} // namespace boost
-
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
-
-#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
-#ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable : 4511 4512)
-#endif
-
-namespace boost { 
-namespace archive {
-
-class BOOST_SYMBOL_VISIBLE xml_iarchive : 
-    public xml_iarchive_impl<xml_iarchive>{
-public:
-    xml_iarchive(std::istream & is, unsigned int flags = 0) :
-        xml_iarchive_impl<xml_iarchive>(is, flags)
-    {}
-    ~xml_iarchive(){};
-};
-
-} // namespace archive
-} // namespace boost
-
-// required by export
-BOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::xml_iarchive)
-
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
-
-#endif // BOOST_ARCHIVE_XML_IARCHIVE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/xml_oarchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/xml_oarchive.hpp
deleted file mode 100644
index eea12680372..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/xml_oarchive.hpp
+++ /dev/null
@@ -1,137 +0,0 @@
-#ifndef BOOST_ARCHIVE_XML_OARCHIVE_HPP
-#define BOOST_ARCHIVE_XML_OARCHIVE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// xml_oarchive.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <ostream>
-
-#include <cstddef> // size_t
-#include <boost/config.hpp>
-#if defined(BOOST_NO_STDC_NAMESPACE)
-namespace std{ 
-    using ::size_t; 
-} // namespace std
-#endif
-
-#include <boost/archive/detail/auto_link_archive.hpp>
-#include <boost/archive/basic_text_oprimitive.hpp>
-#include <boost/archive/basic_xml_oarchive.hpp>
-#include <boost/archive/detail/register_archive.hpp>
-#include <boost/serialization/item_version_type.hpp>
-
-#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
-
-#ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable : 4511 4512)
-#endif
-
-namespace boost {
-namespace archive {
-
-namespace detail {
-    template<class Archive> class interface_oarchive;
-} // namespace detail
-
-template<class Archive>
-class BOOST_SYMBOL_VISIBLE xml_oarchive_impl : 
-    public basic_text_oprimitive<std::ostream>,
-    public basic_xml_oarchive<Archive>
-{
-#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
-public:
-#else
-protected:
-    friend class detail::interface_oarchive<Archive>;
-    friend class basic_xml_oarchive<Archive>;
-    friend class save_access;
-#endif
-    template<class T>
-    void save(const T & t){
-        basic_text_oprimitive<std::ostream>::save(t);
-    }
-    void 
-    save(const version_type & t){
-        save(static_cast<const unsigned int>(t));
-    }
-    void 
-    save(const boost::serialization::item_version_type & t){
-        save(static_cast<const unsigned int>(t));
-    }
-    BOOST_ARCHIVE_DECL void 
-    save(const char * t);
-    #ifndef BOOST_NO_INTRINSIC_WCHAR_T
-    BOOST_ARCHIVE_DECL void
-    save(const wchar_t * t);
-    #endif
-    BOOST_ARCHIVE_DECL void
-    save(const std::string &s);
-    #ifndef BOOST_NO_STD_WSTRING
-    BOOST_ARCHIVE_DECL void
-    save(const std::wstring &ws);
-    #endif
-    BOOST_ARCHIVE_DECL 
-    xml_oarchive_impl(std::ostream & os, unsigned int flags);
-    BOOST_ARCHIVE_DECL 
-    ~xml_oarchive_impl();
-public:
-    BOOST_ARCHIVE_DECL
-    void save_binary(const void *address, std::size_t count);
-};
-
-} // namespace archive
-} // namespace boost
-
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
-
-#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
-#ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable : 4511 4512)
-#endif
-
-namespace boost { 
-namespace archive {
-
-// we use the following because we can't use
-// typedef xml_oarchive_impl<xml_oarchive_impl<...> > xml_oarchive;
-
-// do not derive from this class.  If you want to extend this functionality
-// via inhertance, derived from xml_oarchive_impl instead.  This will
-// preserve correct static polymorphism.
-class BOOST_SYMBOL_VISIBLE xml_oarchive : 
-    public xml_oarchive_impl<xml_oarchive>
-{
-public:
-    xml_oarchive(std::ostream & os, unsigned int flags = 0) :
-        xml_oarchive_impl<xml_oarchive>(os, flags)
-    {}
-    ~xml_oarchive(){}
-};
-
-} // namespace archive
-} // namespace boost
-
-// required by export
-BOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::xml_oarchive)
-
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
-
-#endif // BOOST_ARCHIVE_XML_OARCHIVE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/xml_wiarchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/xml_wiarchive.hpp
deleted file mode 100644
index ac24289ac11..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/xml_wiarchive.hpp
+++ /dev/null
@@ -1,149 +0,0 @@
-#ifndef BOOST_ARCHIVE_XML_WIARCHIVE_HPP
-#define BOOST_ARCHIVE_XML_WIARCHIVE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// xml_wiarchive.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/config.hpp>
-#ifdef BOOST_NO_STD_WSTREAMBUF
-#error "wide char i/o not supported on this platform"
-#else
-
-#include <istream>
-
-#include <boost/smart_ptr/scoped_ptr.hpp>
-#include <boost/archive/detail/auto_link_warchive.hpp>
-#include <boost/archive/basic_text_iprimitive.hpp>
-#include <boost/archive/basic_xml_iarchive.hpp>
-#include <boost/archive/detail/register_archive.hpp>
-#include <boost/serialization/item_version_type.hpp>
-// #include <boost/archive/detail/utf8_codecvt_facet.hpp>
-
-#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
-
-#ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable : 4511 4512)
-#endif
-
-namespace boost {
-namespace archive {
-
-namespace detail {
-    template<class Archive> class interface_iarchive;
-} // namespace detail
-
-template<class CharType>
-class basic_xml_grammar;
-typedef basic_xml_grammar<wchar_t> xml_wgrammar;
-
-template<class Archive>
-class BOOST_SYMBOL_VISIBLE xml_wiarchive_impl : 
-    public basic_text_iprimitive<std::wistream>,
-    public basic_xml_iarchive<Archive>
-{
-#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
-public:
-#else
-protected:
-    friend class detail::interface_iarchive<Archive>;
-    friend class basic_xml_iarchive<Archive>;
-    friend class load_access;
-#endif
-    boost::scoped_ptr<xml_wgrammar> gimpl;
-    std::wistream & get_is(){
-        return is;
-    }
-    template<class T>
-    void 
-    load(T & t){
-        basic_text_iprimitive<std::wistream>::load(t);
-    }
-    void 
-    load(version_type & t){
-        unsigned int v;
-        load(v);
-        t = version_type(v);
-    }
-    void 
-    load(boost::serialization::item_version_type & t){
-        unsigned int v;
-        load(v);
-        t = boost::serialization::item_version_type(v);
-    }
-    BOOST_WARCHIVE_DECL void
-    load(char * t);
-    #ifndef BOOST_NO_INTRINSIC_WCHAR_T
-    BOOST_WARCHIVE_DECL void
-    load(wchar_t * t);
-    #endif
-    BOOST_WARCHIVE_DECL void
-    load(std::string &s);
-    #ifndef BOOST_NO_STD_WSTRING
-    BOOST_WARCHIVE_DECL void
-    load(std::wstring &ws);
-    #endif
-    template<class T>
-    void load_override(T & t){
-        basic_xml_iarchive<Archive>::load_override(t);
-    }
-    BOOST_WARCHIVE_DECL void
-    load_override(class_name_type & t);
-    BOOST_WARCHIVE_DECL void 
-    init();
-    BOOST_WARCHIVE_DECL 
-    xml_wiarchive_impl(std::wistream & is, unsigned int flags) ;
-    BOOST_WARCHIVE_DECL 
-    ~xml_wiarchive_impl();
-};
-
-} // namespace archive
-} // namespace boost
-
-#ifdef BOOST_MSVC
-#  pragma warning(pop) 
-#endif
-
-#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
-
-#ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable : 4511 4512)
-#endif
-
-namespace boost { 
-namespace archive {
-
-class BOOST_SYMBOL_VISIBLE xml_wiarchive :
-    public xml_wiarchive_impl<xml_wiarchive>{
-public:
-    xml_wiarchive(std::wistream & is, unsigned int flags = 0) :
-        xml_wiarchive_impl<xml_wiarchive>(is, flags)
-    {}
-    ~xml_wiarchive(){}
-};
-
-} // namespace archive
-} // namespace boost
-
-// required by export
-BOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::xml_wiarchive)
-
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
-
-#endif // BOOST_NO_STD_WSTREAMBUF
-#endif // BOOST_ARCHIVE_XML_WIARCHIVE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/archive/xml_woarchive.hpp b/contrib/libboost/boost_1_65_0/boost/archive/xml_woarchive.hpp
deleted file mode 100644
index cb7ce68cb6f..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/archive/xml_woarchive.hpp
+++ /dev/null
@@ -1,134 +0,0 @@
-#ifndef BOOST_ARCHIVE_XML_WOARCHIVE_HPP
-#define BOOST_ARCHIVE_XML_WOARCHIVE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// xml_woarchive.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/config.hpp>
-#ifdef BOOST_NO_STD_WSTREAMBUF
-#error "wide char i/o not supported on this platform"
-#else
-#include <cstddef> // size_t
-#if defined(BOOST_NO_STDC_NAMESPACE)
-namespace std{ 
-    using ::size_t; 
-} // namespace std
-#endif
-
-#include <ostream>
-
-//#include <boost/smart_ptr/scoped_ptr.hpp>
-#include <boost/archive/detail/auto_link_warchive.hpp>
-#include <boost/archive/basic_text_oprimitive.hpp>
-#include <boost/archive/basic_xml_oarchive.hpp>
-#include <boost/archive/detail/register_archive.hpp>
-#include <boost/serialization/item_version_type.hpp>
-//#include <boost/archive/detail/utf8_codecvt_facet.hpp>
-
-#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
-
-#ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable : 4511 4512)
-#endif
-
-namespace boost {
-namespace archive {
-
-namespace detail {
-    template<class Archive> class interface_oarchive;
-} // namespace detail
-
-template<class Archive>
-class BOOST_SYMBOL_VISIBLE xml_woarchive_impl :
-    public basic_text_oprimitive<std::wostream>,
-    public basic_xml_oarchive<Archive>
-{
-#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
-public:
-#else
-protected:
-    friend class detail::interface_oarchive<Archive>;
-    friend class basic_xml_oarchive<Archive>;
-    friend class save_access;
-#endif
-    //void end_preamble(){
-    //    basic_xml_oarchive<Archive>::end_preamble();
-    //}
-    template<class T>
-    void
-    save(const T & t){
-        basic_text_oprimitive<std::wostream>::save(t);
-    }
-    void
-    save(const version_type & t){
-        save(static_cast<const unsigned int>(t));
-    }
-    void 
-    save(const boost::serialization::item_version_type & t){
-        save(static_cast<const unsigned int>(t));
-    }
-    BOOST_WARCHIVE_DECL void
-    save(const char * t);
-    #ifndef BOOST_NO_INTRINSIC_WCHAR_T
-    BOOST_WARCHIVE_DECL void 
-    save(const wchar_t * t);
-    #endif
-    BOOST_WARCHIVE_DECL void 
-    save(const std::string &s);
-    #ifndef BOOST_NO_STD_WSTRING
-    BOOST_WARCHIVE_DECL void
-    save(const std::wstring &ws);
-    #endif
-    BOOST_WARCHIVE_DECL 
-    xml_woarchive_impl(std::wostream & os, unsigned int flags);
-    BOOST_WARCHIVE_DECL
-    ~xml_woarchive_impl();
-public:
-    BOOST_WARCHIVE_DECL void
-    save_binary(const void *address, std::size_t count);
-
-};
-
-// we use the following because we can't use
-// typedef xml_woarchive_impl<xml_woarchive_impl<...> > xml_woarchive;
-
-// do not derive from this class.  If you want to extend this functionality
-// via inhertance, derived from xml_woarchive_impl instead.  This will
-// preserve correct static polymorphism.
-class BOOST_SYMBOL_VISIBLE xml_woarchive :
-    public xml_woarchive_impl<xml_woarchive>
-{
-public:
-    xml_woarchive(std::wostream & os, unsigned int flags = 0) :
-        xml_woarchive_impl<xml_woarchive>(os, flags)
-    {}
-    ~xml_woarchive(){}
-};
-
-} // namespace archive
-} // namespace boost
-
-// required by export
-BOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::xml_woarchive)
-
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
-
-#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
-
-#endif // BOOST_NO_STD_WSTREAMBUF
-#endif // BOOST_ARCHIVE_XML_OARCHIVE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/foreach_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/foreach_fwd.hpp
deleted file mode 100644
index 4e0bb370c2f..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/foreach_fwd.hpp
+++ /dev/null
@@ -1,51 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-// foreach.hpp header file
-//
-// Copyright 2010 Eric Niebler.
-// Distributed under the Boost Software License, Version 1.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/foreach for documentation
-//
-// Credits:
-// Kazutoshi Satoda: for suggesting the need for a _fwd header for foreach's
-//                      customization points.
-
-#ifndef BOOST_FOREACH_FWD_HPP
-#define BOOST_FOREACH_FWD_HPP
-
-// This must be at global scope, hence the uglified name
-enum boost_foreach_argument_dependent_lookup_hack
-{
-    boost_foreach_argument_dependent_lookup_hack_value
-};
-
-namespace boost
-{
-
-namespace foreach
-{
-    ///////////////////////////////////////////////////////////////////////////////
-    // boost::foreach::tag
-    //
-    typedef boost_foreach_argument_dependent_lookup_hack tag;
-
-    ///////////////////////////////////////////////////////////////////////////////
-    // boost::foreach::is_lightweight_proxy
-    //   Specialize this for user-defined collection types if they are inexpensive to copy.
-    //   This tells BOOST_FOREACH it can avoid the rvalue/lvalue detection stuff.
-    template<typename T>
-    struct is_lightweight_proxy;
-
-    ///////////////////////////////////////////////////////////////////////////////
-    // boost::foreach::is_noncopyable
-    //   Specialize this for user-defined collection types if they cannot be copied.
-    //   This also tells BOOST_FOREACH to avoid the rvalue/lvalue detection stuff.
-    template<typename T>
-    struct is_noncopyable;
-
-} // namespace foreach
-
-} // namespace boost
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/composite_key.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/composite_key.hpp
deleted file mode 100644
index 787cdf83195..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/composite_key.hpp
+++ /dev/null
@@ -1,1513 +0,0 @@
-/* Copyright 2003-2015 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_COMPOSITE_KEY_HPP
-#define BOOST_MULTI_INDEX_COMPOSITE_KEY_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <boost/functional/hash_fwd.hpp>
-#include <boost/multi_index/detail/access_specifier.hpp>
-#include <boost/mpl/eval_if.hpp>
-#include <boost/mpl/identity.hpp>
-#include <boost/mpl/if.hpp>
-#include <boost/mpl/or.hpp>
-#include <boost/preprocessor/cat.hpp>
-#include <boost/preprocessor/control/expr_if.hpp>
-#include <boost/preprocessor/list/at.hpp>
-#include <boost/preprocessor/repetition/enum.hpp>
-#include <boost/preprocessor/repetition/enum_params.hpp> 
-#include <boost/static_assert.hpp>
-#include <boost/tuple/tuple.hpp>
-#include <boost/type_traits/is_same.hpp>
-#include <boost/utility/enable_if.hpp>
-#include <functional>
-
-#if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
-#include <boost/ref.hpp>
-#endif
-
-#if !defined(BOOST_NO_SFINAE)
-#include <boost/type_traits/is_convertible.hpp>
-#endif
-
-#if !defined(BOOST_NO_CXX11_HDR_TUPLE)&&\
-    !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-#include <boost/multi_index/detail/cons_stdtuple.hpp>
-#endif
-
-/* A composite key stores n key extractors and "computes" the
- * result on a given value as a packed reference to the value and
- * the composite key itself. Actual invocations to the component
- * key extractors are lazily performed when executing an operation
- * on composite_key results (equality, comparison, hashing.)
- * As the other key extractors in Boost.MultiIndex, composite_key<T,...>
- * is  overloaded to work on chained pointers to T and reference_wrappers
- * of T.
- */
-
-/* This user_definable macro limits the number of elements of a composite
- * key; useful for shortening resulting symbol names (MSVC++ 6.0, for
- * instance has problems coping with very long symbol names.)
- * NB: This cannot exceed the maximum number of arguments of
- * boost::tuple. In Boost 1.32, the limit is 10.
- */
-
-#if !defined(BOOST_MULTI_INDEX_LIMIT_COMPOSITE_KEY_SIZE)
-#define BOOST_MULTI_INDEX_LIMIT_COMPOSITE_KEY_SIZE 10
-#endif
-
-/* maximum number of key extractors in a composite key */
-
-#if BOOST_MULTI_INDEX_LIMIT_COMPOSITE_KEY_SIZE<10 /* max length of a tuple */
-#define BOOST_MULTI_INDEX_COMPOSITE_KEY_SIZE \
-  BOOST_MULTI_INDEX_LIMIT_COMPOSITE_KEY_SIZE
-#else
-#define BOOST_MULTI_INDEX_COMPOSITE_KEY_SIZE 10
-#endif
-
-/* BOOST_PP_ENUM of BOOST_MULTI_INDEX_COMPOSITE_KEY_SIZE elements */
-
-#define BOOST_MULTI_INDEX_CK_ENUM(macro,data)                                \
-  BOOST_PP_ENUM(BOOST_MULTI_INDEX_COMPOSITE_KEY_SIZE,macro,data)
-
-/* BOOST_PP_ENUM_PARAMS of BOOST_MULTI_INDEX_COMPOSITE_KEY_SIZE elements */
-
-#define BOOST_MULTI_INDEX_CK_ENUM_PARAMS(param)                              \
-  BOOST_PP_ENUM_PARAMS(BOOST_MULTI_INDEX_COMPOSITE_KEY_SIZE,param)
-
-/* if n==0 ->   text0
- * otherwise -> textn=tuples::null_type
- */
-
-#define BOOST_MULTI_INDEX_CK_TEMPLATE_PARM(z,n,text)                         \
-  typename BOOST_PP_CAT(text,n) BOOST_PP_EXPR_IF(n,=tuples::null_type)
-
-/* const textn& kn=textn() */
-
-#define BOOST_MULTI_INDEX_CK_CTOR_ARG(z,n,text)                              \
-  const BOOST_PP_CAT(text,n)& BOOST_PP_CAT(k,n) = BOOST_PP_CAT(text,n)()
-
-/* typename list(0)<list(1),n>::type */
-
-#define BOOST_MULTI_INDEX_CK_APPLY_METAFUNCTION_N(z,n,list)                  \
-  BOOST_DEDUCED_TYPENAME BOOST_PP_LIST_AT(list,0)<                           \
-    BOOST_PP_LIST_AT(list,1),n                                               \
-  >::type
-
-namespace boost{
-
-template<class T> class reference_wrapper; /* fwd decl. */
-
-namespace multi_index{
-
-namespace detail{
-
-/* n-th key extractor of a composite key */
-
-template<typename CompositeKey,int N>
-struct nth_key_from_value
-{
-  typedef typename CompositeKey::key_extractor_tuple key_extractor_tuple;
-  typedef typename mpl::eval_if_c<
-    N<tuples::length<key_extractor_tuple>::value,
-    tuples::element<N,key_extractor_tuple>,
-    mpl::identity<tuples::null_type>
-  >::type                                            type;
-};
-
-/* nth_composite_key_##name<CompositeKey,N>::type yields
- * functor<nth_key_from_value<CompositeKey,N> >, or tuples::null_type
- * if N exceeds the length of the composite key.
- */
-
-#define BOOST_MULTI_INDEX_CK_NTH_COMPOSITE_KEY_FUNCTOR(name,functor)         \
-template<typename KeyFromValue>                                              \
-struct BOOST_PP_CAT(key_,name)                                               \
-{                                                                            \
-  typedef functor<typename KeyFromValue::result_type> type;                  \
-};                                                                           \
-                                                                             \
-template<>                                                                   \
-struct BOOST_PP_CAT(key_,name)<tuples::null_type>                            \
-{                                                                            \
-  typedef tuples::null_type type;                                            \
-};                                                                           \
-                                                                             \
-template<typename CompositeKey,int  N>                                       \
-struct BOOST_PP_CAT(nth_composite_key_,name)                                 \
-{                                                                            \
-  typedef typename nth_key_from_value<CompositeKey,N>::type key_from_value;  \
-  typedef typename BOOST_PP_CAT(key_,name)<key_from_value>::type type;       \
-};
-
-/* nth_composite_key_equal_to
- * nth_composite_key_less
- * nth_composite_key_greater
- * nth_composite_key_hash
- */
-
-BOOST_MULTI_INDEX_CK_NTH_COMPOSITE_KEY_FUNCTOR(equal_to,std::equal_to)
-BOOST_MULTI_INDEX_CK_NTH_COMPOSITE_KEY_FUNCTOR(less,std::less)
-BOOST_MULTI_INDEX_CK_NTH_COMPOSITE_KEY_FUNCTOR(greater,std::greater)
-BOOST_MULTI_INDEX_CK_NTH_COMPOSITE_KEY_FUNCTOR(hash,boost::hash)
-
-/* used for defining equality and comparison ops of composite_key_result */
-
-#define BOOST_MULTI_INDEX_CK_IDENTITY_ENUM_MACRO(z,n,text) text
-
-struct generic_operator_equal
-{
-  template<typename T,typename Q>
-  bool operator()(const T& x,const Q& y)const{return x==y;}
-};
-
-typedef tuple<
-  BOOST_MULTI_INDEX_CK_ENUM(
-    BOOST_MULTI_INDEX_CK_IDENTITY_ENUM_MACRO,
-    detail::generic_operator_equal)>          generic_operator_equal_tuple;
-
-struct generic_operator_less
-{
-  template<typename T,typename Q>
-  bool operator()(const T& x,const Q& y)const{return x<y;}
-};
-
-typedef tuple<
-  BOOST_MULTI_INDEX_CK_ENUM(
-    BOOST_MULTI_INDEX_CK_IDENTITY_ENUM_MACRO,
-    detail::generic_operator_less)>           generic_operator_less_tuple;
-
-/* Metaprogramming machinery for implementing equality, comparison and
- * hashing operations of composite_key_result.
- *
- * equal_* checks for equality between composite_key_results and
- * between those and tuples, accepting a tuple of basic equality functors.
- * compare_* does lexicographical comparison.
- * hash_* computes a combination of elementwise hash values.
- */
-
-template
-<
-  typename KeyCons1,typename Value1,
-  typename KeyCons2, typename Value2,
-  typename EqualCons
->
-struct equal_ckey_ckey; /* fwd decl. */
-
-template
-<
-  typename KeyCons1,typename Value1,
-  typename KeyCons2, typename Value2,
-  typename EqualCons
->
-struct equal_ckey_ckey_terminal
-{
-  static bool compare(
-    const KeyCons1&,const Value1&,
-    const KeyCons2&,const Value2&,
-    const EqualCons&)
-  {
-    return true;
-  }
-};
-
-template
-<
-  typename KeyCons1,typename Value1,
-  typename KeyCons2, typename Value2,
-  typename EqualCons
->
-struct equal_ckey_ckey_normal
-{
-  static bool compare(
-    const KeyCons1& c0,const Value1& v0,
-    const KeyCons2& c1,const Value2& v1,
-    const EqualCons& eq)
-  {
-    if(!eq.get_head()(c0.get_head()(v0),c1.get_head()(v1)))return false;
-    return equal_ckey_ckey<
-      BOOST_DEDUCED_TYPENAME KeyCons1::tail_type,Value1,
-      BOOST_DEDUCED_TYPENAME KeyCons2::tail_type,Value2,
-      BOOST_DEDUCED_TYPENAME EqualCons::tail_type
-    >::compare(c0.get_tail(),v0,c1.get_tail(),v1,eq.get_tail());
-  }
-};
-
-template
-<
-  typename KeyCons1,typename Value1,
-  typename KeyCons2, typename Value2,
-  typename EqualCons
->
-struct equal_ckey_ckey:
-  mpl::if_<
-    mpl::or_<
-      is_same<KeyCons1,tuples::null_type>,
-      is_same<KeyCons2,tuples::null_type>
-    >,
-    equal_ckey_ckey_terminal<KeyCons1,Value1,KeyCons2,Value2,EqualCons>,
-    equal_ckey_ckey_normal<KeyCons1,Value1,KeyCons2,Value2,EqualCons>
-  >::type
-{
-};
-
-template
-<
-  typename KeyCons,typename Value,
-  typename ValCons,typename EqualCons
->
-struct equal_ckey_cval; /* fwd decl. */
-
-template
-<
-  typename KeyCons,typename Value,
-  typename ValCons,typename EqualCons
->
-struct equal_ckey_cval_terminal
-{
-  static bool compare(
-    const KeyCons&,const Value&,const ValCons&,const EqualCons&)
-  {
-    return true;
-  }
-
-  static bool compare(
-    const ValCons&,const KeyCons&,const Value&,const EqualCons&)
-  {
-    return true;
-  }
-};
-
-template
-<
-  typename KeyCons,typename Value,
-  typename ValCons,typename EqualCons
->
-struct equal_ckey_cval_normal
-{
-  static bool compare(
-    const KeyCons& c,const Value& v,const ValCons& vc,
-    const EqualCons& eq)
-  {
-    if(!eq.get_head()(c.get_head()(v),vc.get_head()))return false;
-    return equal_ckey_cval<
-      BOOST_DEDUCED_TYPENAME KeyCons::tail_type,Value,
-      BOOST_DEDUCED_TYPENAME ValCons::tail_type,
-      BOOST_DEDUCED_TYPENAME EqualCons::tail_type
-    >::compare(c.get_tail(),v,vc.get_tail(),eq.get_tail());
-  }
-
-  static bool compare(
-    const ValCons& vc,const KeyCons& c,const Value& v,
-    const EqualCons& eq)
-  {
-    if(!eq.get_head()(vc.get_head(),c.get_head()(v)))return false;
-    return equal_ckey_cval<
-      BOOST_DEDUCED_TYPENAME KeyCons::tail_type,Value,
-      BOOST_DEDUCED_TYPENAME ValCons::tail_type,
-      BOOST_DEDUCED_TYPENAME EqualCons::tail_type
-    >::compare(vc.get_tail(),c.get_tail(),v,eq.get_tail());
-  }
-};
-
-template
-<
-  typename KeyCons,typename Value,
-  typename ValCons,typename EqualCons
->
-struct equal_ckey_cval:
-  mpl::if_<
-    mpl::or_<
-      is_same<KeyCons,tuples::null_type>,
-      is_same<ValCons,tuples::null_type>
-    >,
-    equal_ckey_cval_terminal<KeyCons,Value,ValCons,EqualCons>,
-    equal_ckey_cval_normal<KeyCons,Value,ValCons,EqualCons>
-  >::type
-{
-};
-
-template
-<
-  typename KeyCons1,typename Value1,
-  typename KeyCons2, typename Value2,
-  typename CompareCons
->
-struct compare_ckey_ckey; /* fwd decl. */
-
-template
-<
-  typename KeyCons1,typename Value1,
-  typename KeyCons2, typename Value2,
-  typename CompareCons
->
-struct compare_ckey_ckey_terminal
-{
-  static bool compare(
-    const KeyCons1&,const Value1&,
-    const KeyCons2&,const Value2&,
-    const CompareCons&)
-  {
-    return false;
-  }
-};
-
-template
-<
-  typename KeyCons1,typename Value1,
-  typename KeyCons2, typename Value2,
-  typename CompareCons
->
-struct compare_ckey_ckey_normal
-{
-  static bool compare(
-    const KeyCons1& c0,const Value1& v0,
-    const KeyCons2& c1,const Value2& v1,
-    const CompareCons& comp)
-  {
-    if(comp.get_head()(c0.get_head()(v0),c1.get_head()(v1)))return true;
-    if(comp.get_head()(c1.get_head()(v1),c0.get_head()(v0)))return false;
-    return compare_ckey_ckey<
-      BOOST_DEDUCED_TYPENAME KeyCons1::tail_type,Value1,
-      BOOST_DEDUCED_TYPENAME KeyCons2::tail_type,Value2,
-      BOOST_DEDUCED_TYPENAME CompareCons::tail_type
-    >::compare(c0.get_tail(),v0,c1.get_tail(),v1,comp.get_tail());
-  }
-};
-
-template
-<
-  typename KeyCons1,typename Value1,
-  typename KeyCons2, typename Value2,
-  typename CompareCons
->
-struct compare_ckey_ckey:
-  mpl::if_<
-    mpl::or_<
-      is_same<KeyCons1,tuples::null_type>,
-      is_same<KeyCons2,tuples::null_type>
-    >,
-    compare_ckey_ckey_terminal<KeyCons1,Value1,KeyCons2,Value2,CompareCons>,
-    compare_ckey_ckey_normal<KeyCons1,Value1,KeyCons2,Value2,CompareCons>
-  >::type
-{
-};
-
-template
-<
-  typename KeyCons,typename Value,
-  typename ValCons,typename CompareCons
->
-struct compare_ckey_cval; /* fwd decl. */
-
-template
-<
-  typename KeyCons,typename Value,
-  typename ValCons,typename CompareCons
->
-struct compare_ckey_cval_terminal
-{
-  static bool compare(
-    const KeyCons&,const Value&,const ValCons&,const CompareCons&)
-  {
-    return false;
-  }
-
-  static bool compare(
-    const ValCons&,const KeyCons&,const Value&,const CompareCons&)
-  {
-    return false;
-  }
-};
-
-template
-<
-  typename KeyCons,typename Value,
-  typename ValCons,typename CompareCons
->
-struct compare_ckey_cval_normal
-{
-  static bool compare(
-    const KeyCons& c,const Value& v,const ValCons& vc,
-    const CompareCons& comp)
-  {
-    if(comp.get_head()(c.get_head()(v),vc.get_head()))return true;
-    if(comp.get_head()(vc.get_head(),c.get_head()(v)))return false;
-    return compare_ckey_cval<
-      BOOST_DEDUCED_TYPENAME KeyCons::tail_type,Value,
-      BOOST_DEDUCED_TYPENAME ValCons::tail_type,
-      BOOST_DEDUCED_TYPENAME CompareCons::tail_type
-    >::compare(c.get_tail(),v,vc.get_tail(),comp.get_tail());
-  }
-
-  static bool compare(
-    const ValCons& vc,const KeyCons& c,const Value& v,
-    const CompareCons& comp)
-  {
-    if(comp.get_head()(vc.get_head(),c.get_head()(v)))return true;
-    if(comp.get_head()(c.get_head()(v),vc.get_head()))return false;
-    return compare_ckey_cval<
-      BOOST_DEDUCED_TYPENAME KeyCons::tail_type,Value,
-      BOOST_DEDUCED_TYPENAME ValCons::tail_type,
-      BOOST_DEDUCED_TYPENAME CompareCons::tail_type
-    >::compare(vc.get_tail(),c.get_tail(),v,comp.get_tail());
-  }
-};
-
-template
-<
-  typename KeyCons,typename Value,
-  typename ValCons,typename CompareCons
->
-struct compare_ckey_cval:
-  mpl::if_<
-    mpl::or_<
-      is_same<KeyCons,tuples::null_type>,
-      is_same<ValCons,tuples::null_type>
-    >,
-    compare_ckey_cval_terminal<KeyCons,Value,ValCons,CompareCons>,
-    compare_ckey_cval_normal<KeyCons,Value,ValCons,CompareCons>
-  >::type
-{
-};
-
-template<typename KeyCons,typename Value,typename HashCons>
-struct hash_ckey; /* fwd decl. */
-
-template<typename KeyCons,typename Value,typename HashCons>
-struct hash_ckey_terminal
-{
-  static std::size_t hash(
-    const KeyCons&,const Value&,const HashCons&,std::size_t carry)
-  {
-    return carry;
-  }
-};
-
-template<typename KeyCons,typename Value,typename HashCons>
-struct hash_ckey_normal
-{
-  static std::size_t hash(
-    const KeyCons& c,const Value& v,const HashCons& h,std::size_t carry=0)
-  {
-    /* same hashing formula as boost::hash_combine */
-
-    carry^=h.get_head()(c.get_head()(v))+0x9e3779b9+(carry<<6)+(carry>>2);
-    return hash_ckey<
-      BOOST_DEDUCED_TYPENAME KeyCons::tail_type,Value,
-      BOOST_DEDUCED_TYPENAME HashCons::tail_type
-    >::hash(c.get_tail(),v,h.get_tail(),carry);
-  }
-};
-
-template<typename KeyCons,typename Value,typename HashCons>
-struct hash_ckey:
-  mpl::if_<
-    is_same<KeyCons,tuples::null_type>,
-    hash_ckey_terminal<KeyCons,Value,HashCons>,
-    hash_ckey_normal<KeyCons,Value,HashCons>
-  >::type
-{
-};
-
-template<typename ValCons,typename HashCons>
-struct hash_cval; /* fwd decl. */
-
-template<typename ValCons,typename HashCons>
-struct hash_cval_terminal
-{
-  static std::size_t hash(const ValCons&,const HashCons&,std::size_t carry)
-  {
-    return carry;
-  }
-};
-
-template<typename ValCons,typename HashCons>
-struct hash_cval_normal
-{
-  static std::size_t hash(
-    const ValCons& vc,const HashCons& h,std::size_t carry=0)
-  {
-    carry^=h.get_head()(vc.get_head())+0x9e3779b9+(carry<<6)+(carry>>2);
-    return hash_cval<
-      BOOST_DEDUCED_TYPENAME ValCons::tail_type,
-      BOOST_DEDUCED_TYPENAME HashCons::tail_type
-    >::hash(vc.get_tail(),h.get_tail(),carry);
-  }
-};
-
-template<typename ValCons,typename HashCons>
-struct hash_cval:
-  mpl::if_<
-    is_same<ValCons,tuples::null_type>,
-    hash_cval_terminal<ValCons,HashCons>,
-    hash_cval_normal<ValCons,HashCons>
-  >::type
-{
-};
-
-} /* namespace multi_index::detail */
-
-/* composite_key_result */
-
-#if defined(BOOST_MSVC)
-#pragma warning(push)
-#pragma warning(disable:4512)
-#endif
-
-template<typename CompositeKey>
-struct composite_key_result
-{
-  typedef CompositeKey                            composite_key_type;
-  typedef typename composite_key_type::value_type value_type;
-
-  composite_key_result(
-    const composite_key_type& composite_key_,const value_type& value_):
-    composite_key(composite_key_),value(value_)
-  {}
-
-  const composite_key_type& composite_key;
-  const value_type&         value;
-};
-
-#if defined(BOOST_MSVC)
-#pragma warning(pop)
-#endif
-
-/* composite_key */
-
-template<
-  typename Value,
-  BOOST_MULTI_INDEX_CK_ENUM(BOOST_MULTI_INDEX_CK_TEMPLATE_PARM,KeyFromValue)
->
-struct composite_key:
-  private tuple<BOOST_MULTI_INDEX_CK_ENUM_PARAMS(KeyFromValue)>
-{
-private:
-  typedef tuple<BOOST_MULTI_INDEX_CK_ENUM_PARAMS(KeyFromValue)> super;
-
-public:
-  typedef super                               key_extractor_tuple;
-  typedef Value                               value_type;
-  typedef composite_key_result<composite_key> result_type;
-
-  composite_key(
-    BOOST_MULTI_INDEX_CK_ENUM(BOOST_MULTI_INDEX_CK_CTOR_ARG,KeyFromValue)):
-    super(BOOST_MULTI_INDEX_CK_ENUM_PARAMS(k))
-  {}
-
-  composite_key(const key_extractor_tuple& x):super(x){}
-
-  const key_extractor_tuple& key_extractors()const{return *this;}
-  key_extractor_tuple&       key_extractors(){return *this;}
-
-  template<typename ChainedPtr>
-
-#if !defined(BOOST_NO_SFINAE)
-  typename disable_if<
-    is_convertible<const ChainedPtr&,const value_type&>,result_type>::type
-#else
-  result_type
-#endif
-
-  operator()(const ChainedPtr& x)const
-  {
-    return operator()(*x);
-  }
-
-  result_type operator()(const value_type& x)const
-  {
-    return result_type(*this,x);
-  }
-
-  result_type operator()(const reference_wrapper<const value_type>& x)const
-  {
-    return result_type(*this,x.get());
-  }
-
-  result_type operator()(const reference_wrapper<value_type>& x)const
-  {
-    return result_type(*this,x.get());
-  }
-};
-
-/* comparison operators */
-
-/* == */
-
-template<typename CompositeKey1,typename CompositeKey2>
-inline bool operator==(
-  const composite_key_result<CompositeKey1>& x,
-  const composite_key_result<CompositeKey2>& y)
-{
-  typedef typename CompositeKey1::key_extractor_tuple key_extractor_tuple1;
-  typedef typename CompositeKey1::value_type          value_type1;
-  typedef typename CompositeKey2::key_extractor_tuple key_extractor_tuple2;
-  typedef typename CompositeKey2::value_type          value_type2;
-
-  BOOST_STATIC_ASSERT(
-    tuples::length<key_extractor_tuple1>::value==
-    tuples::length<key_extractor_tuple2>::value);
-
-  return detail::equal_ckey_ckey<
-    key_extractor_tuple1,value_type1,
-    key_extractor_tuple2,value_type2,
-    detail::generic_operator_equal_tuple
-  >::compare(
-    x.composite_key.key_extractors(),x.value,
-    y.composite_key.key_extractors(),y.value,
-    detail::generic_operator_equal_tuple());
-}
-
-template<
-  typename CompositeKey,
-  BOOST_MULTI_INDEX_CK_ENUM_PARAMS(typename Value)
->
-inline bool operator==(
-  const composite_key_result<CompositeKey>& x,
-  const tuple<BOOST_MULTI_INDEX_CK_ENUM_PARAMS(Value)>& y)
-{
-  typedef typename CompositeKey::key_extractor_tuple     key_extractor_tuple;
-  typedef typename CompositeKey::value_type              value_type;
-  typedef tuple<BOOST_MULTI_INDEX_CK_ENUM_PARAMS(Value)> key_tuple;
-  
-  BOOST_STATIC_ASSERT(
-    tuples::length<key_extractor_tuple>::value==
-    tuples::length<key_tuple>::value);
-
-  return detail::equal_ckey_cval<
-    key_extractor_tuple,value_type,
-    key_tuple,detail::generic_operator_equal_tuple
-  >::compare(
-    x.composite_key.key_extractors(),x.value,
-    y,detail::generic_operator_equal_tuple());
-}
-
-template
-<
-  BOOST_MULTI_INDEX_CK_ENUM_PARAMS(typename Value),
-  typename CompositeKey
->
-inline bool operator==(
-  const tuple<BOOST_MULTI_INDEX_CK_ENUM_PARAMS(Value)>& x,
-  const composite_key_result<CompositeKey>& y)
-{
-  typedef typename CompositeKey::key_extractor_tuple     key_extractor_tuple;
-  typedef typename CompositeKey::value_type              value_type;
-  typedef tuple<BOOST_MULTI_INDEX_CK_ENUM_PARAMS(Value)> key_tuple;
-  
-  BOOST_STATIC_ASSERT(
-    tuples::length<key_extractor_tuple>::value==
-    tuples::length<key_tuple>::value);
-
-  return detail::equal_ckey_cval<
-    key_extractor_tuple,value_type,
-    key_tuple,detail::generic_operator_equal_tuple
-  >::compare(
-    x,y.composite_key.key_extractors(),
-    y.value,detail::generic_operator_equal_tuple());
-}
-
-#if !defined(BOOST_NO_CXX11_HDR_TUPLE)&&\
-    !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-template<typename CompositeKey,typename... Values>
-inline bool operator==(
-  const composite_key_result<CompositeKey>& x,
-  const std::tuple<Values...>& y)
-{
-  typedef typename CompositeKey::key_extractor_tuple key_extractor_tuple;
-  typedef typename CompositeKey::value_type          value_type;
-  typedef std::tuple<Values...>                      key_tuple;
-  typedef typename detail::cons_stdtuple_ctor<
-    key_tuple>::result_type                          cons_key_tuple;
-  
-  BOOST_STATIC_ASSERT(
-    static_cast<std::size_t>(tuples::length<key_extractor_tuple>::value)==
-    std::tuple_size<key_tuple>::value);
-
-  return detail::equal_ckey_cval<
-    key_extractor_tuple,value_type,
-    cons_key_tuple,detail::generic_operator_equal_tuple
-  >::compare(
-    x.composite_key.key_extractors(),x.value,
-    detail::make_cons_stdtuple(y),detail::generic_operator_equal_tuple());
-}
-
-template<typename CompositeKey,typename... Values>
-inline bool operator==(
-  const std::tuple<Values...>& x,
-  const composite_key_result<CompositeKey>& y)
-{
-  typedef typename CompositeKey::key_extractor_tuple key_extractor_tuple;
-  typedef typename CompositeKey::value_type          value_type;
-  typedef std::tuple<Values...>                      key_tuple;
-  typedef typename detail::cons_stdtuple_ctor<
-    key_tuple>::result_type                          cons_key_tuple;
-
-  BOOST_STATIC_ASSERT(
-    static_cast<std::size_t>(tuples::length<key_extractor_tuple>::value)==
-    std::tuple_size<key_tuple>::value);
-
-  return detail::equal_ckey_cval<
-    key_extractor_tuple,value_type,
-    cons_key_tuple,detail::generic_operator_equal_tuple
-  >::compare(
-    detail::make_cons_stdtuple(x),y.composite_key.key_extractors(),
-    y.value,detail::generic_operator_equal_tuple());
-}
-#endif
-
-/* < */
-
-template<typename CompositeKey1,typename CompositeKey2>
-inline bool operator<(
-  const composite_key_result<CompositeKey1>& x,
-  const composite_key_result<CompositeKey2>& y)
-{
-  typedef typename CompositeKey1::key_extractor_tuple key_extractor_tuple1;
-  typedef typename CompositeKey1::value_type          value_type1;
-  typedef typename CompositeKey2::key_extractor_tuple key_extractor_tuple2;
-  typedef typename CompositeKey2::value_type          value_type2;
-
-  return detail::compare_ckey_ckey<
-   key_extractor_tuple1,value_type1,
-   key_extractor_tuple2,value_type2,
-   detail::generic_operator_less_tuple
-  >::compare(
-    x.composite_key.key_extractors(),x.value,
-    y.composite_key.key_extractors(),y.value,
-    detail::generic_operator_less_tuple());
-}
-
-template
-<
-  typename CompositeKey,
-  BOOST_MULTI_INDEX_CK_ENUM_PARAMS(typename Value)
->
-inline bool operator<(
-  const composite_key_result<CompositeKey>& x,
-  const tuple<BOOST_MULTI_INDEX_CK_ENUM_PARAMS(Value)>& y)
-{
-  typedef typename CompositeKey::key_extractor_tuple     key_extractor_tuple;
-  typedef typename CompositeKey::value_type              value_type;
-  typedef tuple<BOOST_MULTI_INDEX_CK_ENUM_PARAMS(Value)> key_tuple;
-  
-  return detail::compare_ckey_cval<
-    key_extractor_tuple,value_type,
-    key_tuple,detail::generic_operator_less_tuple
-  >::compare(
-    x.composite_key.key_extractors(),x.value,
-    y,detail::generic_operator_less_tuple());
-}
-
-template
-<
-  BOOST_MULTI_INDEX_CK_ENUM_PARAMS(typename Value),
-  typename CompositeKey
->
-inline bool operator<(
-  const tuple<BOOST_MULTI_INDEX_CK_ENUM_PARAMS(Value)>& x,
-  const composite_key_result<CompositeKey>& y)
-{
-  typedef typename CompositeKey::key_extractor_tuple     key_extractor_tuple;
-  typedef typename CompositeKey::value_type              value_type;
-  typedef tuple<BOOST_MULTI_INDEX_CK_ENUM_PARAMS(Value)> key_tuple;
-  
-  return detail::compare_ckey_cval<
-    key_extractor_tuple,value_type,
-    key_tuple,detail::generic_operator_less_tuple
-  >::compare(
-    x,y.composite_key.key_extractors(),
-    y.value,detail::generic_operator_less_tuple());
-}
-
-#if !defined(BOOST_NO_CXX11_HDR_TUPLE)&&\
-    !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-template<typename CompositeKey,typename... Values>
-inline bool operator<(
-  const composite_key_result<CompositeKey>& x,
-  const std::tuple<Values...>& y)
-{
-  typedef typename CompositeKey::key_extractor_tuple key_extractor_tuple;
-  typedef typename CompositeKey::value_type          value_type;
-  typedef std::tuple<Values...>                      key_tuple;
-  typedef typename detail::cons_stdtuple_ctor<
-    key_tuple>::result_type                          cons_key_tuple;
-  
-  return detail::compare_ckey_cval<
-    key_extractor_tuple,value_type,
-    cons_key_tuple,detail::generic_operator_less_tuple
-  >::compare(
-    x.composite_key.key_extractors(),x.value,
-    detail::make_cons_stdtuple(y),detail::generic_operator_less_tuple());
-}
-
-template<typename CompositeKey,typename... Values>
-inline bool operator<(
-  const std::tuple<Values...>& x,
-  const composite_key_result<CompositeKey>& y)
-{
-  typedef typename CompositeKey::key_extractor_tuple key_extractor_tuple;
-  typedef typename CompositeKey::value_type          value_type;
-  typedef std::tuple<Values...>                      key_tuple;
-  typedef typename detail::cons_stdtuple_ctor<
-    key_tuple>::result_type                          cons_key_tuple;
-  
-  return detail::compare_ckey_cval<
-    key_extractor_tuple,value_type,
-    cons_key_tuple,detail::generic_operator_less_tuple
-  >::compare(
-    detail::make_cons_stdtuple(x),y.composite_key.key_extractors(),
-    y.value,detail::generic_operator_less_tuple());
-}
-#endif
-
-/* rest of comparison operators */
-
-#define BOOST_MULTI_INDEX_CK_COMPLETE_COMP_OPS(t1,t2,a1,a2)                  \
-template<t1,t2> inline bool operator!=(const a1& x,const a2& y)              \
-{                                                                            \
-  return !(x==y);                                                            \
-}                                                                            \
-                                                                             \
-template<t1,t2> inline bool operator>(const a1& x,const a2& y)               \
-{                                                                            \
-  return y<x;                                                                \
-}                                                                            \
-                                                                             \
-template<t1,t2> inline bool operator>=(const a1& x,const a2& y)              \
-{                                                                            \
-  return !(x<y);                                                             \
-}                                                                            \
-                                                                             \
-template<t1,t2> inline bool operator<=(const a1& x,const a2& y)              \
-{                                                                            \
-  return !(y<x);                                                             \
-}
-
-BOOST_MULTI_INDEX_CK_COMPLETE_COMP_OPS(
-  typename CompositeKey1,
-  typename CompositeKey2,
-  composite_key_result<CompositeKey1>,
-  composite_key_result<CompositeKey2>
-)
-
-BOOST_MULTI_INDEX_CK_COMPLETE_COMP_OPS(
-  typename CompositeKey,
-  BOOST_MULTI_INDEX_CK_ENUM_PARAMS(typename Value),
-  composite_key_result<CompositeKey>,
-  tuple<BOOST_MULTI_INDEX_CK_ENUM_PARAMS(Value)>
-)
-
-BOOST_MULTI_INDEX_CK_COMPLETE_COMP_OPS(
-  BOOST_MULTI_INDEX_CK_ENUM_PARAMS(typename Value),
-  typename CompositeKey,
-  tuple<BOOST_MULTI_INDEX_CK_ENUM_PARAMS(Value)>,
-  composite_key_result<CompositeKey>
-)
-
-#if !defined(BOOST_NO_CXX11_HDR_TUPLE)&&\
-    !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-BOOST_MULTI_INDEX_CK_COMPLETE_COMP_OPS(
-  typename CompositeKey,
-  typename... Values,
-  composite_key_result<CompositeKey>,
-  std::tuple<Values...>
-)
-
-BOOST_MULTI_INDEX_CK_COMPLETE_COMP_OPS(
-  typename CompositeKey,
-  typename... Values,
-  std::tuple<Values...>,
-  composite_key_result<CompositeKey>
-)
-#endif
-
-/* composite_key_equal_to */
-
-template
-<
-  BOOST_MULTI_INDEX_CK_ENUM(BOOST_MULTI_INDEX_CK_TEMPLATE_PARM,Pred)
->
-struct composite_key_equal_to:
-  private tuple<BOOST_MULTI_INDEX_CK_ENUM_PARAMS(Pred)>
-{
-private:
-  typedef tuple<BOOST_MULTI_INDEX_CK_ENUM_PARAMS(Pred)> super;
-
-public:
-  typedef super key_eq_tuple;
-
-  composite_key_equal_to(
-    BOOST_MULTI_INDEX_CK_ENUM(BOOST_MULTI_INDEX_CK_CTOR_ARG,Pred)):
-    super(BOOST_MULTI_INDEX_CK_ENUM_PARAMS(k))
-  {}
-
-  composite_key_equal_to(const key_eq_tuple& x):super(x){}
-
-  const key_eq_tuple& key_eqs()const{return *this;}
-  key_eq_tuple&       key_eqs(){return *this;}
-
-  template<typename CompositeKey1,typename CompositeKey2>
-  bool operator()(
-    const composite_key_result<CompositeKey1> & x,
-    const composite_key_result<CompositeKey2> & y)const
-  {
-    typedef typename CompositeKey1::key_extractor_tuple key_extractor_tuple1;
-    typedef typename CompositeKey1::value_type          value_type1;
-    typedef typename CompositeKey2::key_extractor_tuple key_extractor_tuple2;
-    typedef typename CompositeKey2::value_type          value_type2;
-
-    BOOST_STATIC_ASSERT(
-      tuples::length<key_extractor_tuple1>::value<=
-      tuples::length<key_eq_tuple>::value&&
-      tuples::length<key_extractor_tuple1>::value==
-      tuples::length<key_extractor_tuple2>::value);
-
-    return detail::equal_ckey_ckey<
-      key_extractor_tuple1,value_type1,
-      key_extractor_tuple2,value_type2,
-      key_eq_tuple
-    >::compare(
-      x.composite_key.key_extractors(),x.value,
-      y.composite_key.key_extractors(),y.value,
-      key_eqs());
-  }
-  
-  template
-  <
-    typename CompositeKey,
-    BOOST_MULTI_INDEX_CK_ENUM_PARAMS(typename Value)
-  >
-  bool operator()(
-    const composite_key_result<CompositeKey>& x,
-    const tuple<BOOST_MULTI_INDEX_CK_ENUM_PARAMS(Value)>& y)const
-  {
-    typedef typename CompositeKey::key_extractor_tuple     key_extractor_tuple;
-    typedef typename CompositeKey::value_type              value_type;
-    typedef tuple<BOOST_MULTI_INDEX_CK_ENUM_PARAMS(Value)> key_tuple;
-
-    BOOST_STATIC_ASSERT(
-      tuples::length<key_extractor_tuple>::value<=
-      tuples::length<key_eq_tuple>::value&&
-      tuples::length<key_extractor_tuple>::value==
-      tuples::length<key_tuple>::value);
-
-    return detail::equal_ckey_cval<
-      key_extractor_tuple,value_type,
-      key_tuple,key_eq_tuple
-    >::compare(x.composite_key.key_extractors(),x.value,y,key_eqs());
-  }
-
-  template
-  <
-    BOOST_MULTI_INDEX_CK_ENUM_PARAMS(typename Value),
-    typename CompositeKey
-  >
-  bool operator()(
-    const tuple<BOOST_MULTI_INDEX_CK_ENUM_PARAMS(Value)>& x,
-    const composite_key_result<CompositeKey>& y)const
-  {
-    typedef typename CompositeKey::key_extractor_tuple     key_extractor_tuple;
-    typedef typename CompositeKey::value_type              value_type;
-    typedef tuple<BOOST_MULTI_INDEX_CK_ENUM_PARAMS(Value)> key_tuple;
-
-    BOOST_STATIC_ASSERT(
-      tuples::length<key_tuple>::value<=
-      tuples::length<key_eq_tuple>::value&&
-      tuples::length<key_tuple>::value==
-      tuples::length<key_extractor_tuple>::value);
-
-    return detail::equal_ckey_cval<
-      key_extractor_tuple,value_type,
-      key_tuple,key_eq_tuple
-    >::compare(x,y.composite_key.key_extractors(),y.value,key_eqs());
-  }
-
-#if !defined(BOOST_NO_CXX11_HDR_TUPLE)&&\
-    !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-  template<typename CompositeKey,typename... Values>
-  bool operator()(
-    const composite_key_result<CompositeKey>& x,
-    const std::tuple<Values...>& y)const
-  {
-    typedef typename CompositeKey::key_extractor_tuple key_extractor_tuple;
-    typedef typename CompositeKey::value_type          value_type;
-    typedef std::tuple<Values...>                      key_tuple;
-    typedef typename detail::cons_stdtuple_ctor<
-      key_tuple>::result_type                          cons_key_tuple;
-
-    BOOST_STATIC_ASSERT(
-      tuples::length<key_extractor_tuple>::value<=
-      tuples::length<key_eq_tuple>::value&&
-      static_cast<std::size_t>(tuples::length<key_extractor_tuple>::value)==
-      std::tuple_size<key_tuple>::value);
-
-    return detail::equal_ckey_cval<
-      key_extractor_tuple,value_type,
-      cons_key_tuple,key_eq_tuple
-    >::compare(
-      x.composite_key.key_extractors(),x.value,
-      detail::make_cons_stdtuple(y),key_eqs());
-  }
-
-  template<typename CompositeKey,typename... Values>
-  bool operator()(
-    const std::tuple<Values...>& x,
-    const composite_key_result<CompositeKey>& y)const
-  {
-    typedef typename CompositeKey::key_extractor_tuple key_extractor_tuple;
-    typedef typename CompositeKey::value_type          value_type;
-    typedef std::tuple<Values...>                      key_tuple;
-    typedef typename detail::cons_stdtuple_ctor<
-      key_tuple>::result_type                          cons_key_tuple;
-
-    BOOST_STATIC_ASSERT(
-      std::tuple_size<key_tuple>::value<=
-      static_cast<std::size_t>(tuples::length<key_eq_tuple>::value)&&
-      std::tuple_size<key_tuple>::value==
-      static_cast<std::size_t>(tuples::length<key_extractor_tuple>::value));
-
-    return detail::equal_ckey_cval<
-      key_extractor_tuple,value_type,
-      cons_key_tuple,key_eq_tuple
-    >::compare(
-      detail::make_cons_stdtuple(x),y.composite_key.key_extractors(),
-      y.value,key_eqs());
-  }
-#endif
-};
-
-/* composite_key_compare */
-
-template
-<
-  BOOST_MULTI_INDEX_CK_ENUM(BOOST_MULTI_INDEX_CK_TEMPLATE_PARM,Compare)
->
-struct composite_key_compare:
-  private tuple<BOOST_MULTI_INDEX_CK_ENUM_PARAMS(Compare)>
-{
-private:
-  typedef tuple<BOOST_MULTI_INDEX_CK_ENUM_PARAMS(Compare)> super;
-
-public:
-  typedef super key_comp_tuple;
-
-  composite_key_compare(
-    BOOST_MULTI_INDEX_CK_ENUM(BOOST_MULTI_INDEX_CK_CTOR_ARG,Compare)):
-    super(BOOST_MULTI_INDEX_CK_ENUM_PARAMS(k))
-  {}
-
-  composite_key_compare(const key_comp_tuple& x):super(x){}
-
-  const key_comp_tuple& key_comps()const{return *this;}
-  key_comp_tuple&       key_comps(){return *this;}
-
-  template<typename CompositeKey1,typename CompositeKey2>
-  bool operator()(
-    const composite_key_result<CompositeKey1> & x,
-    const composite_key_result<CompositeKey2> & y)const
-  {
-    typedef typename CompositeKey1::key_extractor_tuple key_extractor_tuple1;
-    typedef typename CompositeKey1::value_type          value_type1;
-    typedef typename CompositeKey2::key_extractor_tuple key_extractor_tuple2;
-    typedef typename CompositeKey2::value_type          value_type2;
-
-    BOOST_STATIC_ASSERT(
-      tuples::length<key_extractor_tuple1>::value<=
-      tuples::length<key_comp_tuple>::value||
-      tuples::length<key_extractor_tuple2>::value<=
-      tuples::length<key_comp_tuple>::value);
-
-    return detail::compare_ckey_ckey<
-      key_extractor_tuple1,value_type1,
-      key_extractor_tuple2,value_type2,
-      key_comp_tuple
-    >::compare(
-      x.composite_key.key_extractors(),x.value,
-      y.composite_key.key_extractors(),y.value,
-      key_comps());
-  }
-  
-#if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
-  template<typename CompositeKey,typename Value>
-  bool operator()(
-    const composite_key_result<CompositeKey>& x,
-    const Value& y)const
-  {
-    return operator()(x,boost::make_tuple(boost::cref(y)));
-  }
-#endif
-
-  template
-  <
-    typename CompositeKey,
-    BOOST_MULTI_INDEX_CK_ENUM_PARAMS(typename Value)
-  >
-  bool operator()(
-    const composite_key_result<CompositeKey>& x,
-    const tuple<BOOST_MULTI_INDEX_CK_ENUM_PARAMS(Value)>& y)const
-  {
-    typedef typename CompositeKey::key_extractor_tuple     key_extractor_tuple;
-    typedef typename CompositeKey::value_type              value_type;
-    typedef tuple<BOOST_MULTI_INDEX_CK_ENUM_PARAMS(Value)> key_tuple;
-
-    BOOST_STATIC_ASSERT(
-      tuples::length<key_extractor_tuple>::value<=
-      tuples::length<key_comp_tuple>::value||
-      tuples::length<key_tuple>::value<=
-      tuples::length<key_comp_tuple>::value);
-
-    return detail::compare_ckey_cval<
-      key_extractor_tuple,value_type,
-      key_tuple,key_comp_tuple
-    >::compare(x.composite_key.key_extractors(),x.value,y,key_comps());
-  }
-
-#if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
-  template<typename Value,typename CompositeKey>
-  bool operator()(
-    const Value& x,
-    const composite_key_result<CompositeKey>& y)const
-  {
-    return operator()(boost::make_tuple(boost::cref(x)),y);
-  }
-#endif
-
-  template
-  <
-    BOOST_MULTI_INDEX_CK_ENUM_PARAMS(typename Value),
-    typename CompositeKey
-  >
-  bool operator()(
-    const tuple<BOOST_MULTI_INDEX_CK_ENUM_PARAMS(Value)>& x,
-    const composite_key_result<CompositeKey>& y)const
-  {
-    typedef typename CompositeKey::key_extractor_tuple     key_extractor_tuple;
-    typedef typename CompositeKey::value_type              value_type;
-    typedef tuple<BOOST_MULTI_INDEX_CK_ENUM_PARAMS(Value)> key_tuple;
-
-    BOOST_STATIC_ASSERT(
-      tuples::length<key_tuple>::value<=
-      tuples::length<key_comp_tuple>::value||
-      tuples::length<key_extractor_tuple>::value<=
-      tuples::length<key_comp_tuple>::value);
-
-    return detail::compare_ckey_cval<
-      key_extractor_tuple,value_type,
-      key_tuple,key_comp_tuple
-    >::compare(x,y.composite_key.key_extractors(),y.value,key_comps());
-  }
-
-#if !defined(BOOST_NO_CXX11_HDR_TUPLE)&&\
-    !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-  template<typename CompositeKey,typename... Values>
-  bool operator()(
-    const composite_key_result<CompositeKey>& x,
-    const std::tuple<Values...>& y)const
-  {
-    typedef typename CompositeKey::key_extractor_tuple key_extractor_tuple;
-    typedef typename CompositeKey::value_type          value_type;
-    typedef std::tuple<Values...>                      key_tuple;
-    typedef typename detail::cons_stdtuple_ctor<
-      key_tuple>::result_type                          cons_key_tuple;
-
-    BOOST_STATIC_ASSERT(
-      tuples::length<key_extractor_tuple>::value<=
-      tuples::length<key_comp_tuple>::value||
-      std::tuple_size<key_tuple>::value<=
-      static_cast<std::size_t>(tuples::length<key_comp_tuple>::value));
-
-    return detail::compare_ckey_cval<
-      key_extractor_tuple,value_type,
-      cons_key_tuple,key_comp_tuple
-    >::compare(
-      x.composite_key.key_extractors(),x.value,
-      detail::make_cons_stdtuple(y),key_comps());
-  }
-
-  template<typename CompositeKey,typename... Values>
-  bool operator()(
-    const std::tuple<Values...>& x,
-    const composite_key_result<CompositeKey>& y)const
-  {
-    typedef typename CompositeKey::key_extractor_tuple key_extractor_tuple;
-    typedef typename CompositeKey::value_type          value_type;
-    typedef std::tuple<Values...>                      key_tuple;
-    typedef typename detail::cons_stdtuple_ctor<
-      key_tuple>::result_type                          cons_key_tuple;
-
-    BOOST_STATIC_ASSERT(
-      std::tuple_size<key_tuple>::value<=
-      static_cast<std::size_t>(tuples::length<key_comp_tuple>::value)||
-      tuples::length<key_extractor_tuple>::value<=
-      tuples::length<key_comp_tuple>::value);
-
-    return detail::compare_ckey_cval<
-      key_extractor_tuple,value_type,
-      cons_key_tuple,key_comp_tuple
-    >::compare(
-      detail::make_cons_stdtuple(x),y.composite_key.key_extractors(),
-      y.value,key_comps());
-  }
-#endif
-};
-
-/* composite_key_hash */
-
-template
-<
-  BOOST_MULTI_INDEX_CK_ENUM(BOOST_MULTI_INDEX_CK_TEMPLATE_PARM,Hash)
->
-struct composite_key_hash:
-  private tuple<BOOST_MULTI_INDEX_CK_ENUM_PARAMS(Hash)>
-{
-private:
-  typedef tuple<BOOST_MULTI_INDEX_CK_ENUM_PARAMS(Hash)> super;
-
-public:
-  typedef super key_hasher_tuple;
-
-  composite_key_hash(
-    BOOST_MULTI_INDEX_CK_ENUM(BOOST_MULTI_INDEX_CK_CTOR_ARG,Hash)):
-    super(BOOST_MULTI_INDEX_CK_ENUM_PARAMS(k))
-  {}
-
-  composite_key_hash(const key_hasher_tuple& x):super(x){}
-
-  const key_hasher_tuple& key_hash_functions()const{return *this;}
-  key_hasher_tuple&       key_hash_functions(){return *this;}
-
-  template<typename CompositeKey>
-  std::size_t operator()(const composite_key_result<CompositeKey> & x)const
-  {
-    typedef typename CompositeKey::key_extractor_tuple key_extractor_tuple;
-    typedef typename CompositeKey::value_type          value_type;
-
-    BOOST_STATIC_ASSERT(
-      tuples::length<key_extractor_tuple>::value==
-      tuples::length<key_hasher_tuple>::value);
-
-    return detail::hash_ckey<
-      key_extractor_tuple,value_type,
-      key_hasher_tuple
-    >::hash(x.composite_key.key_extractors(),x.value,key_hash_functions());
-  }
-  
-  template<BOOST_MULTI_INDEX_CK_ENUM_PARAMS(typename Value)>
-  std::size_t operator()(
-    const tuple<BOOST_MULTI_INDEX_CK_ENUM_PARAMS(Value)>& x)const
-  {
-    typedef tuple<BOOST_MULTI_INDEX_CK_ENUM_PARAMS(Value)> key_tuple;
-
-    BOOST_STATIC_ASSERT(
-      tuples::length<key_tuple>::value==
-      tuples::length<key_hasher_tuple>::value);
-
-    return detail::hash_cval<
-      key_tuple,key_hasher_tuple
-    >::hash(x,key_hash_functions());
-  }
-
-#if !defined(BOOST_NO_CXX11_HDR_TUPLE)&&\
-    !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-  template<typename... Values>
-  std::size_t operator()(const std::tuple<Values...>& x)const
-  {
-    typedef std::tuple<Values...>                key_tuple;
-    typedef typename detail::cons_stdtuple_ctor<
-      key_tuple>::result_type                    cons_key_tuple;
-
-    BOOST_STATIC_ASSERT(
-      std::tuple_size<key_tuple>::value==
-      static_cast<std::size_t>(tuples::length<key_hasher_tuple>::value));
-
-    return detail::hash_cval<
-      cons_key_tuple,key_hasher_tuple
-    >::hash(detail::make_cons_stdtuple(x),key_hash_functions());
-  }
-#endif
-};
-
-/* Instantiations of the former functors with "natural" basic components:
- * composite_key_result_equal_to uses std::equal_to of the values.
- * composite_key_result_less     uses std::less.
- * composite_key_result_greater  uses std::greater.
- * composite_key_result_hash     uses boost::hash.
- */
-
-#define BOOST_MULTI_INDEX_CK_RESULT_EQUAL_TO_SUPER                           \
-composite_key_equal_to<                                                      \
-    BOOST_MULTI_INDEX_CK_ENUM(                                               \
-      BOOST_MULTI_INDEX_CK_APPLY_METAFUNCTION_N,                             \
-      /* the argument is a PP list */                                        \
-      (detail::nth_composite_key_equal_to,                                   \
-        (BOOST_DEDUCED_TYPENAME CompositeKeyResult::composite_key_type,      \
-          BOOST_PP_NIL)))                                                    \
-  >
-
-template<typename CompositeKeyResult>
-struct composite_key_result_equal_to:
-BOOST_MULTI_INDEX_PRIVATE_IF_USING_DECL_FOR_TEMPL_FUNCTIONS
-BOOST_MULTI_INDEX_CK_RESULT_EQUAL_TO_SUPER
-{
-private:
-  typedef BOOST_MULTI_INDEX_CK_RESULT_EQUAL_TO_SUPER super;
-
-public:
-  typedef CompositeKeyResult  first_argument_type;
-  typedef first_argument_type second_argument_type;
-  typedef bool                result_type;
-
-  using super::operator();
-};
-
-#define BOOST_MULTI_INDEX_CK_RESULT_LESS_SUPER                               \
-composite_key_compare<                                                       \
-    BOOST_MULTI_INDEX_CK_ENUM(                                               \
-      BOOST_MULTI_INDEX_CK_APPLY_METAFUNCTION_N,                             \
-      /* the argument is a PP list */                                        \
-      (detail::nth_composite_key_less,                                       \
-        (BOOST_DEDUCED_TYPENAME CompositeKeyResult::composite_key_type,      \
-          BOOST_PP_NIL)))                                                    \
-  >
-
-template<typename CompositeKeyResult>
-struct composite_key_result_less:
-BOOST_MULTI_INDEX_PRIVATE_IF_USING_DECL_FOR_TEMPL_FUNCTIONS
-BOOST_MULTI_INDEX_CK_RESULT_LESS_SUPER
-{
-private:
-  typedef BOOST_MULTI_INDEX_CK_RESULT_LESS_SUPER super;
-
-public:
-  typedef CompositeKeyResult  first_argument_type;
-  typedef first_argument_type second_argument_type;
-  typedef bool                result_type;
-
-  using super::operator();
-};
-
-#define BOOST_MULTI_INDEX_CK_RESULT_GREATER_SUPER                            \
-composite_key_compare<                                                       \
-    BOOST_MULTI_INDEX_CK_ENUM(                                               \
-      BOOST_MULTI_INDEX_CK_APPLY_METAFUNCTION_N,                             \
-      /* the argument is a PP list */                                        \
-      (detail::nth_composite_key_greater,                                    \
-        (BOOST_DEDUCED_TYPENAME CompositeKeyResult::composite_key_type,      \
-          BOOST_PP_NIL)))                                                    \
-  >
-
-template<typename CompositeKeyResult>
-struct composite_key_result_greater:
-BOOST_MULTI_INDEX_PRIVATE_IF_USING_DECL_FOR_TEMPL_FUNCTIONS
-BOOST_MULTI_INDEX_CK_RESULT_GREATER_SUPER
-{
-private:
-  typedef BOOST_MULTI_INDEX_CK_RESULT_GREATER_SUPER super;
-
-public:
-  typedef CompositeKeyResult  first_argument_type;
-  typedef first_argument_type second_argument_type;
-  typedef bool                result_type;
-
-  using super::operator();
-};
-
-#define BOOST_MULTI_INDEX_CK_RESULT_HASH_SUPER                               \
-composite_key_hash<                                                          \
-    BOOST_MULTI_INDEX_CK_ENUM(                                               \
-      BOOST_MULTI_INDEX_CK_APPLY_METAFUNCTION_N,                             \
-      /* the argument is a PP list */                                        \
-      (detail::nth_composite_key_hash,                                       \
-        (BOOST_DEDUCED_TYPENAME CompositeKeyResult::composite_key_type,      \
-          BOOST_PP_NIL)))                                                    \
-  >
-
-template<typename CompositeKeyResult>
-struct composite_key_result_hash:
-BOOST_MULTI_INDEX_PRIVATE_IF_USING_DECL_FOR_TEMPL_FUNCTIONS
-BOOST_MULTI_INDEX_CK_RESULT_HASH_SUPER
-{
-private:
-  typedef BOOST_MULTI_INDEX_CK_RESULT_HASH_SUPER super;
-
-public:
-  typedef CompositeKeyResult argument_type;
-  typedef std::size_t        result_type;
-
-  using super::operator();
-};
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-/* Specializations of std::equal_to, std::less, std::greater and boost::hash
- * for composite_key_results enabling interoperation with tuples of values.
- */
-
-namespace std{
-
-template<typename CompositeKey>
-struct equal_to<boost::multi_index::composite_key_result<CompositeKey> >:
-  boost::multi_index::composite_key_result_equal_to<
-    boost::multi_index::composite_key_result<CompositeKey>
-  >
-{
-};
-
-template<typename CompositeKey>
-struct less<boost::multi_index::composite_key_result<CompositeKey> >:
-  boost::multi_index::composite_key_result_less<
-    boost::multi_index::composite_key_result<CompositeKey>
-  >
-{
-};
-
-template<typename CompositeKey>
-struct greater<boost::multi_index::composite_key_result<CompositeKey> >:
-  boost::multi_index::composite_key_result_greater<
-    boost::multi_index::composite_key_result<CompositeKey>
-  >
-{
-};
-
-} /* namespace std */
-
-namespace boost{
-
-template<typename CompositeKey>
-struct hash<boost::multi_index::composite_key_result<CompositeKey> >:
-  boost::multi_index::composite_key_result_hash<
-    boost::multi_index::composite_key_result<CompositeKey>
-  >
-{
-};
-
-} /* namespace boost */
-
-#undef BOOST_MULTI_INDEX_CK_RESULT_HASH_SUPER
-#undef BOOST_MULTI_INDEX_CK_RESULT_GREATER_SUPER
-#undef BOOST_MULTI_INDEX_CK_RESULT_LESS_SUPER
-#undef BOOST_MULTI_INDEX_CK_RESULT_EQUAL_TO_SUPER
-#undef BOOST_MULTI_INDEX_CK_COMPLETE_COMP_OPS
-#undef BOOST_MULTI_INDEX_CK_IDENTITY_ENUM_MACRO
-#undef BOOST_MULTI_INDEX_CK_NTH_COMPOSITE_KEY_FUNCTOR
-#undef BOOST_MULTI_INDEX_CK_APPLY_METAFUNCTION_N
-#undef BOOST_MULTI_INDEX_CK_CTOR_ARG
-#undef BOOST_MULTI_INDEX_CK_TEMPLATE_PARM
-#undef BOOST_MULTI_INDEX_CK_ENUM_PARAMS
-#undef BOOST_MULTI_INDEX_CK_ENUM
-#undef BOOST_MULTI_INDEX_COMPOSITE_KEY_SIZE
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/access_specifier.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/access_specifier.hpp
deleted file mode 100644
index f3346e836d4..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/access_specifier.hpp
+++ /dev/null
@@ -1,54 +0,0 @@
-/* Copyright 2003-2013 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_DETAIL_ACCESS_SPECIFIER_HPP
-#define BOOST_MULTI_INDEX_DETAIL_ACCESS_SPECIFIER_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp>
-#include <boost/detail/workaround.hpp>
-
-/* In those compilers that do not accept the member template friend syntax,
- * some protected and private sections might need to be specified as
- * public.
- */
-
-#if defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
-#define BOOST_MULTI_INDEX_PROTECTED_IF_MEMBER_TEMPLATE_FRIENDS public
-#define BOOST_MULTI_INDEX_PRIVATE_IF_MEMBER_TEMPLATE_FRIENDS public
-#else
-#define BOOST_MULTI_INDEX_PROTECTED_IF_MEMBER_TEMPLATE_FRIENDS protected
-#define BOOST_MULTI_INDEX_PRIVATE_IF_MEMBER_TEMPLATE_FRIENDS private
-#endif
-
-/* GCC does not correctly support in-class using declarations for template
- * functions. See http://gcc.gnu.org/bugzilla/show_bug.cgi?id=9810
- * MSVC 7.1/8.0 seem to have a similar problem, though the conditions in
- * which the error happens are not that simple. I have yet to isolate this
- * into a snippet suitable for bug reporting.
- * Sun Studio also has this problem, which might be related, from the
- * information gathered at Sun forums, with a known issue notified at the
- * internal bug report 6421933. The bug is present up to Studio Express 2,
- * the latest preview version of the future Sun Studio 12. As of this writing
- * (October 2006) it is not known whether a fix will finally make it into the
- * official Sun Studio 12.
- */
-
-#if BOOST_WORKAROUND(__GNUC__,==3)&&(__GNUC_MINOR__<4)||\
-    BOOST_WORKAROUND(BOOST_MSVC,==1310)||\
-    BOOST_WORKAROUND(BOOST_MSVC,==1400)||\
-    BOOST_WORKAROUND(__SUNPRO_CC,BOOST_TESTED_AT(0x590))
-#define BOOST_MULTI_INDEX_PRIVATE_IF_USING_DECL_FOR_TEMPL_FUNCTIONS public
-#else
-#define BOOST_MULTI_INDEX_PRIVATE_IF_USING_DECL_FOR_TEMPL_FUNCTIONS private
-#endif
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/adl_swap.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/adl_swap.hpp
deleted file mode 100644
index 02b06442290..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/adl_swap.hpp
+++ /dev/null
@@ -1,44 +0,0 @@
-/* Copyright 2003-2013 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_DETAIL_ADL_SWAP_HPP
-#define BOOST_MULTI_INDEX_DETAIL_ADL_SWAP_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <algorithm>
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-template<typename T>
-void adl_swap(T& x,T& y)
-{
-
-#if !defined(BOOST_FUNCTION_SCOPE_USING_DECLARATION_BREAKS_ADL)
-  using std::swap;
-  swap(x,y);
-#else
-  std::swap(x,y);
-#endif
-
-}
-
-} /* namespace multi_index::detail */
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/archive_constructed.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/archive_constructed.hpp
deleted file mode 100644
index 0a7a26e0d4e..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/archive_constructed.hpp
+++ /dev/null
@@ -1,83 +0,0 @@
-/* Copyright 2003-2016 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_DETAIL_ARCHIVE_CONSTRUCTED_HPP
-#define BOOST_MULTI_INDEX_DETAIL_ARCHIVE_CONSTRUCTED_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <boost/detail/no_exceptions_support.hpp>
-#include <boost/noncopyable.hpp>
-#include <boost/serialization/serialization.hpp>
-#include <boost/type_traits/aligned_storage.hpp>
-#include <boost/type_traits/alignment_of.hpp> 
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-/* constructs a stack-based object from a serialization archive */
-
-template<typename T>
-struct archive_constructed:private noncopyable
-{
-  template<class Archive>
-  archive_constructed(Archive& ar,const unsigned int version)
-  {
-    serialization::load_construct_data_adl(ar,&get(),version);
-    BOOST_TRY{
-      ar>>get();
-    }
-    BOOST_CATCH(...){
-      (&get())->~T();
-      BOOST_RETHROW;
-    }
-    BOOST_CATCH_END
-  }
-
-  template<class Archive>
-  archive_constructed(const char* name,Archive& ar,const unsigned int version)
-  {
-    serialization::load_construct_data_adl(ar,&get(),version);
-    BOOST_TRY{
-      ar>>serialization::make_nvp(name,get());
-    }
-    BOOST_CATCH(...){
-      (&get())->~T();
-      BOOST_RETHROW;
-    }
-    BOOST_CATCH_END
-  }
-
-  ~archive_constructed()
-  {
-    (&get())->~T();
-  }
-
-#include <boost/multi_index/detail/ignore_wstrict_aliasing.hpp>
-
-  T& get(){return *reinterpret_cast<T*>(&space);}
-
-#include <boost/multi_index/detail/restore_wstrict_aliasing.hpp>
-
-private:
-  typename aligned_storage<sizeof(T),alignment_of<T>::value>::type space;
-};
-
-} /* namespace multi_index::detail */
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/auto_space.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/auto_space.hpp
deleted file mode 100644
index 9d78c3a363f..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/auto_space.hpp
+++ /dev/null
@@ -1,91 +0,0 @@
-/* Copyright 2003-2013 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_DETAIL_AUTO_SPACE_HPP
-#define BOOST_MULTI_INDEX_DETAIL_AUTO_SPACE_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <algorithm>
-#include <boost/detail/allocator_utilities.hpp>
-#include <boost/multi_index/detail/adl_swap.hpp>
-#include <boost/noncopyable.hpp>
-#include <memory>
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-/* auto_space provides uninitialized space suitably to store
- * a given number of elements of a given type.
- */
-
-/* NB: it is not clear whether using an allocator to handle
- * zero-sized arrays of elements is conformant or not. GCC 3.3.1
- * and prior fail here, other stdlibs handle the issue gracefully.
- * To be on the safe side, the case n==0 is given special treatment.
- * References:
- *   GCC Bugzilla, "standard allocator crashes when deallocating segment
- *    "of zero length", http://gcc.gnu.org/bugzilla/show_bug.cgi?id=14176
- *   C++ Standard Library Defect Report List (Revision 28), issue 199
- *     "What does allocate(0) return?",
- *     http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#199
- */
-
-template<typename T,typename Allocator=std::allocator<T> >
-struct auto_space:private noncopyable
-{
-  typedef typename boost::detail::allocator::rebind_to<
-    Allocator,T
-  >::type::pointer pointer;
-
-  explicit auto_space(const Allocator& al=Allocator(),std::size_t n=1):
-  al_(al),n_(n),data_(n_?al_.allocate(n_):pointer(0))
-  {}
-
-  ~auto_space()
-  {
-    if(n_)al_.deallocate(data_,n_);
-  }
-
-  Allocator get_allocator()const{return al_;}
-
-  pointer data()const{return data_;}
-
-  void swap(auto_space& x)
-  {
-    if(al_!=x.al_)adl_swap(al_,x.al_);
-    std::swap(n_,x.n_);
-    std::swap(data_,x.data_);
-  }
-    
-private:
-  typename boost::detail::allocator::rebind_to<
-    Allocator,T>::type                          al_;
-  std::size_t                                   n_;
-  pointer                                       data_;
-};
-
-template<typename T,typename Allocator>
-void swap(auto_space<T,Allocator>& x,auto_space<T,Allocator>& y)
-{
-  x.swap(y);
-}
-
-} /* namespace multi_index::detail */
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/base_type.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/base_type.hpp
deleted file mode 100644
index 8c9b62b716a..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/base_type.hpp
+++ /dev/null
@@ -1,74 +0,0 @@
-/* Copyright 2003-2013 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_DETAIL_BASE_TYPE_HPP
-#define BOOST_MULTI_INDEX_DETAIL_BASE_TYPE_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <boost/detail/workaround.hpp>
-#include <boost/mpl/at.hpp>
-#include <boost/mpl/apply.hpp>
-#include <boost/mpl/size.hpp>
-#include <boost/multi_index/detail/index_base.hpp>
-#include <boost/multi_index/detail/is_index_list.hpp>
-#include <boost/static_assert.hpp>
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-/* MPL machinery to construct a linear hierarchy of indices out of
- * a index list.
- */
-
-struct index_applier
-{
-  template<typename IndexSpecifierMeta,typename SuperMeta>
-  struct apply
-  {
-    typedef typename IndexSpecifierMeta::type            index_specifier;
-    typedef typename index_specifier::
-      BOOST_NESTED_TEMPLATE index_class<SuperMeta>::type type;
-  }; 
-};
-
-template<int N,typename Value,typename IndexSpecifierList,typename Allocator>
-struct nth_layer
-{
-  BOOST_STATIC_CONSTANT(int,length=mpl::size<IndexSpecifierList>::value);
-
-  typedef typename  mpl::eval_if_c<
-    N==length,
-    mpl::identity<index_base<Value,IndexSpecifierList,Allocator> >,
-    mpl::apply2<
-      index_applier,
-      mpl::at_c<IndexSpecifierList,N>,
-      nth_layer<N+1,Value,IndexSpecifierList,Allocator>
-    >
-  >::type type;
-};
-
-template<typename Value,typename IndexSpecifierList,typename Allocator>
-struct multi_index_base_type:nth_layer<0,Value,IndexSpecifierList,Allocator>
-{
-  BOOST_STATIC_ASSERT(detail::is_index_list<IndexSpecifierList>::value);
-};
-
-} /* namespace multi_index::detail */
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/bidir_node_iterator.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/bidir_node_iterator.hpp
deleted file mode 100644
index 9be5ec84b43..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/bidir_node_iterator.hpp
+++ /dev/null
@@ -1,114 +0,0 @@
-/* Copyright 2003-2014 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_DETAIL_BIDIR_NODE_ITERATOR_HPP
-#define BOOST_MULTI_INDEX_DETAIL_BIDIR_NODE_ITERATOR_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <boost/operators.hpp>
-
-#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
-#include <boost/serialization/nvp.hpp>
-#include <boost/serialization/split_member.hpp>
-#endif
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-/* Iterator class for node-based indices with bidirectional
- * iterators (ordered and sequenced indices.)
- */
-
-template<typename Node>
-class bidir_node_iterator:
-  public bidirectional_iterator_helper<
-    bidir_node_iterator<Node>,
-    typename Node::value_type,
-    std::ptrdiff_t,
-    const typename Node::value_type*,
-    const typename Node::value_type&>
-{
-public:
-  /* coverity[uninit_ctor]: suppress warning */
-  bidir_node_iterator(){}
-  explicit bidir_node_iterator(Node* node_):node(node_){}
-
-  const typename Node::value_type& operator*()const
-  {
-    return node->value();
-  }
-
-  bidir_node_iterator& operator++()
-  {
-    Node::increment(node);
-    return *this;
-  }
-
-  bidir_node_iterator& operator--()
-  {
-    Node::decrement(node);
-    return *this;
-  }
-
-#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
-  /* Serialization. As for why the following is public,
-   * see explanation in safe_mode_iterator notes in safe_mode.hpp.
-   */
-
-  BOOST_SERIALIZATION_SPLIT_MEMBER()
-
-  typedef typename Node::base_type node_base_type;
-
-  template<class Archive>
-  void save(Archive& ar,const unsigned int)const
-  {
-    node_base_type* bnode=node;
-    ar<<serialization::make_nvp("pointer",bnode);
-  }
-
-  template<class Archive>
-  void load(Archive& ar,const unsigned int)
-  {
-    node_base_type* bnode;
-    ar>>serialization::make_nvp("pointer",bnode);
-    node=static_cast<Node*>(bnode);
-  }
-#endif
-
-  /* get_node is not to be used by the user */
-
-  typedef Node node_type;
-
-  Node* get_node()const{return node;}
-
-private:
-  Node* node;
-};
-
-template<typename Node>
-bool operator==(
-  const bidir_node_iterator<Node>& x,
-  const bidir_node_iterator<Node>& y)
-{
-  return x.get_node()==y.get_node();
-}
-
-} /* namespace multi_index::detail */
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/bucket_array.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/bucket_array.hpp
deleted file mode 100644
index d9fa434d9a9..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/bucket_array.hpp
+++ /dev/null
@@ -1,243 +0,0 @@
-/* Copyright 2003-2015 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_DETAIL_BUCKET_ARRAY_HPP
-#define BOOST_MULTI_INDEX_DETAIL_BUCKET_ARRAY_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <algorithm>
-#include <boost/multi_index/detail/auto_space.hpp>
-#include <boost/multi_index/detail/hash_index_node.hpp>
-#include <boost/noncopyable.hpp>
-#include <boost/preprocessor/repetition/repeat.hpp>
-#include <boost/preprocessor/seq/elem.hpp>
-#include <boost/preprocessor/seq/enum.hpp>
-#include <boost/preprocessor/seq/size.hpp>
-#include <cstddef>
-#include <limits.h>
-
-#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
-#include <boost/archive/archive_exception.hpp>
-#include <boost/serialization/access.hpp>
-#include <boost/throw_exception.hpp> 
-#endif
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-/* bucket structure for use by hashed indices */
-
-#define BOOST_MULTI_INDEX_BA_SIZES_32BIT                                  \
-(53ul)(97ul)(193ul)(389ul)(769ul)                                         \
-(1543ul)(3079ul)(6151ul)(12289ul)(24593ul)                                \
-(49157ul)(98317ul)(196613ul)(393241ul)(786433ul)                          \
-(1572869ul)(3145739ul)(6291469ul)(12582917ul)(25165843ul)                 \
-(50331653ul)(100663319ul)(201326611ul)(402653189ul)(805306457ul)          \
-(1610612741ul)(3221225473ul)
-
-#if ((((ULONG_MAX>>16)>>16)>>16)>>15)==0 /* unsigned long less than 64 bits */
-#define BOOST_MULTI_INDEX_BA_SIZES                                         \
-BOOST_MULTI_INDEX_BA_SIZES_32BIT                                           \
-(4294967291ul)
-#else
-  /* obtained with aid from
-   *   http://javaboutique.internet.com/prime_numb/
-   *   http://www.rsok.com/~jrm/next_ten_primes.html
-   * and verified with
-   *   http://www.alpertron.com.ar/ECM.HTM
-   */
-
-#define BOOST_MULTI_INDEX_BA_SIZES                                         \
-BOOST_MULTI_INDEX_BA_SIZES_32BIT                                           \
-(6442450939ul)(12884901893ul)(25769803751ul)(51539607551ul)                \
-(103079215111ul)(206158430209ul)(412316860441ul)(824633720831ul)           \
-(1649267441651ul)(3298534883309ul)(6597069766657ul)(13194139533299ul)      \
-(26388279066623ul)(52776558133303ul)(105553116266489ul)(211106232532969ul) \
-(422212465066001ul)(844424930131963ul)(1688849860263953ul)                 \
-(3377699720527861ul)(6755399441055731ul)(13510798882111483ul)              \
-(27021597764222939ul)(54043195528445957ul)(108086391056891903ul)           \
-(216172782113783843ul)(432345564227567621ul)(864691128455135207ul)         \
-(1729382256910270481ul)(3458764513820540933ul)(6917529027641081903ul)      \
-(13835058055282163729ul)(18446744073709551557ul)
-#endif
-
-template<bool _=true> /* templatized to have in-header static var defs */
-class bucket_array_base:private noncopyable
-{
-protected:
-  static const std::size_t sizes[
-    BOOST_PP_SEQ_SIZE(BOOST_MULTI_INDEX_BA_SIZES)];
-
-  static std::size_t size_index(std::size_t n)
-  {
-    const std::size_t *bound=std::lower_bound(sizes,sizes+sizes_length,n);
-    if(bound==sizes+sizes_length)--bound;
-    return bound-sizes;
-  }
-
-#define BOOST_MULTI_INDEX_BA_POSITION_CASE(z,n,_)                    \
-  case n:return hash%BOOST_PP_SEQ_ELEM(n,BOOST_MULTI_INDEX_BA_SIZES);
-
-  static std::size_t position(std::size_t hash,std::size_t size_index_)
-  {
-    /* Accelerate hash%sizes[size_index_] by replacing with a switch on
-     * hash%Ci expressions, each Ci a compile-time constant, which the
-     * compiler can implement without using integer division.
-     */
-
-    switch(size_index_){
-      default: /* never used */
-      BOOST_PP_REPEAT(
-        BOOST_PP_SEQ_SIZE(BOOST_MULTI_INDEX_BA_SIZES),
-        BOOST_MULTI_INDEX_BA_POSITION_CASE,~)
-    }
-  }
-
-private:
-  static const std::size_t sizes_length;
-};
-
-template<bool _>
-const std::size_t bucket_array_base<_>::sizes[]={
-  BOOST_PP_SEQ_ENUM(BOOST_MULTI_INDEX_BA_SIZES)
-};
-
-template<bool _>
-const std::size_t bucket_array_base<_>::sizes_length=
-  sizeof(bucket_array_base<_>::sizes)/
-  sizeof(bucket_array_base<_>::sizes[0]);
-
-#undef BOOST_MULTI_INDEX_BA_POSITION_CASE
-#undef BOOST_MULTI_INDEX_BA_SIZES
-#undef BOOST_MULTI_INDEX_BA_SIZES_32BIT
-
-template<typename Allocator>
-class bucket_array:bucket_array_base<>
-{
-  typedef bucket_array_base<>                        super;
-  typedef hashed_index_base_node_impl<
-    typename boost::detail::allocator::rebind_to<
-      Allocator,
-      char
-    >::type
-  >                                                  base_node_impl_type;
-
-public:
-  typedef typename base_node_impl_type::base_pointer base_pointer;
-  typedef typename base_node_impl_type::pointer      pointer;
-
-  bucket_array(const Allocator& al,pointer end_,std::size_t size_):
-    size_index_(super::size_index(size_)),
-    spc(al,super::sizes[size_index_]+1)
-  {
-    clear(end_);
-  }
-
-  std::size_t size()const
-  {
-    return super::sizes[size_index_];
-  }
-
-  std::size_t position(std::size_t hash)const
-  {
-    return super::position(hash,size_index_);
-  }
-
-  base_pointer begin()const{return buckets();}
-  base_pointer end()const{return buckets()+size();}
-  base_pointer at(std::size_t n)const{return buckets()+n;}
-
-  void clear(pointer end_)
-  {
-    for(base_pointer x=begin(),y=end();x!=y;++x)x->prior()=pointer(0);
-    end()->prior()=end_->prior()=end_;
-    end_->next()=end();
- }
-
-  void swap(bucket_array& x)
-  {
-    std::swap(size_index_,x.size_index_);
-    spc.swap(x.spc);
-  }
-
-private:
-  std::size_t                               size_index_;
-  auto_space<base_node_impl_type,Allocator> spc;
-
-  base_pointer buckets()const
-  {
-    return spc.data();
-  }
-
-#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
-  friend class boost::serialization::access;
-  
-  /* bucket_arrays do not emit any kind of serialization info. They are
-   * fed to Boost.Serialization as hashed index iterators need to track
-   * them during serialization.
-   */
-
-  template<class Archive>
-  void serialize(Archive&,const unsigned int)
-  {
-  }
-#endif
-};
-
-template<typename Allocator>
-void swap(bucket_array<Allocator>& x,bucket_array<Allocator>& y)
-{
-  x.swap(y);
-}
-
-} /* namespace multi_index::detail */
-
-} /* namespace multi_index */
-
-#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
-/* bucket_arrays never get constructed directly by Boost.Serialization,
- * as archives are always fed pointers to previously existent
- * arrays. So, if this is called it means we are dealing with a
- * somehow invalid archive.
- */
-
-#if defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)
-namespace serialization{
-#else
-namespace multi_index{
-namespace detail{
-#endif
-
-template<class Archive,typename Allocator>
-inline void load_construct_data(
-  Archive&,boost::multi_index::detail::bucket_array<Allocator>*,
-  const unsigned int)
-{
-  throw_exception(
-    archive::archive_exception(archive::archive_exception::other_exception));
-}
-
-#if defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)
-} /* namespace serialization */
-#else
-} /* namespace multi_index::detail */
-} /* namespace multi_index */
-#endif
-
-#endif
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/cons_stdtuple.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/cons_stdtuple.hpp
deleted file mode 100644
index 855c5e06aa9..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/cons_stdtuple.hpp
+++ /dev/null
@@ -1,93 +0,0 @@
-/* Copyright 2003-2014 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_DETAIL_CONS_STDTUPLE_HPP
-#define BOOST_MULTI_INDEX_DETAIL_CONS_STDTUPLE_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <boost/mpl/if.hpp>
-#include <boost/tuple/tuple.hpp>
-#include <tuple>
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-/* std::tuple wrapper providing the cons-based interface of boost::tuple for
- * composite_key interoperability.
- */
-
-template<typename StdTuple,std::size_t N>
-struct cons_stdtuple;
-
-struct cons_stdtuple_ctor_terminal
-{
-  typedef boost::tuples::null_type result_type;
-
-  template<typename StdTuple>
-  static result_type create(const StdTuple&)
-  {
-    return boost::tuples::null_type();
-  }
-};
-
-template<typename StdTuple,std::size_t N>
-struct cons_stdtuple_ctor_normal
-{
-  typedef cons_stdtuple<StdTuple,N> result_type;
-
-  static result_type create(const StdTuple& t)
-  {
-    return result_type(t);
-  }
-};
-
-template<typename StdTuple,std::size_t N=0>
-struct cons_stdtuple_ctor:
-  boost::mpl::if_c<
-    N<std::tuple_size<StdTuple>::value,
-    cons_stdtuple_ctor_normal<StdTuple,N>,
-    cons_stdtuple_ctor_terminal
-  >::type
-{};
-
-template<typename StdTuple,std::size_t N>
-struct cons_stdtuple
-{
-  typedef typename std::tuple_element<N,StdTuple>::type head_type;
-  typedef cons_stdtuple_ctor<StdTuple,N+1>              tail_ctor;
-  typedef typename tail_ctor::result_type               tail_type;
-  
-  cons_stdtuple(const StdTuple& t_):t(t_){}
-
-  const head_type& get_head()const{return std::get<N>(t);}
-  tail_type get_tail()const{return tail_ctor::create(t);}
-    
-  const StdTuple& t;
-};
-
-template<typename StdTuple>
-typename cons_stdtuple_ctor<StdTuple>::result_type
-make_cons_stdtuple(const StdTuple& t)
-{
-  return cons_stdtuple_ctor<StdTuple>::create(t);
-}
-
-} /* namespace multi_index::detail */
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/converter.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/converter.hpp
deleted file mode 100644
index 3e04a3e8295..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/converter.hpp
+++ /dev/null
@@ -1,52 +0,0 @@
-/* Copyright 2003-2013 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_DETAIL_CONVERTER_HPP
-#define BOOST_MULTI_INDEX_DETAIL_CONVERTER_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-/* converter offers means to access indices of a given multi_index_container
- * and for convertibilty between index iterators, so providing a
- * localized access point for get() and project() functions.
- */
-
-template<typename MultiIndexContainer,typename Index>
-struct converter
-{
-  static const Index& index(const MultiIndexContainer& x){return x;}
-  static Index&       index(MultiIndexContainer& x){return x;}
-
-  static typename Index::const_iterator const_iterator(
-    const MultiIndexContainer& x,typename MultiIndexContainer::node_type* node)
-  {
-    return x.Index::make_iterator(node);
-  }
-
-  static typename Index::iterator iterator(
-    MultiIndexContainer& x,typename MultiIndexContainer::node_type* node)
-  {
-    return x.Index::make_iterator(node);
-  }
-};
-
-} /* namespace multi_index::detail */
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/copy_map.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/copy_map.hpp
deleted file mode 100644
index 9a34b259cf3..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/copy_map.hpp
+++ /dev/null
@@ -1,142 +0,0 @@
-/* Copyright 2003-2015 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_DETAIL_COPY_MAP_HPP
-#define BOOST_MULTI_INDEX_DETAIL_COPY_MAP_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <algorithm>
-#include <boost/detail/no_exceptions_support.hpp>
-#include <boost/multi_index/detail/auto_space.hpp>
-#include <boost/multi_index/detail/raw_ptr.hpp>
-#include <boost/noncopyable.hpp>
-#include <cstddef>
-#include <functional>
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-/* copy_map is used as an auxiliary structure during copy_() operations.
- * When a container with n nodes is replicated, node_map holds the pairings
- * between original and copied nodes, and provides a fast way to find a
- * copied node from an original one.
- * The semantics of the class are not simple, and no attempt has been made
- * to enforce it: multi_index_container handles it right. On the other hand,
- * the const interface, which is the one provided to index implementations,
- * only allows for:
- *   - Enumeration of pairs of (original,copied) nodes (excluding the headers),
- *   - fast retrieval of copied nodes (including the headers.)
- */
-
-template <typename Node>
-struct copy_map_entry
-{
-  copy_map_entry(Node* f,Node* s):first(f),second(s){}
-
-  Node* first;
-  Node* second;
-
-  bool operator<(const copy_map_entry<Node>& x)const
-  {
-    return std::less<Node*>()(first,x.first);
-  }
-};
-
-template <typename Node,typename Allocator>
-class copy_map:private noncopyable
-{
-public:
-  typedef const copy_map_entry<Node>* const_iterator;
-
-  copy_map(
-    const Allocator& al,std::size_t size,Node* header_org,Node* header_cpy):
-    al_(al),size_(size),spc(al_,size_),n(0),
-    header_org_(header_org),header_cpy_(header_cpy),released(false)
-  {}
-
-  ~copy_map()
-  {
-    if(!released){
-      for(std::size_t i=0;i<n;++i){
-        boost::detail::allocator::destroy(&(spc.data()+i)->second->value());
-        deallocate((spc.data()+i)->second);
-      }
-    }
-  }
-
-  const_iterator begin()const{return raw_ptr<const_iterator>(spc.data());}
-  const_iterator end()const{return raw_ptr<const_iterator>(spc.data()+n);}
-
-  void clone(Node* node)
-  {
-    (spc.data()+n)->first=node;
-    (spc.data()+n)->second=raw_ptr<Node*>(al_.allocate(1));
-    BOOST_TRY{
-      boost::detail::allocator::construct(
-        &(spc.data()+n)->second->value(),node->value());
-    }
-    BOOST_CATCH(...){
-      deallocate((spc.data()+n)->second);
-      BOOST_RETHROW;
-    }
-    BOOST_CATCH_END
-    ++n;
-
-    if(n==size_){
-      std::sort(
-        raw_ptr<copy_map_entry<Node>*>(spc.data()),
-        raw_ptr<copy_map_entry<Node>*>(spc.data())+size_);
-    }
-  }
-
-  Node* find(Node* node)const
-  {
-    if(node==header_org_)return header_cpy_;
-    return std::lower_bound(
-      begin(),end(),copy_map_entry<Node>(node,0))->second;
-  }
-
-  void release()
-  {
-    released=true;
-  }
-
-private:
-  typedef typename boost::detail::allocator::rebind_to<
-    Allocator,Node
-  >::type                                               allocator_type;
-  typedef typename allocator_type::pointer              allocator_pointer;
-
-  allocator_type                                        al_;
-  std::size_t                                           size_;
-  auto_space<copy_map_entry<Node>,Allocator>            spc;
-  std::size_t                                           n;
-  Node*                                                 header_org_;
-  Node*                                                 header_cpy_;
-  bool                                                  released;
-
-  void deallocate(Node* node)
-  {
-    al_.deallocate(static_cast<allocator_pointer>(node),1);
-  }
-};
-
-} /* namespace multi_index::detail */
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/do_not_copy_elements_tag.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/do_not_copy_elements_tag.hpp
deleted file mode 100644
index f0fa7304253..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/do_not_copy_elements_tag.hpp
+++ /dev/null
@@ -1,34 +0,0 @@
-/* Copyright 2003-2013 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_DETAIL_DO_NOT_COPY_ELEMENTS_TAG_HPP
-#define BOOST_MULTI_INDEX_DETAIL_DO_NOT_COPY_ELEMENTS_TAG_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-/* Used to mark a special ctor variant that copies the internal objects of
- * a container but not its elements.
- */
-
-struct do_not_copy_elements_tag{};
-
-} /* namespace multi_index::detail */
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/duplicates_iterator.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/duplicates_iterator.hpp
deleted file mode 100644
index cbebf264045..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/duplicates_iterator.hpp
+++ /dev/null
@@ -1,120 +0,0 @@
-/* Copyright 2003-2013 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_DETAIL_DUPLICATES_ITERATOR_HPP
-#define BOOST_MULTI_INDEX_DETAIL_DUPLICATES_ITERATOR_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <cstddef>
-#include <iterator>
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-/* duplicates_operator is given a range of ordered elements and
- * passes only over those which are duplicated.
- */
-
-template<typename Node,typename Predicate>
-class duplicates_iterator
-{
-public:
-  typedef typename Node::value_type        value_type;
-  typedef std::ptrdiff_t                   difference_type;
-  typedef const typename Node::value_type* pointer;
-  typedef const typename Node::value_type& reference;
-  typedef std::forward_iterator_tag        iterator_category;
-
-  duplicates_iterator(Node* node_,Node* end_,Predicate pred_):
-    node(node_),begin_chunk(0),end(end_),pred(pred_)
-  {
-    advance();
-  }
-
-  duplicates_iterator(Node* end_,Predicate pred_):
-    node(end_),begin_chunk(end_),end(end_),pred(pred_)
-  {
-  }
-
-  reference operator*()const
-  {
-    return node->value();
-  }
-
-  pointer operator->()const
-  {
-    return &node->value();
-  }
-
-  duplicates_iterator& operator++()
-  {
-    Node::increment(node);
-    sync();
-    return *this;
-  }
-
-  duplicates_iterator operator++(int)
-  {
-    duplicates_iterator tmp(*this);
-    ++(*this);
-    return tmp;
-  }
-
-  Node* get_node()const{return node;}
-
-private:
-  void sync()
-  {
-    if(node!=end&&pred(begin_chunk->value(),node->value()))advance();
-  }
-
-  void advance()
-  {
-    for(Node* node2=node;node!=end;node=node2){
-      Node::increment(node2);
-      if(node2!=end&&!pred(node->value(),node2->value()))break;
-    }
-    begin_chunk=node;
-  }
-
-  Node*     node;
-  Node*     begin_chunk;
-  Node*     end;
-  Predicate pred;
-};
-
-template<typename Node,typename Predicate>
-bool operator==(
-  const duplicates_iterator<Node,Predicate>& x,
-  const duplicates_iterator<Node,Predicate>& y)
-{
-  return x.get_node()==y.get_node();
-}
-
-template<typename Node,typename Predicate>
-bool operator!=(
-  const duplicates_iterator<Node,Predicate>& x,
-  const duplicates_iterator<Node,Predicate>& y)
-{
-  return !(x==y);
-}
-
-} /* namespace multi_index::detail */
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/has_tag.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/has_tag.hpp
deleted file mode 100644
index 217b61143af..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/has_tag.hpp
+++ /dev/null
@@ -1,42 +0,0 @@
-/* Copyright 2003-2013 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_DETAIL_HAS_TAG_HPP
-#define BOOST_MULTI_INDEX_DETAIL_HAS_TAG_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <boost/mpl/contains.hpp>
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-/* determines whether an index type has a given tag in its tag list */
-
-template<typename Tag>
-struct has_tag
-{
-  template<typename Index>
-  struct apply:mpl::contains<BOOST_DEDUCED_TYPENAME Index::tag_list,Tag>
-  {
-  }; 
-};
-
-} /* namespace multi_index::detail */
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/hash_index_args.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/hash_index_args.hpp
deleted file mode 100644
index 81902f5a4a5..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/hash_index_args.hpp
+++ /dev/null
@@ -1,105 +0,0 @@
-/* Copyright 2003-2013 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_DETAIL_HASH_INDEX_ARGS_HPP
-#define BOOST_MULTI_INDEX_DETAIL_HASH_INDEX_ARGS_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <boost/functional/hash.hpp>
-#include <boost/mpl/aux_/na.hpp>
-#include <boost/mpl/eval_if.hpp>
-#include <boost/mpl/identity.hpp>
-#include <boost/mpl/if.hpp>
-#include <boost/multi_index/tag.hpp>
-#include <boost/static_assert.hpp>
-#include <boost/type_traits/is_same.hpp>
-#include <functional>
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-/* Hashed index specifiers can be instantiated in two forms:
- *
- *   (hashed_unique|hashed_non_unique)<
- *     KeyFromValue,
- *     Hash=boost::hash<KeyFromValue::result_type>,
- *     Pred=std::equal_to<KeyFromValue::result_type> >
- *   (hashed_unique|hashed_non_unique)<
- *     TagList,
- *     KeyFromValue,
- *     Hash=boost::hash<KeyFromValue::result_type>,
- *     Pred=std::equal_to<KeyFromValue::result_type> >
- *
- * hashed_index_args implements the machinery to accept this
- * argument-dependent polymorphism.
- */
-
-template<typename KeyFromValue>
-struct index_args_default_hash
-{
-  typedef ::boost::hash<typename KeyFromValue::result_type> type;
-};
-
-template<typename KeyFromValue>
-struct index_args_default_pred
-{
-  typedef std::equal_to<typename KeyFromValue::result_type> type;
-};
-
-template<typename Arg1,typename Arg2,typename Arg3,typename Arg4>
-struct hashed_index_args
-{
-  typedef is_tag<Arg1> full_form;
-
-  typedef typename mpl::if_<
-    full_form,
-    Arg1,
-    tag< > >::type                                   tag_list_type;
-  typedef typename mpl::if_<
-    full_form,
-    Arg2,
-    Arg1>::type                                      key_from_value_type;
-  typedef typename mpl::if_<
-    full_form,
-    Arg3,
-    Arg2>::type                                      supplied_hash_type;
-  typedef typename mpl::eval_if<
-    mpl::is_na<supplied_hash_type>,
-    index_args_default_hash<key_from_value_type>,
-    mpl::identity<supplied_hash_type>
-  >::type                                            hash_type;
-  typedef typename mpl::if_<
-    full_form,
-    Arg4,
-    Arg3>::type                                      supplied_pred_type;
-  typedef typename mpl::eval_if<
-    mpl::is_na<supplied_pred_type>,
-    index_args_default_pred<key_from_value_type>,
-    mpl::identity<supplied_pred_type>
-  >::type                                            pred_type;
-
-  BOOST_STATIC_ASSERT(is_tag<tag_list_type>::value);
-  BOOST_STATIC_ASSERT(!mpl::is_na<key_from_value_type>::value);
-  BOOST_STATIC_ASSERT(!mpl::is_na<hash_type>::value);
-  BOOST_STATIC_ASSERT(!mpl::is_na<pred_type>::value);
-};
-
-} /* namespace multi_index::detail */
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/hash_index_iterator.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/hash_index_iterator.hpp
deleted file mode 100644
index 8d063002a1d..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/hash_index_iterator.hpp
+++ /dev/null
@@ -1,166 +0,0 @@
-/* Copyright 2003-2014 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_DETAIL_HASH_INDEX_ITERATOR_HPP
-#define BOOST_MULTI_INDEX_DETAIL_HASH_INDEX_ITERATOR_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <boost/operators.hpp>
-
-#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
-#include <boost/serialization/nvp.hpp>
-#include <boost/serialization/split_member.hpp>
-#include <boost/serialization/version.hpp>
-#endif
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-/* Iterator class for hashed indices.
- */
-
-struct hashed_index_global_iterator_tag{};
-struct hashed_index_local_iterator_tag{};
-
-template<typename Node,typename BucketArray,typename Category>
-class hashed_index_iterator:
-  public forward_iterator_helper<
-    hashed_index_iterator<Node,BucketArray,Category>,
-    typename Node::value_type,
-    std::ptrdiff_t,
-    const typename Node::value_type*,
-    const typename Node::value_type&>
-{
-public:
-  /* coverity[uninit_ctor]: suppress warning */
-  hashed_index_iterator(){}
-  hashed_index_iterator(Node* node_):node(node_){}
-
-  const typename Node::value_type& operator*()const
-  {
-    return node->value();
-  }
-
-  hashed_index_iterator& operator++()
-  {
-    this->increment(Category());
-    return *this;
-  }
-
-#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
-  /* Serialization. As for why the following is public,
-   * see explanation in safe_mode_iterator notes in safe_mode.hpp.
-   */
-  
-  BOOST_SERIALIZATION_SPLIT_MEMBER()
-
-  typedef typename Node::base_type node_base_type;
-
-  template<class Archive>
-  void save(Archive& ar,const unsigned int)const
-  {
-    node_base_type* bnode=node;
-    ar<<serialization::make_nvp("pointer",bnode);
-  }
-
-  template<class Archive>
-  void load(Archive& ar,const unsigned int version)
-  {
-    load(ar,version,Category());
-  }
-
-  template<class Archive>
-  void load(
-    Archive& ar,const unsigned int version,hashed_index_global_iterator_tag)
-  {
-    node_base_type* bnode;
-    ar>>serialization::make_nvp("pointer",bnode);
-    node=static_cast<Node*>(bnode);
-    if(version<1){
-      BucketArray* throw_away; /* consume unused ptr */
-      ar>>serialization::make_nvp("pointer",throw_away);
-    }
-  }
-
-  template<class Archive>
-  void load(
-    Archive& ar,const unsigned int version,hashed_index_local_iterator_tag)
-  {
-    node_base_type* bnode;
-    ar>>serialization::make_nvp("pointer",bnode);
-    node=static_cast<Node*>(bnode);
-    if(version<1){
-      BucketArray* buckets;
-      ar>>serialization::make_nvp("pointer",buckets);
-      if(buckets&&node&&node->impl()==buckets->end()->prior()){
-        /* end local_iterators used to point to end node, now they are null */
-        node=0;
-      }
-    }
-  }
-#endif
-
-  /* get_node is not to be used by the user */
-
-  typedef Node node_type;
-
-  Node* get_node()const{return node;}
-
-private:
-
-  void increment(hashed_index_global_iterator_tag)
-  {
-    Node::increment(node);
-  }
-
-  void increment(hashed_index_local_iterator_tag)
-  {
-    Node::increment_local(node);
-  }
-
-  Node* node;
-};
-
-template<typename Node,typename BucketArray,typename Category>
-bool operator==(
-  const hashed_index_iterator<Node,BucketArray,Category>& x,
-  const hashed_index_iterator<Node,BucketArray,Category>& y)
-{
-  return x.get_node()==y.get_node();
-}
-
-} /* namespace multi_index::detail */
-
-} /* namespace multi_index */
-
-#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
-/* class version = 1 : hashed_index_iterator does no longer serialize a bucket
- * array pointer.
- */
-
-namespace serialization {
-template<typename Node,typename BucketArray,typename Category>
-struct version<
-  boost::multi_index::detail::hashed_index_iterator<Node,BucketArray,Category>
->
-{
-  BOOST_STATIC_CONSTANT(int,value=1);
-};
-} /* namespace serialization */
-#endif
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/hash_index_node.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/hash_index_node.hpp
deleted file mode 100644
index 7788e810ac9..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/hash_index_node.hpp
+++ /dev/null
@@ -1,778 +0,0 @@
-/* Copyright 2003-2015 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_DETAIL_HASH_INDEX_NODE_HPP
-#define BOOST_MULTI_INDEX_DETAIL_HASH_INDEX_NODE_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <boost/detail/allocator_utilities.hpp>
-#include <boost/multi_index/detail/raw_ptr.hpp>
-#include <utility>
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-/* Certain C++ requirements on unordered associative containers (see LWG issue
- * #579) imply a data structure where nodes are linked in a single list, which
- * in its turn forces implementors to add additional overhed per node to
- * associate each with its corresponding bucket. Others resort to storing hash
- * values, we use an alternative structure providing unconditional O(1)
- * manipulation, even in situations of unfair hash distribution, plus some
- * lookup speedups. For unique indices we maintain a doubly linked list of
- * nodes except that if N is the first node of a bucket its associated
- * bucket node is embedded between N and the preceding node in the following
- * manner:
- *
- *        +---+   +---+       +---+   +---+
- *     <--+   |<--+   |    <--+   |<--+   |
- *   ...  | B0|   | B1|  ...  | B1|   | B2|  ...
- *        |   |-+ |   +-->    |   |-+ |   +-->
- *        +-+-+ | +---+       +-+-+ | +---+
- *              |   ^               |   ^
- *              |   |               |   |
- *              | +-+               | +-+
- *              | |                 | |
- *              v |                 v |  
- *       --+---+---+---+--   --+---+---+---+--
- *     ... |   | B1|   |  ...  |   | B2|   | ...
- *       --+---+---+---+--   --+---+---+---+--
- *
- *
- * The fist and last nodes of buckets can be checked with
- *
- *   first node of a bucket: Npn != N
- *   last node of a bucket:  Nnp != N
- *
- * (n and p short for ->next(), ->prior(), bucket nodes have prior pointers
- * only). Pure insert and erase (without lookup) can be unconditionally done
- * in O(1).
- * For non-unique indices we add the following additional complexity: when
- * there is a group of 3 or more equivalent elements, they are linked as
- * follows:
- *
- *         +-----------------------+
- *         |                       v
- *   +---+ | +---+       +---+   +---+
- *   |   | +-+   |       |   |<--+   |
- *   | F |   | S |  ...  | P |   | L |
- *   |   +-->|   |       |   +-+ |   |
- *   +---+   +---+       +---+ | +---+
- *     ^                       |
- *     +-----------------------+
- * 
- * F, S, P and L are the first, second, penultimate and last node in the
- * group, respectively (S and P can coincide if the group has size 3.) This
- * arrangement is used to skip equivalent elements in O(1) when doing lookup,
- * while preserving O(1) insert/erase. The following invariants identify
- * special positions (some of the operations have to be carefully implemented
- * as Xnn is not valid if Xn points to a bucket):
- *
- *   first node of a bucket: Npnp  == N
- *   last node of a bucket:  Nnpp  == N
- *   first node of a group:  Nnp != N && Nnppn == N
- *   second node of a group: Npn != N && Nppnn == N
- *   n-1 node of a group:    Nnp != N && Nnnpp == N
- *   last node of a group:   Npn != N && Npnnp == N
- * 
- * The memory overhead is one pointer per bucket plus two pointers per node,
- * probably unbeatable. The resulting structure is bidirectonally traversable,
- * though currently we are just providing forward iteration.
- */
-
-template<typename Allocator>
-struct hashed_index_node_impl;
-
-/* half-header (only prior() pointer) to use for the bucket array */
-
-template<typename Allocator>
-struct hashed_index_base_node_impl
-{
-  typedef typename
-  boost::detail::allocator::rebind_to<
-      Allocator,hashed_index_base_node_impl
-  >::type::pointer                          base_pointer;
-  typedef typename
-  boost::detail::allocator::rebind_to<
-    Allocator,hashed_index_base_node_impl
-  >::type::const_pointer                    const_base_pointer;
-  typedef typename
-  boost::detail::allocator::rebind_to<
-    Allocator,
-    hashed_index_node_impl<Allocator>
-  >::type::pointer                          pointer;
-  typedef typename
-  boost::detail::allocator::rebind_to<
-    Allocator,
-    hashed_index_node_impl<Allocator>
-  >::type::const_pointer                    const_pointer;
-
-  pointer& prior(){return prior_;}
-  pointer  prior()const{return prior_;}
-
-private:
-  pointer prior_;
-};
-
-/* full header (prior() and next()) for the nodes */
-
-template<typename Allocator>
-struct hashed_index_node_impl:hashed_index_base_node_impl<Allocator>
-{
-private:
-  typedef hashed_index_base_node_impl<Allocator> super;
-
-public:  
-  typedef typename super::base_pointer           base_pointer;
-  typedef typename super::const_base_pointer     const_base_pointer;
-  typedef typename super::pointer                pointer;
-  typedef typename super::const_pointer          const_pointer;
-
-  base_pointer& next(){return next_;}
-  base_pointer  next()const{return next_;}
-
-  static pointer pointer_from(base_pointer x)
-  {
-    return static_cast<pointer>(
-      static_cast<hashed_index_node_impl*>(
-        raw_ptr<super*>(x)));
-  }
-
-  static base_pointer base_pointer_from(pointer x)
-  {
-    return static_cast<base_pointer>(
-      raw_ptr<hashed_index_node_impl*>(x));
-  }
-
-private:
-  base_pointer next_;
-};
-
-/* Boost.MultiIndex requires machinery to reverse unlink operations. A simple
- * way to make a pointer-manipulation function undoable is to templatize
- * its internal pointer assignments with a functor that, besides doing the
- * assignment, keeps track of the original pointer values and can later undo
- * the operations in reverse order.
- */
-
-struct default_assigner
-{
-  template<typename T> void operator()(T& x,const T& val){x=val;}
-};
-
-template<typename Node>
-struct unlink_undo_assigner
-{
-  typedef typename Node::base_pointer base_pointer;
-  typedef typename Node::pointer      pointer;
-
-  unlink_undo_assigner():pointer_track_count(0),base_pointer_track_count(0){}
-
-  void operator()(pointer& x,pointer val)
-  {
-    pointer_tracks[pointer_track_count].x=&x;
-    pointer_tracks[pointer_track_count++].val=x;
-    x=val;
-  }
-
-  void operator()(base_pointer& x,base_pointer val)
-  {
-    base_pointer_tracks[base_pointer_track_count].x=&x;
-    base_pointer_tracks[base_pointer_track_count++].val=x;
-    x=val;
-  }
-
-  void operator()() /* undo op */
-  {
-    /* in the absence of aliasing, restitution order is immaterial */
-
-    while(pointer_track_count--){
-      *(pointer_tracks[pointer_track_count].x)=
-        pointer_tracks[pointer_track_count].val;
-    }
-    while(base_pointer_track_count--){
-      *(base_pointer_tracks[base_pointer_track_count].x)=
-        base_pointer_tracks[base_pointer_track_count].val;
-    }
-  }
-
-  struct pointer_track     {pointer*      x; pointer      val;};
-  struct base_pointer_track{base_pointer* x; base_pointer val;};
-
-  /* We know the maximum number of pointer and base pointer assignments that
-   * the two unlink versions do, so we can statically reserve the needed
-   * storage.
-   */
-
-  pointer_track      pointer_tracks[3];
-  int                pointer_track_count;
-  base_pointer_track base_pointer_tracks[2];
-  int                base_pointer_track_count;
-};
-
-/* algorithmic stuff for unique and non-unique variants */
-
-struct hashed_unique_tag{};
-struct hashed_non_unique_tag{};
-
-template<typename Node,typename Category>
-struct hashed_index_node_alg;
-
-template<typename Node>
-struct hashed_index_node_alg<Node,hashed_unique_tag>
-{
-  typedef typename Node::base_pointer       base_pointer;
-  typedef typename Node::const_base_pointer const_base_pointer;
-  typedef typename Node::pointer            pointer;
-  typedef typename Node::const_pointer      const_pointer;
-
-  static bool is_first_of_bucket(pointer x)
-  {
-    return x->prior()->next()!=base_pointer_from(x);
-  }
-
-  static pointer after(pointer x)
-  {
-    return is_last_of_bucket(x)?x->next()->prior():pointer_from(x->next());
-  }
-
-  static pointer after_local(pointer x)
-  {
-    return is_last_of_bucket(x)?pointer(0):pointer_from(x->next());
-  }
-
-  static pointer next_to_inspect(pointer x)
-  {
-    return is_last_of_bucket(x)?pointer(0):pointer_from(x->next());
-  }
-
-  static void link(pointer x,base_pointer buc,pointer end)
-  {
-    if(buc->prior()==pointer(0)){ /* empty bucket */
-      x->prior()=end->prior();
-      x->next()=end->prior()->next();
-      x->prior()->next()=buc;
-      buc->prior()=x;
-      end->prior()=x;
-    }
-    else{
-      x->prior()=buc->prior()->prior();
-      x->next()=base_pointer_from(buc->prior());
-      buc->prior()=x;
-      x->next()->prior()=x;
-    }
-  }
-
-  static void unlink(pointer x)
-  {
-    default_assigner assign;
-    unlink(x,assign);
-  }
-
-  typedef unlink_undo_assigner<Node> unlink_undo;
-
-  template<typename Assigner>
-  static void unlink(pointer x,Assigner& assign)
-  {
-    if(is_first_of_bucket(x)){
-      if(is_last_of_bucket(x)){
-        assign(x->prior()->next()->prior(),pointer(0));
-        assign(x->prior()->next(),x->next());
-        assign(x->next()->prior()->prior(),x->prior());
-      }
-      else{
-        assign(x->prior()->next()->prior(),pointer_from(x->next()));
-        assign(x->next()->prior(),x->prior());
-      }
-    }
-    else if(is_last_of_bucket(x)){
-      assign(x->prior()->next(),x->next());
-      assign(x->next()->prior()->prior(),x->prior());
-    }
-    else{
-      assign(x->prior()->next(),x->next());
-      assign(x->next()->prior(),x->prior());
-    }
-  }
-
-  /* used only at rehashing */
-
-  static void append(pointer x,pointer end)
-  {
-    x->prior()=end->prior();
-    x->next()=end->prior()->next();
-    x->prior()->next()=base_pointer_from(x);
-    end->prior()=x;
-  }
-
-  static bool unlink_last(pointer end)
-  {
-    /* returns true iff bucket is emptied */
-
-    pointer x=end->prior();
-    if(x->prior()->next()==base_pointer_from(x)){
-      x->prior()->next()=x->next();
-      end->prior()=x->prior();
-      return false;
-    }
-    else{
-      x->prior()->next()->prior()=pointer(0);
-      x->prior()->next()=x->next();
-      end->prior()=x->prior();
-      return true;
-    }
-  }
-
-private:
-  static pointer pointer_from(base_pointer x)
-  {
-    return Node::pointer_from(x);
-  }
-
-  static base_pointer base_pointer_from(pointer x)
-  {
-    return Node::base_pointer_from(x);
-  }
-
-  static bool is_last_of_bucket(pointer x)
-  {
-    return x->next()->prior()!=x;
-  }
-};
-
-template<typename Node>
-struct hashed_index_node_alg<Node,hashed_non_unique_tag>
-{
-  typedef typename Node::base_pointer       base_pointer;
-  typedef typename Node::const_base_pointer const_base_pointer;
-  typedef typename Node::pointer            pointer;
-  typedef typename Node::const_pointer      const_pointer;
-
-  static bool is_first_of_bucket(pointer x)
-  {
-    return x->prior()->next()->prior()==x;
-  }
-
-  static bool is_first_of_group(pointer x)
-  {
-    return
-      x->next()->prior()!=x&&
-      x->next()->prior()->prior()->next()==base_pointer_from(x);
-  }
-
-  static pointer after(pointer x)
-  {
-    if(x->next()->prior()==x)return pointer_from(x->next());
-    if(x->next()->prior()->prior()==x)return x->next()->prior();
-    if(x->next()->prior()->prior()->next()==base_pointer_from(x))
-      return pointer_from(x->next());
-    return pointer_from(x->next())->next()->prior();
-  }
-
-  static pointer after_local(pointer x)
-  {
-    if(x->next()->prior()==x)return pointer_from(x->next());
-    if(x->next()->prior()->prior()==x)return pointer(0);
-    if(x->next()->prior()->prior()->next()==base_pointer_from(x))
-      return pointer_from(x->next());
-    return pointer_from(x->next())->next()->prior();
-  }
-
-  static pointer next_to_inspect(pointer x)
-  {
-    if(x->next()->prior()==x)return pointer_from(x->next());
-    if(x->next()->prior()->prior()==x)return pointer(0);
-    if(x->next()->prior()->next()->prior()!=x->next()->prior())
-      return pointer(0);
-    return pointer_from(x->next()->prior()->next());
-  }
-
-  static void link(pointer x,base_pointer buc,pointer end)
-  {
-    if(buc->prior()==pointer(0)){ /* empty bucket */
-      x->prior()=end->prior();
-      x->next()=end->prior()->next();
-      x->prior()->next()=buc;
-      buc->prior()=x;
-      end->prior()=x;
-    }
-    else{
-      x->prior()=buc->prior()->prior();
-      x->next()=base_pointer_from(buc->prior());
-      buc->prior()=x;
-      x->next()->prior()=x;
-    }
-  };
-
-  static void link(pointer x,pointer first,pointer last)
-  {
-    x->prior()=first->prior();
-    x->next()=base_pointer_from(first);
-    if(is_first_of_bucket(first)){
-      x->prior()->next()->prior()=x;
-    }
-    else{
-      x->prior()->next()=base_pointer_from(x);
-    }
-
-    if(first==last){
-      last->prior()=x;
-    }
-    else if(first->next()==base_pointer_from(last)){
-      first->prior()=last;
-      first->next()=base_pointer_from(x);
-    }
-    else{
-      pointer second=pointer_from(first->next()),
-              lastbutone=last->prior();
-      second->prior()=first;
-      first->prior()=last;
-      lastbutone->next()=base_pointer_from(x);
-    }
-  }
-
-  static void unlink(pointer x)
-  {
-    default_assigner assign;
-    unlink(x,assign);
-  }
-
-  typedef unlink_undo_assigner<Node> unlink_undo;
-
-  template<typename Assigner>
-  static void unlink(pointer x,Assigner& assign)
-  {
-    if(x->prior()->next()==base_pointer_from(x)){
-      if(x->next()->prior()==x){
-        left_unlink(x,assign);
-        right_unlink(x,assign);
-      }
-      else if(x->next()->prior()->prior()==x){           /* last of bucket */
-        left_unlink(x,assign);
-        right_unlink_last_of_bucket(x,assign);
-      }
-      else if(x->next()->prior()->prior()->next()==
-              base_pointer_from(x)){                /* first of group size */
-        left_unlink(x,assign);
-        right_unlink_first_of_group(x,assign);
-      }
-      else{                                                /* n-1 of group */
-        unlink_last_but_one_of_group(x,assign);
-      }
-    }
-    else if(x->prior()->next()->prior()==x){            /* first of bucket */
-      if(x->next()->prior()==x){
-        left_unlink_first_of_bucket(x,assign);
-        right_unlink(x,assign);
-      }
-      else if(x->next()->prior()->prior()==x){           /* last of bucket */
-        assign(x->prior()->next()->prior(),pointer(0));
-        assign(x->prior()->next(),x->next());
-        assign(x->next()->prior()->prior(),x->prior());
-      }
-      else{                                              /* first of group */
-        left_unlink_first_of_bucket(x,assign);
-        right_unlink_first_of_group(x,assign);
-      }
-    }
-    else if(x->next()->prior()->prior()==x){   /* last of group and bucket */
-      left_unlink_last_of_group(x,assign);
-      right_unlink_last_of_bucket(x,assign);
-    }
-    else if(pointer_from(x->prior()->prior()->next())
-            ->next()==base_pointer_from(x)){            /* second of group */
-      unlink_second_of_group(x,assign);
-    }
-    else{                              /* last of group, ~(last of bucket) */
-      left_unlink_last_of_group(x,assign);
-      right_unlink(x,assign);
-    }
-  }
-
-  /* used only at rehashing */
-
-  static void link_range(
-    pointer first,pointer last,base_pointer buc,pointer cend)
-  {
-    if(buc->prior()==pointer(0)){ /* empty bucket */
-      first->prior()=cend->prior();
-      last->next()=cend->prior()->next();
-      first->prior()->next()=buc;
-      buc->prior()=first;
-      cend->prior()=last;
-    }
-    else{
-      first->prior()=buc->prior()->prior();
-      last->next()=base_pointer_from(buc->prior());
-      buc->prior()=first;
-      last->next()->prior()=last;
-    }
-  }
-
-  static void append_range(pointer first,pointer last,pointer cend)
-  {
-    first->prior()=cend->prior();
-    last->next()=cend->prior()->next();
-    first->prior()->next()=base_pointer_from(first);
-    cend->prior()=last;
-  }
-
-  static std::pair<pointer,bool> unlink_last_group(pointer end)
-  {
-    /* returns first of group true iff bucket is emptied */
-
-    pointer x=end->prior();
-    if(x->prior()->next()==base_pointer_from(x)){
-      x->prior()->next()=x->next();
-      end->prior()=x->prior();
-      return std::make_pair(x,false);
-    }
-    else if(x->prior()->next()->prior()==x){
-      x->prior()->next()->prior()=pointer(0);
-      x->prior()->next()=x->next();
-      end->prior()=x->prior();
-      return std::make_pair(x,true);
-    }
-    else{
-      pointer y=pointer_from(x->prior()->next());
-
-      if(y->prior()->next()==base_pointer_from(y)){
-        y->prior()->next()=x->next();
-        end->prior()=y->prior();
-        return std::make_pair(y,false);
-      }
-      else{
-        y->prior()->next()->prior()=pointer(0);
-        y->prior()->next()=x->next();
-        end->prior()=y->prior();
-        return std::make_pair(y,true);
-      }
-    }
-  }
-
-  static void unlink_range(pointer first,pointer last)
-  {
-    if(is_first_of_bucket(first)){
-      if(is_last_of_bucket(last)){
-        first->prior()->next()->prior()=pointer(0);
-        first->prior()->next()=last->next();
-        last->next()->prior()->prior()=first->prior();
-      }
-      else{
-        first->prior()->next()->prior()=pointer_from(last->next());
-        last->next()->prior()=first->prior();
-      }
-    }
-    else if(is_last_of_bucket(last)){
-      first->prior()->next()=last->next();
-      last->next()->prior()->prior()=first->prior();
-    }
-    else{
-      first->prior()->next()=last->next();
-      last->next()->prior()=first->prior();
-    }
-  }
-
-private:
-  static pointer pointer_from(base_pointer x)
-  {
-    return Node::pointer_from(x);
-  }
-
-  static base_pointer base_pointer_from(pointer x)
-  {
-    return Node::base_pointer_from(x);
-  }
-
-  static bool is_last_of_bucket(pointer x)
-  {
-    return x->next()->prior()->prior()==x;
-  }
-
-  template<typename Assigner>
-  static void left_unlink(pointer x,Assigner& assign)
-  {
-    assign(x->prior()->next(),x->next());
-  }
-  
-  template<typename Assigner>
-  static void right_unlink(pointer x,Assigner& assign)
-  {
-    assign(x->next()->prior(),x->prior());
-  }
-
-  template<typename Assigner>
-  static void left_unlink_first_of_bucket(pointer x,Assigner& assign)
-  {
-    assign(x->prior()->next()->prior(),pointer_from(x->next()));
-  }
-
-  template<typename Assigner>
-  static void right_unlink_last_of_bucket(pointer x,Assigner& assign)
-  {
-    assign(x->next()->prior()->prior(),x->prior());
-  }
-
-  template<typename Assigner>
-  static void right_unlink_first_of_group(pointer x,Assigner& assign)
-  {
-    pointer second=pointer_from(x->next()),
-            last=second->prior(),
-            lastbutone=last->prior();
-    if(second==lastbutone){
-      assign(second->next(),base_pointer_from(last));
-      assign(second->prior(),x->prior());
-    }
-    else{
-      assign(lastbutone->next(),base_pointer_from(second));
-      assign(second->next()->prior(),last);
-      assign(second->prior(),x->prior());
-    }
-  }
-
-  template<typename Assigner>
-  static void left_unlink_last_of_group(pointer x,Assigner& assign)
-  {
-    pointer lastbutone=x->prior(),
-            first=pointer_from(lastbutone->next()),
-            second=pointer_from(first->next());
-    if(lastbutone==second){
-      assign(lastbutone->prior(),first);
-      assign(lastbutone->next(),x->next());
-    }
-    else{
-      assign(second->prior(),lastbutone);
-      assign(lastbutone->prior()->next(),base_pointer_from(first));
-      assign(lastbutone->next(),x->next());
-    }
-  }
-
-  template<typename Assigner>
-  static void unlink_last_but_one_of_group(pointer x,Assigner& assign)
-  {
-    pointer first=pointer_from(x->next()),
-            second=pointer_from(first->next()),
-            last=second->prior();
-    if(second==x){
-      assign(last->prior(),first);
-      assign(first->next(),base_pointer_from(last));
-    }
-    else{
-      assign(last->prior(),x->prior());
-      assign(x->prior()->next(),base_pointer_from(first));
-    }
-  }
-
-  template<typename Assigner>
-  static void unlink_second_of_group(pointer x,Assigner& assign)
-  {
-    pointer last=x->prior(),
-            lastbutone=last->prior(),
-            first=pointer_from(lastbutone->next());
-    if(lastbutone==x){
-      assign(first->next(),base_pointer_from(last));
-      assign(last->prior(),first);
-    }
-    else{
-      assign(first->next(),x->next());
-      assign(x->next()->prior(),last);
-    }
-  }
-};
-
-template<typename Super>
-struct hashed_index_node_trampoline:
-  hashed_index_node_impl<
-    typename boost::detail::allocator::rebind_to<
-      typename Super::allocator_type,
-      char
-    >::type
-  >
-{
-  typedef typename boost::detail::allocator::rebind_to<
-    typename Super::allocator_type,
-    char
-  >::type                                               impl_allocator_type;
-  typedef hashed_index_node_impl<impl_allocator_type>   impl_type;
-};
-
-template<typename Super,typename Category>
-struct hashed_index_node:
-  Super,hashed_index_node_trampoline<Super>
-{
-private:
-  typedef hashed_index_node_trampoline<Super> trampoline;
-
-public:
-  typedef typename trampoline::impl_type          impl_type;
-  typedef hashed_index_node_alg<
-    impl_type,Category>                           node_alg;
-  typedef typename trampoline::base_pointer       impl_base_pointer;
-  typedef typename trampoline::const_base_pointer const_impl_base_pointer;
-  typedef typename trampoline::pointer            impl_pointer;
-  typedef typename trampoline::const_pointer      const_impl_pointer;
-
-  impl_pointer&      prior(){return trampoline::prior();}
-  impl_pointer       prior()const{return trampoline::prior();}
-  impl_base_pointer& next(){return trampoline::next();}
-  impl_base_pointer  next()const{return trampoline::next();}
-
-  impl_pointer impl()
-  {
-    return static_cast<impl_pointer>(
-      static_cast<impl_type*>(static_cast<trampoline*>(this)));
-  }
-
-  const_impl_pointer impl()const
-  {
-    return static_cast<const_impl_pointer>(
-      static_cast<const impl_type*>(static_cast<const trampoline*>(this)));
-  }
-
-  static hashed_index_node* from_impl(impl_pointer x)
-  {
-    return
-      static_cast<hashed_index_node*>(
-        static_cast<trampoline*>(
-          raw_ptr<impl_type*>(x)));
-  }
-
-  static const hashed_index_node* from_impl(const_impl_pointer x)
-  {
-    return 
-      static_cast<const hashed_index_node*>(
-        static_cast<const trampoline*>(
-          raw_ptr<const impl_type*>(x)));
-  }
-
-  /* interoperability with hashed_index_iterator */
-
-  static void increment(hashed_index_node*& x)
-  {
-    x=from_impl(node_alg::after(x->impl()));
-  }
-
-  static void increment_local(hashed_index_node*& x)
-  {
-    x=from_impl(node_alg::after_local(x->impl()));
-  }
-};
-
-} /* namespace multi_index::detail */
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/header_holder.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/header_holder.hpp
deleted file mode 100644
index ca8a9b2edb1..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/header_holder.hpp
+++ /dev/null
@@ -1,50 +0,0 @@
-/* Copyright 2003-2008 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_DETAIL_HEADER_HOLDER_HPP
-#define BOOST_MULTI_INDEX_DETAIL_HEADER_HOLDER_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/noncopyable.hpp>
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-/* A utility class used to hold a pointer to the header node.
- * The base from member idiom is used because index classes, which are
- * superclasses of multi_index_container, need this header in construction
- * time. The allocation is made by the allocator of the multi_index_container
- * class --hence, this allocator needs also be stored resorting
- * to the base from member trick.
- */
-
-template<typename NodeTypePtr,typename Final>
-struct header_holder:private noncopyable
-{
-  header_holder():member(final().allocate_node()){}
-  ~header_holder(){final().deallocate_node(&*member);}
-
-  NodeTypePtr member;
-
-private:
-  Final& final(){return *static_cast<Final*>(this);}
-};
-
-} /* namespace multi_index::detail */
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/ignore_wstrict_aliasing.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/ignore_wstrict_aliasing.hpp
deleted file mode 100644
index ae398456d1f..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/ignore_wstrict_aliasing.hpp
+++ /dev/null
@@ -1,18 +0,0 @@
-/* Copyright 2003-2016 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#include <boost/config.hpp>
-
-#if defined(BOOST_GCC)&&(BOOST_GCC>=4*10000+6*100)
-#if !defined(BOOST_MULTI_INDEX_DETAIL_RESTORE_WSTRICT_ALIASING)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wstrict-aliasing"
-#else
-#pragma GCC diagnostic pop
-#endif
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/index_base.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/index_base.hpp
deleted file mode 100644
index 99000ed4813..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/index_base.hpp
+++ /dev/null
@@ -1,293 +0,0 @@
-/* Copyright 2003-2014 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_DETAIL_INDEX_BASE_HPP
-#define BOOST_MULTI_INDEX_DETAIL_INDEX_BASE_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <boost/detail/allocator_utilities.hpp>
-#include <boost/detail/no_exceptions_support.hpp>
-#include <boost/detail/workaround.hpp>
-#include <boost/move/core.hpp>
-#include <boost/move/utility.hpp>
-#include <boost/mpl/vector.hpp>
-#include <boost/multi_index/detail/copy_map.hpp>
-#include <boost/multi_index/detail/do_not_copy_elements_tag.hpp>
-#include <boost/multi_index/detail/node_type.hpp>
-#include <boost/multi_index/detail/vartempl_support.hpp>
-#include <boost/multi_index_container_fwd.hpp>
-#include <boost/tuple/tuple.hpp>
-#include <utility>
-
-#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
-#include <boost/multi_index/detail/index_loader.hpp>
-#include <boost/multi_index/detail/index_saver.hpp>
-#endif
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-/* The role of this class is threefold:
- *   - tops the linear hierarchy of indices.
- *   - terminates some cascading backbone function calls (insert_, etc.),
- *   - grants access to the backbone functions of the final
- *     multi_index_container class (for access restriction reasons, these
- *     cannot be called directly from the index classes.)
- */
-
-struct lvalue_tag{};
-struct rvalue_tag{};
-struct emplaced_tag{};
-
-template<typename Value,typename IndexSpecifierList,typename Allocator>
-class index_base
-{
-protected:
-  typedef index_node_base<Value,Allocator>    node_type;
-  typedef typename multi_index_node_type<
-    Value,IndexSpecifierList,Allocator>::type final_node_type;
-  typedef multi_index_container<
-    Value,IndexSpecifierList,Allocator>       final_type;
-  typedef tuples::null_type                   ctor_args_list;
-  typedef typename 
-  boost::detail::allocator::rebind_to<
-    Allocator,
-    typename Allocator::value_type
-  >::type                                     final_allocator_type;
-  typedef mpl::vector0<>                      index_type_list;
-  typedef mpl::vector0<>                      iterator_type_list;
-  typedef mpl::vector0<>                      const_iterator_type_list;
-  typedef copy_map<
-    final_node_type,
-    final_allocator_type>                     copy_map_type;
-
-#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
-  typedef index_saver<
-    node_type,
-    final_allocator_type>                     index_saver_type;
-  typedef index_loader<
-    node_type,
-    final_node_type,
-    final_allocator_type>                     index_loader_type;
-#endif
-
-private:
-  typedef Value                               value_type;
-
-protected:
-  explicit index_base(const ctor_args_list&,const Allocator&){}
-
-  index_base(
-    const index_base<Value,IndexSpecifierList,Allocator>&,
-    do_not_copy_elements_tag)
-  {}
-
-  void copy_(
-    const index_base<Value,IndexSpecifierList,Allocator>&,const copy_map_type&)
-  {}
-
-  final_node_type* insert_(const value_type& v,final_node_type*& x,lvalue_tag)
-  {
-    x=final().allocate_node();
-    BOOST_TRY{
-      boost::detail::allocator::construct(&x->value(),v);
-    }
-    BOOST_CATCH(...){
-      final().deallocate_node(x);
-      BOOST_RETHROW;
-    }
-    BOOST_CATCH_END
-    return x;
-  }
-
-  final_node_type* insert_(const value_type& v,final_node_type*& x,rvalue_tag)
-  {
-    x=final().allocate_node();
-    BOOST_TRY{
-      /* This shoud have used a modified, T&&-compatible version of
-       * boost::detail::allocator::construct, but 
-       * <boost/detail/allocator_utilities.hpp> is too old and venerable to
-       * mess with; besides, it is a general internal utility and the imperfect
-       * perfect forwarding emulation of Boost.Move might break other libs.
-       */
-
-      new (&x->value()) value_type(boost::move(const_cast<value_type&>(v)));
-    }
-    BOOST_CATCH(...){
-      final().deallocate_node(x);
-      BOOST_RETHROW;
-    }
-    BOOST_CATCH_END
-    return x;
-  }
-
-  final_node_type* insert_(const value_type&,final_node_type*& x,emplaced_tag)
-  {
-    return x;
-  }
-
-  final_node_type* insert_(
-    const value_type& v,node_type*,final_node_type*& x,lvalue_tag)
-  {
-    return insert_(v,x,lvalue_tag());
-  }
-
-  final_node_type* insert_(
-    const value_type& v,node_type*,final_node_type*& x,rvalue_tag)
-  {
-    return insert_(v,x,rvalue_tag());
-  }
-
-  final_node_type* insert_(
-    const value_type&,node_type*,final_node_type*& x,emplaced_tag)
-  {
-    return x;
-  }
-
-  void erase_(node_type* x)
-  {
-    boost::detail::allocator::destroy(&x->value());
-  }
-
-  void delete_node_(node_type* x)
-  {
-    boost::detail::allocator::destroy(&x->value());
-  }
-
-  void clear_(){}
-
-  void swap_(index_base<Value,IndexSpecifierList,Allocator>&){}
-
-  void swap_elements_(index_base<Value,IndexSpecifierList,Allocator>&){}
-
-  bool replace_(const value_type& v,node_type* x,lvalue_tag)
-  {
-    x->value()=v;
-    return true;
-  }
-
-  bool replace_(const value_type& v,node_type* x,rvalue_tag)
-  {
-    x->value()=boost::move(const_cast<value_type&>(v));
-    return true;
-  }
-
-  bool modify_(node_type*){return true;}
-
-  bool modify_rollback_(node_type*){return true;}
-
-#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
-  /* serialization */
-
-  template<typename Archive>
-  void save_(Archive&,const unsigned int,const index_saver_type&)const{}
-
-  template<typename Archive>
-  void load_(Archive&,const unsigned int,const index_loader_type&){}
-#endif
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING)
-  /* invariant stuff */
-
-  bool invariant_()const{return true;}
-#endif
-
-  /* access to backbone memfuns of Final class */
-
-  final_type&       final(){return *static_cast<final_type*>(this);}
-  const final_type& final()const{return *static_cast<const final_type*>(this);}
-
-  final_node_type* final_header()const{return final().header();}
-
-  bool        final_empty_()const{return final().empty_();}
-  std::size_t final_size_()const{return final().size_();}
-  std::size_t final_max_size_()const{return final().max_size_();}
-
-  std::pair<final_node_type*,bool> final_insert_(const value_type& x)
-    {return final().insert_(x);}
-  std::pair<final_node_type*,bool> final_insert_rv_(const value_type& x)
-    {return final().insert_rv_(x);}
-  template<typename T>
-  std::pair<final_node_type*,bool> final_insert_ref_(const T& t)
-    {return final().insert_ref_(t);}
-  template<typename T>
-  std::pair<final_node_type*,bool> final_insert_ref_(T& t)
-    {return final().insert_ref_(t);}
-
-  template<BOOST_MULTI_INDEX_TEMPLATE_PARAM_PACK>
-  std::pair<final_node_type*,bool> final_emplace_(
-    BOOST_MULTI_INDEX_FUNCTION_PARAM_PACK)
-  {
-    return final().emplace_(BOOST_MULTI_INDEX_FORWARD_PARAM_PACK);
-  }
-
-  std::pair<final_node_type*,bool> final_insert_(
-    const value_type& x,final_node_type* position)
-    {return final().insert_(x,position);}
-  std::pair<final_node_type*,bool> final_insert_rv_(
-    const value_type& x,final_node_type* position)
-    {return final().insert_rv_(x,position);}
-  template<typename T>
-  std::pair<final_node_type*,bool> final_insert_ref_(
-    const T& t,final_node_type* position)
-    {return final().insert_ref_(t,position);}
-  template<typename T>
-  std::pair<final_node_type*,bool> final_insert_ref_(
-    T& t,final_node_type* position)
-    {return final().insert_ref_(t,position);}
-
-  template<BOOST_MULTI_INDEX_TEMPLATE_PARAM_PACK>
-  std::pair<final_node_type*,bool> final_emplace_hint_(
-    final_node_type* position,BOOST_MULTI_INDEX_FUNCTION_PARAM_PACK)
-  {
-    return final().emplace_hint_(
-      position,BOOST_MULTI_INDEX_FORWARD_PARAM_PACK);
-  }
-
-  void final_erase_(final_node_type* x){final().erase_(x);}
-
-  void final_delete_node_(final_node_type* x){final().delete_node_(x);}
-  void final_delete_all_nodes_(){final().delete_all_nodes_();}
-  void final_clear_(){final().clear_();}
-
-  void final_swap_(final_type& x){final().swap_(x);}
-
-  bool final_replace_(
-    const value_type& k,final_node_type* x)
-    {return final().replace_(k,x);}
-  bool final_replace_rv_(
-    const value_type& k,final_node_type* x)
-    {return final().replace_rv_(k,x);}
-
-  template<typename Modifier>
-  bool final_modify_(Modifier& mod,final_node_type* x)
-    {return final().modify_(mod,x);}
-
-  template<typename Modifier,typename Rollback>
-  bool final_modify_(Modifier& mod,Rollback& back,final_node_type* x)
-    {return final().modify_(mod,back,x);}
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING)
-  void final_check_invariant_()const{final().check_invariant_();}
-#endif
-};
-
-} /* namespace multi_index::detail */
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/index_loader.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/index_loader.hpp
deleted file mode 100644
index 71418a10e19..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/index_loader.hpp
+++ /dev/null
@@ -1,139 +0,0 @@
-/* Copyright 2003-2015 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_DETAIL_INDEX_LOADER_HPP
-#define BOOST_MULTI_INDEX_DETAIL_INDEX_LOADER_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <algorithm>
-#include <boost/archive/archive_exception.hpp>
-#include <boost/noncopyable.hpp>
-#include <boost/multi_index/detail/auto_space.hpp>
-#include <boost/multi_index/detail/raw_ptr.hpp>
-#include <boost/serialization/nvp.hpp>
-#include <boost/throw_exception.hpp> 
-#include <cstddef>
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-/* Counterpart of index_saver (check index_saver.hpp for serialization
- * details.)* multi_index_container is in charge of supplying the info about
- * the base sequence, and each index can subsequently load itself using the
- * const interface of index_loader.
- */
-
-template<typename Node,typename FinalNode,typename Allocator>
-class index_loader:private noncopyable
-{
-public:
-  index_loader(const Allocator& al,std::size_t size):
-    spc(al,size),size_(size),n(0),sorted(false)
-  {
-  }
-
-  template<class Archive>
-  void add(Node* node,Archive& ar,const unsigned int)
-  {
-    ar>>serialization::make_nvp("position",*node);
-    entries()[n++]=node;
-  }
-
-  template<class Archive>
-  void add_track(Node* node,Archive& ar,const unsigned int)
-  {
-    ar>>serialization::make_nvp("position",*node);
-  }
-
-  /* A rearranger is passed two nodes, and is expected to
-   * reposition the second after the first.
-   * If the first node is 0, then the second should be moved
-   * to the beginning of the sequence.
-   */
-
-  template<typename Rearranger,class Archive>
-  void load(Rearranger r,Archive& ar,const unsigned int)const
-  {
-    FinalNode* prev=unchecked_load_node(ar);
-    if(!prev)return;
-
-    if(!sorted){
-      std::sort(entries(),entries()+size_);
-      sorted=true;
-    }
-
-    check_node(prev);
-
-    for(;;){
-      for(;;){
-        FinalNode* node=load_node(ar);
-        if(!node)break;
-
-        if(node==prev)prev=0;
-        r(prev,node);
-
-        prev=node;
-      }
-      prev=load_node(ar);
-      if(!prev)break;
-    }
-  }
-
-private:
-  Node** entries()const{return raw_ptr<Node**>(spc.data());}
-
-  /* We try to delay sorting as much as possible just in case it
-   * is not necessary, hence this version of load_node.
-   */
-
-  template<class Archive>
-  FinalNode* unchecked_load_node(Archive& ar)const
-  {
-    Node* node=0;
-    ar>>serialization::make_nvp("pointer",node);
-    return static_cast<FinalNode*>(node);
-  }
-
-  template<class Archive>
-  FinalNode* load_node(Archive& ar)const
-  {
-    Node* node=0;
-    ar>>serialization::make_nvp("pointer",node);
-    check_node(node);
-    return static_cast<FinalNode*>(node);
-  }
-
-  void check_node(Node* node)const
-  {
-    if(node!=0&&!std::binary_search(entries(),entries()+size_,node)){
-      throw_exception(
-        archive::archive_exception(
-          archive::archive_exception::other_exception));
-    }
-  }
-
-  auto_space<Node*,Allocator> spc;
-  std::size_t                 size_;
-  std::size_t                 n;
-  mutable bool                sorted;
-};
-
-} /* namespace multi_index::detail */
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/index_matcher.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/index_matcher.hpp
deleted file mode 100644
index 34d1f9d5a8d..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/index_matcher.hpp
+++ /dev/null
@@ -1,249 +0,0 @@
-/* Copyright 2003-2015 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_DETAIL_INDEX_MATCHER_HPP
-#define BOOST_MULTI_INDEX_DETAIL_INDEX_MATCHER_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <algorithm>
-#include <boost/noncopyable.hpp>
-#include <boost/multi_index/detail/auto_space.hpp>
-#include <boost/multi_index/detail/raw_ptr.hpp>
-#include <cstddef>
-#include <functional>
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-/* index_matcher compares a sequence of elements against a
- * base sequence, identifying those elements that belong to the
- * longest subsequence which is ordered with respect to the base.
- * For instance, if the base sequence is:
- *
- *   0 1 2 3 4 5 6 7 8 9
- *
- * and the compared sequence (not necesarilly the same length):
- *
- *   1 4 2 3 0 7 8 9
- *
- * the elements of the longest ordered subsequence are:
- *
- *   1 2 3 7 8 9
- * 
- * The algorithm for obtaining such a subsequence is called
- * Patience Sorting, described in ch. 1 of:
- *   Aldous, D., Diaconis, P.: "Longest increasing subsequences: from
- *   patience sorting to the Baik-Deift-Johansson Theorem", Bulletin
- *   of the American Mathematical Society, vol. 36, no 4, pp. 413-432,
- *   July 1999.
- *   http://www.ams.org/bull/1999-36-04/S0273-0979-99-00796-X/
- *   S0273-0979-99-00796-X.pdf
- *
- * This implementation is not fully generic since it assumes that
- * the sequences given are pointed to by index iterators (having a
- * get_node() memfun.)
- */
-
-namespace index_matcher{
-
-/* The algorithm stores the nodes of the base sequence and a number
- * of "piles" that are dynamically updated during the calculation
- * stage. From a logical point of view, nodes form an independent
- * sequence from piles. They are stored together so as to minimize
- * allocated memory.
- */
-
-struct entry
-{
-  entry(void* node_,std::size_t pos_=0):node(node_),pos(pos_){}
-
-  /* node stuff */
-
-  void*       node;
-  std::size_t pos;
-  entry*      previous;
-  bool        ordered;
-
-  struct less_by_node
-  {
-    bool operator()(
-      const entry& x,const entry& y)const
-    {
-      return std::less<void*>()(x.node,y.node);
-    }
-  };
-
-  /* pile stuff */
-
-  std::size_t pile_top;
-  entry*      pile_top_entry;
-
-  struct less_by_pile_top
-  {
-    bool operator()(
-      const entry& x,const entry& y)const
-    {
-      return x.pile_top<y.pile_top;
-    }
-  };
-};
-
-/* common code operating on void *'s */
-
-template<typename Allocator>
-class algorithm_base:private noncopyable
-{
-protected:
-  algorithm_base(const Allocator& al,std::size_t size):
-    spc(al,size),size_(size),n_(0),sorted(false)
-  {
-  }
-
-  void add(void* node)
-  {
-    entries()[n_]=entry(node,n_);
-    ++n_;
-  }
-
-  void begin_algorithm()const
-  {
-    if(!sorted){
-      std::sort(entries(),entries()+size_,entry::less_by_node());
-      sorted=true;
-    }
-    num_piles=0;
-  }
-
-  void add_node_to_algorithm(void* node)const
-  {
-    entry* ent=
-      std::lower_bound(
-        entries(),entries()+size_,
-        entry(node),entry::less_by_node()); /* localize entry */
-    ent->ordered=false;
-    std::size_t n=ent->pos;                 /* get its position */
-
-    entry dummy(0);
-    dummy.pile_top=n;
-
-    entry* pile_ent=                        /* find the first available pile */
-      std::lower_bound(                     /* to stack the entry            */
-        entries(),entries()+num_piles,
-        dummy,entry::less_by_pile_top());
-
-    pile_ent->pile_top=n;                   /* stack the entry */
-    pile_ent->pile_top_entry=ent;        
-
-    /* if not the first pile, link entry to top of the preceding pile */
-    if(pile_ent>&entries()[0]){ 
-      ent->previous=(pile_ent-1)->pile_top_entry;
-    }
-
-    if(pile_ent==&entries()[num_piles]){    /* new pile? */
-      ++num_piles;
-    }
-  }
-
-  void finish_algorithm()const
-  {
-    if(num_piles>0){
-      /* Mark those elements which are in their correct position, i.e. those
-       * belonging to the longest increasing subsequence. These are those
-       * elements linked from the top of the last pile.
-       */
-
-      entry* ent=entries()[num_piles-1].pile_top_entry;
-      for(std::size_t n=num_piles;n--;){
-        ent->ordered=true;
-        ent=ent->previous;
-      }
-    }
-  }
-
-  bool is_ordered(void * node)const
-  {
-    return std::lower_bound(
-      entries(),entries()+size_,
-      entry(node),entry::less_by_node())->ordered;
-  }
-
-private:
-  entry* entries()const{return raw_ptr<entry*>(spc.data());}
-
-  auto_space<entry,Allocator> spc;
-  std::size_t                 size_;
-  std::size_t                 n_;
-  mutable bool                sorted;
-  mutable std::size_t         num_piles;
-};
-
-/* The algorithm has three phases:
- *   - Initialization, during which the nodes of the base sequence are added.
- *   - Execution.
- *   - Results querying, through the is_ordered memfun.
- */
-
-template<typename Node,typename Allocator>
-class algorithm:private algorithm_base<Allocator>
-{
-  typedef algorithm_base<Allocator> super;
-
-public:
-  algorithm(const Allocator& al,std::size_t size):super(al,size){}
-
-  void add(Node* node)
-  {
-    super::add(node);
-  }
-
-  template<typename IndexIterator>
-  void execute(IndexIterator first,IndexIterator last)const
-  {
-    super::begin_algorithm();
-
-    for(IndexIterator it=first;it!=last;++it){
-      add_node_to_algorithm(get_node(it));
-    }
-
-    super::finish_algorithm();
-  }
-
-  bool is_ordered(Node* node)const
-  {
-    return super::is_ordered(node);
-  }
-
-private:
-  void add_node_to_algorithm(Node* node)const
-  {
-    super::add_node_to_algorithm(node);
-  }
-
-  template<typename IndexIterator>
-  static Node* get_node(IndexIterator it)
-  {
-    return static_cast<Node*>(it.get_node());
-  }
-};
-
-} /* namespace multi_index::detail::index_matcher */
-
-} /* namespace multi_index::detail */
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/index_node_base.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/index_node_base.hpp
deleted file mode 100644
index 1a1f0cae4be..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/index_node_base.hpp
+++ /dev/null
@@ -1,135 +0,0 @@
-/* Copyright 2003-2016 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_DETAIL_INDEX_NODE_BASE_HPP
-#define BOOST_MULTI_INDEX_DETAIL_INDEX_NODE_BASE_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <boost/type_traits/aligned_storage.hpp>
-#include <boost/type_traits/alignment_of.hpp> 
-
-#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
-#include <boost/archive/archive_exception.hpp>
-#include <boost/serialization/access.hpp>
-#include <boost/throw_exception.hpp> 
-#endif
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-/* index_node_base tops the node hierarchy of multi_index_container. It holds
- * the value of the element contained.
- */
-
-template<typename Value>
-struct pod_value_holder
-{
-  typename aligned_storage<
-    sizeof(Value),
-    alignment_of<Value>::value
-  >::type                      space;
-};
-
-template<typename Value,typename Allocator>
-struct index_node_base:private pod_value_holder<Value>
-{
-  typedef index_node_base base_type; /* used for serialization purposes */
-  typedef Value           value_type;
-  typedef Allocator       allocator_type;
-
-#include <boost/multi_index/detail/ignore_wstrict_aliasing.hpp>
-
-  value_type& value()
-  {
-    return *reinterpret_cast<value_type*>(&this->space);
-  }
-
-  const value_type& value()const
-  {
-    return *reinterpret_cast<const value_type*>(&this->space);
-  }
-
-#include <boost/multi_index/detail/restore_wstrict_aliasing.hpp>
-
-  static index_node_base* from_value(const value_type* p)
-  {
-    return static_cast<index_node_base *>(
-      reinterpret_cast<pod_value_holder<Value>*>( /* std 9.2.17 */
-        const_cast<value_type*>(p))); 
-  }
-
-private:
-#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
-  friend class boost::serialization::access;
-  
-  /* nodes do not emit any kind of serialization info. They are
-   * fed to Boost.Serialization so that pointers to nodes are
-   * tracked correctly.
-   */
-
-  template<class Archive>
-  void serialize(Archive&,const unsigned int)
-  {
-  }
-#endif
-};
-
-template<typename Node,typename Value>
-Node* node_from_value(const Value* p)
-{
-  typedef typename Node::allocator_type allocator_type;
-  return static_cast<Node*>(
-    index_node_base<Value,allocator_type>::from_value(p));
-}
-
-} /* namespace multi_index::detail */
-
-} /* namespace multi_index */
-
-#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
-/* Index nodes never get constructed directly by Boost.Serialization,
- * as archives are always fed pointers to previously existent
- * nodes. So, if this is called it means we are dealing with a
- * somehow invalid archive.
- */
-
-#if defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)
-namespace serialization{
-#else
-namespace multi_index{
-namespace detail{
-#endif
-
-template<class Archive,typename Value,typename Allocator>
-inline void load_construct_data(
-  Archive&,boost::multi_index::detail::index_node_base<Value,Allocator>*,
-  const unsigned int)
-{
-  throw_exception(
-    archive::archive_exception(archive::archive_exception::other_exception));
-}
-
-#if defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)
-} /* namespace serialization */
-#else
-} /* namespace multi_index::detail */
-} /* namespace multi_index */
-#endif
-
-#endif
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/index_saver.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/index_saver.hpp
deleted file mode 100644
index ae09d4eba4f..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/index_saver.hpp
+++ /dev/null
@@ -1,135 +0,0 @@
-/* Copyright 2003-2013 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_DETAIL_INDEX_SAVER_HPP
-#define BOOST_MULTI_INDEX_DETAIL_INDEX_SAVER_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <boost/multi_index/detail/index_matcher.hpp>
-#include <boost/noncopyable.hpp>
-#include <boost/serialization/nvp.hpp>
-#include <cstddef>
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-/* index_saver accepts a base sequence of previously saved elements
- * and saves a possibly reordered subsequence in an efficient manner,
- * serializing only the information needed to rearrange the subsequence
- * based on the original order of the base.
- * multi_index_container is in charge of supplying the info about the
- * base sequence, and each index can subsequently save itself using the
- * const interface of index_saver.
- */
-
-template<typename Node,typename Allocator>
-class index_saver:private noncopyable
-{
-public:
-  index_saver(const Allocator& al,std::size_t size):alg(al,size){}
-
-  template<class Archive>
-  void add(Node* node,Archive& ar,const unsigned int)
-  {
-    ar<<serialization::make_nvp("position",*node);
-    alg.add(node);
-  }
-
-  template<class Archive>
-  void add_track(Node* node,Archive& ar,const unsigned int)
-  {
-    ar<<serialization::make_nvp("position",*node);
-  }
-
-  template<typename IndexIterator,class Archive>
-  void save(
-    IndexIterator first,IndexIterator last,Archive& ar,
-    const unsigned int)const
-  {
-    /* calculate ordered positions */
-
-    alg.execute(first,last);
-
-    /* Given a consecutive subsequence of displaced elements
-     * x1,...,xn, the following information is serialized:
-     *
-     *   p0,p1,...,pn,0
-     *
-     * where pi is a pointer to xi and p0 is a pointer to the element
-     * preceding x1. Crealy, from this information is possible to
-     * restore the original order on loading time. If x1 is the first
-     * element in the sequence, the following is serialized instead:
-     *
-     *   p1,p1,...,pn,0
-     *
-     * For each subsequence of n elements, n+2 pointers are serialized.
-     * An optimization policy is applied: consider for instance the
-     * sequence
-     *
-     *   a,B,c,D
-     * 
-     * where B and D are displaced, but c is in its correct position.
-     * Applying the schema described above we would serialize 6 pointers:
-     *
-     *  p(a),p(B),0
-     *  p(c),p(D),0
-     * 
-     * but this can be reduced to 5 pointers by treating c as a displaced
-     * element:
-     *
-     *  p(a),p(B),p(c),p(D),0
-     */
-
-    std::size_t last_saved=3; /* distance to last pointer saved */
-    for(IndexIterator it=first,prev=first;it!=last;prev=it++,++last_saved){
-      if(!alg.is_ordered(get_node(it))){
-        if(last_saved>1)save_node(get_node(prev),ar);
-        save_node(get_node(it),ar);
-        last_saved=0;
-      }
-      else if(last_saved==2)save_node(null_node(),ar);
-    }
-    if(last_saved<=2)save_node(null_node(),ar);
-
-    /* marks the end of the serialization info for [first,last) */
-
-    save_node(null_node(),ar);
-  }
-
-private:
-  template<typename IndexIterator>
-  static Node* get_node(IndexIterator it)
-  {
-    return it.get_node();
-  }
-
-  static Node* null_node(){return 0;}
-
-  template<typename Archive>
-  static void save_node(Node* node,Archive& ar)
-  {
-    ar<<serialization::make_nvp("pointer",node);
-  }
-
-  index_matcher::algorithm<Node,Allocator> alg;
-};
-
-} /* namespace multi_index::detail */
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/invariant_assert.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/invariant_assert.hpp
deleted file mode 100644
index c6c547c7c33..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/invariant_assert.hpp
+++ /dev/null
@@ -1,21 +0,0 @@
-/* Copyright 2003-2013 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_DETAIL_INVARIANT_ASSERT_HPP
-#define BOOST_MULTI_INDEX_DETAIL_INVARIANT_ASSERT_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#if !defined(BOOST_MULTI_INDEX_INVARIANT_ASSERT)
-#include <boost/assert.hpp>
-#define BOOST_MULTI_INDEX_INVARIANT_ASSERT BOOST_ASSERT
-#endif
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/is_index_list.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/is_index_list.hpp
deleted file mode 100644
index f6a24218b81..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/is_index_list.hpp
+++ /dev/null
@@ -1,40 +0,0 @@
-/* Copyright 2003-2013 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_DETAIL_IS_INDEX_LIST_HPP
-#define BOOST_MULTI_INDEX_DETAIL_IS_INDEX_LIST_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <boost/mpl/empty.hpp>
-#include <boost/mpl/is_sequence.hpp>
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-template<typename T>
-struct is_index_list
-{
-  BOOST_STATIC_CONSTANT(bool,mpl_sequence=mpl::is_sequence<T>::value);
-  BOOST_STATIC_CONSTANT(bool,non_empty=!mpl::empty<T>::value);
-  BOOST_STATIC_CONSTANT(bool,value=mpl_sequence&&non_empty);
-};
-
-} /* namespace multi_index::detail */
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/is_transparent.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/is_transparent.hpp
deleted file mode 100644
index 72036d257e2..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/is_transparent.hpp
+++ /dev/null
@@ -1,135 +0,0 @@
-/* Copyright 2003-2014 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_DETAIL_IS_TRANSPARENT_HPP
-#define BOOST_MULTI_INDEX_DETAIL_IS_TRANSPARENT_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <boost/mpl/bool.hpp>
-#include <boost/type_traits/intrinsics.hpp>
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-/* Metafunction that checks if f(arg,arg2) executes without argument type
- * conversion. By default (i.e. when it cannot be determined) it evaluates to
- * true.
- */
-
-template<typename F,typename Arg1,typename Arg2,typename=void>
-struct is_transparent:mpl::true_{};
-
-} /* namespace multi_index::detail */
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#if !defined(BOOST_NO_SFINAE)&&!defined(BOOST_NO_SFINAE_EXPR)&& \
-    !defined(BOOST_NO_CXX11_DECLTYPE)&& \
-    (defined(BOOST_NO_CXX11_FINAL)||defined(BOOST_IS_FINAL))
-
-#include <boost/mpl/and.hpp>
-#include <boost/mpl/not.hpp>
-#include <boost/mpl/or.hpp>
-#include <boost/type_traits/function_traits.hpp>
-#include <boost/type_traits/is_class.hpp>
-#include <boost/type_traits/is_final.hpp>
-#include <boost/type_traits/is_function.hpp>
-#include <boost/type_traits/is_same.hpp>
-#include <boost/type_traits/remove_pointer.hpp>
-#include <boost/utility/declval.hpp>
-#include <boost/utility/enable_if.hpp>
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-struct not_is_transparent_result_type{};
-
-template<typename F,typename Arg1,typename Arg2>
-struct is_transparent_class_helper:F
-{
-  using F::operator();
-  template<typename T,typename Q>
-  not_is_transparent_result_type operator()(const T&,const Q&)const;
-};
-
-template<typename F,typename Arg1,typename Arg2,typename=void>
-struct is_transparent_class:mpl::true_{};
-
-template<typename F,typename Arg1,typename Arg2>
-struct is_transparent_class<
-  F,Arg1,Arg2,
-  typename enable_if<
-    is_same<
-      decltype(
-        declval<const is_transparent_class_helper<F,Arg1,Arg2> >()(
-          declval<const Arg1&>(),declval<const Arg2&>())
-      ),
-      not_is_transparent_result_type
-    >
-  >::type
->:mpl::false_{};
-
-template<typename F,typename Arg1,typename Arg2>
-struct is_transparent<
-  F,Arg1,Arg2,
-  typename enable_if<
-    mpl::and_<
-      is_class<F>,
-      mpl::not_<is_final<F> > /* is_transparent_class_helper derives from F */
-    >
-  >::type
->:is_transparent_class<F,Arg1,Arg2>{};
-
-template<typename F,typename Arg1,typename Arg2,typename=void>
-struct is_transparent_function:mpl::true_{};
-
-template<typename F,typename Arg1,typename Arg2>
-struct is_transparent_function<
-  F,Arg1,Arg2,
-  typename enable_if<
-    mpl::or_<
-      mpl::not_<mpl::or_<
-        is_same<typename function_traits<F>::arg1_type,const Arg1&>,
-        is_same<typename function_traits<F>::arg1_type,Arg1>
-      > >,
-      mpl::not_<mpl::or_<
-        is_same<typename function_traits<F>::arg2_type,const Arg2&>,
-        is_same<typename function_traits<F>::arg2_type,Arg2>
-      > >
-    >
-  >::type
->:mpl::false_{};
-
-template<typename F,typename Arg1,typename Arg2>
-struct is_transparent<
-  F,Arg1,Arg2,
-  typename enable_if<
-    is_function<typename remove_pointer<F>::type>
-  >::type
->:is_transparent_function<typename remove_pointer<F>::type,Arg1,Arg2>{};
-
-} /* namespace multi_index::detail */
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/iter_adaptor.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/iter_adaptor.hpp
deleted file mode 100644
index 7a032350b36..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/iter_adaptor.hpp
+++ /dev/null
@@ -1,321 +0,0 @@
-/* Copyright 2003-2013 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_DETAIL_ITER_ADAPTOR_HPP
-#define BOOST_MULTI_INDEX_DETAIL_ITER_ADAPTOR_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <boost/mpl/apply.hpp>
-#include <boost/operators.hpp>
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-/* Poor man's version of boost::iterator_adaptor. Used instead of the
- * original as compile times for the latter are significantly higher.
- * The interface is not replicated exactly, only to the extent necessary
- * for internal consumption.
- */
-
-/* NB. The purpose of the (non-inclass) global operators ==, < and - defined
- * above is to partially alleviate a problem of MSVC++ 6.0 by * which
- * friend-injected operators on T are not visible if T is instantiated only
- * in template code where T is a dependent type.
- */
-
-class iter_adaptor_access
-{
-public:
-  template<class Class>
-    static typename Class::reference dereference(const Class& x)
-  {
-    return x.dereference();
-  }
-
-  template<class Class>
-  static bool equal(const Class& x,const Class& y)
-  {
-    return x.equal(y);
-  }
-
-  template<class Class>
-  static void increment(Class& x)
-  {
-    x.increment();
-  }
-
-  template<class Class>
-  static void decrement(Class& x)
-  {
-    x.decrement();
-  }
-
-  template<class Class>
-  static void advance(Class& x,typename Class::difference_type n)
-  {
-    x.advance(n);
-  }
-
-  template<class Class>
-  static typename Class::difference_type distance_to(
-    const Class& x,const Class& y)
-  {
-    return x.distance_to(y);
-  }
-};
-
-template<typename Category>
-struct iter_adaptor_selector;
-
-template<class Derived,class Base>
-class forward_iter_adaptor_base:
-  public forward_iterator_helper<
-    Derived,
-    typename Base::value_type,
-    typename Base::difference_type,
-    typename Base::pointer,
-    typename Base::reference>
-{
-public:
-  typedef typename Base::reference reference;
-
-  reference operator*()const
-  {
-    return iter_adaptor_access::dereference(final());
-  }
-
-  friend bool operator==(const Derived& x,const Derived& y)
-  {
-    return iter_adaptor_access::equal(x,y);
-  }
-
-  Derived& operator++()
-  {
-    iter_adaptor_access::increment(final());
-    return final();
-  }
-
-private:
-  Derived& final(){return *static_cast<Derived*>(this);}
-  const Derived& final()const{return *static_cast<const Derived*>(this);}
-};
-
-template<class Derived,class Base>
-bool operator==(
-  const forward_iter_adaptor_base<Derived,Base>& x,
-  const forward_iter_adaptor_base<Derived,Base>& y)
-{
-  return iter_adaptor_access::equal(
-    static_cast<const Derived&>(x),static_cast<const Derived&>(y));
-}
-
-template<>
-struct iter_adaptor_selector<std::forward_iterator_tag>
-{
-  template<class Derived,class Base>
-  struct apply
-  {
-    typedef forward_iter_adaptor_base<Derived,Base> type;
-  };
-};
-
-template<class Derived,class Base>
-class bidirectional_iter_adaptor_base:
-  public bidirectional_iterator_helper<
-    Derived,
-    typename Base::value_type,
-    typename Base::difference_type,
-    typename Base::pointer,
-    typename Base::reference>
-{
-public:
-  typedef typename Base::reference reference;
-
-  reference operator*()const
-  {
-    return iter_adaptor_access::dereference(final());
-  }
-
-  friend bool operator==(const Derived& x,const Derived& y)
-  {
-    return iter_adaptor_access::equal(x,y);
-  }
-
-  Derived& operator++()
-  {
-    iter_adaptor_access::increment(final());
-    return final();
-  }
-
-  Derived& operator--()
-  {
-    iter_adaptor_access::decrement(final());
-    return final();
-  }
-
-private:
-  Derived& final(){return *static_cast<Derived*>(this);}
-  const Derived& final()const{return *static_cast<const Derived*>(this);}
-};
-
-template<class Derived,class Base>
-bool operator==(
-  const bidirectional_iter_adaptor_base<Derived,Base>& x,
-  const bidirectional_iter_adaptor_base<Derived,Base>& y)
-{
-  return iter_adaptor_access::equal(
-    static_cast<const Derived&>(x),static_cast<const Derived&>(y));
-}
-
-template<>
-struct iter_adaptor_selector<std::bidirectional_iterator_tag>
-{
-  template<class Derived,class Base>
-  struct apply
-  {
-    typedef bidirectional_iter_adaptor_base<Derived,Base> type;
-  };
-};
-
-template<class Derived,class Base>
-class random_access_iter_adaptor_base:
-  public random_access_iterator_helper<
-    Derived,
-    typename Base::value_type,
-    typename Base::difference_type,
-    typename Base::pointer,
-    typename Base::reference>
-{
-public:
-  typedef typename Base::reference       reference;
-  typedef typename Base::difference_type difference_type;
-
-  reference operator*()const
-  {
-    return iter_adaptor_access::dereference(final());
-  }
-
-  friend bool operator==(const Derived& x,const Derived& y)
-  {
-    return iter_adaptor_access::equal(x,y);
-  }
-
-  friend bool operator<(const Derived& x,const Derived& y)
-  {
-    return iter_adaptor_access::distance_to(x,y)>0;
-  }
-
-  Derived& operator++()
-  {
-    iter_adaptor_access::increment(final());
-    return final();
-  }
-
-  Derived& operator--()
-  {
-    iter_adaptor_access::decrement(final());
-    return final();
-  }
-
-  Derived& operator+=(difference_type n)
-  {
-    iter_adaptor_access::advance(final(),n);
-    return final();
-  }
-
-  Derived& operator-=(difference_type n)
-  {
-    iter_adaptor_access::advance(final(),-n);
-    return final();
-  }
-
-  friend difference_type operator-(const Derived& x,const Derived& y)
-  {
-    return iter_adaptor_access::distance_to(y,x);
-  }
-
-private:
-  Derived& final(){return *static_cast<Derived*>(this);}
-  const Derived& final()const{return *static_cast<const Derived*>(this);}
-};
-
-template<class Derived,class Base>
-bool operator==(
-  const random_access_iter_adaptor_base<Derived,Base>& x,
-  const random_access_iter_adaptor_base<Derived,Base>& y)
-{
-  return iter_adaptor_access::equal(
-    static_cast<const Derived&>(x),static_cast<const Derived&>(y));
-}
-
-template<class Derived,class Base>
-bool operator<(
-  const random_access_iter_adaptor_base<Derived,Base>& x,
-  const random_access_iter_adaptor_base<Derived,Base>& y)
-{
-  return iter_adaptor_access::distance_to(
-    static_cast<const Derived&>(x),static_cast<const Derived&>(y))>0;
-}
-
-template<class Derived,class Base>
-typename random_access_iter_adaptor_base<Derived,Base>::difference_type
-operator-(
-  const random_access_iter_adaptor_base<Derived,Base>& x,
-  const random_access_iter_adaptor_base<Derived,Base>& y)
-{
-  return iter_adaptor_access::distance_to(
-    static_cast<const Derived&>(y),static_cast<const Derived&>(x));
-}
-
-template<>
-struct iter_adaptor_selector<std::random_access_iterator_tag>
-{
-  template<class Derived,class Base>
-  struct apply
-  {
-    typedef random_access_iter_adaptor_base<Derived,Base> type;
-  };
-};
-
-template<class Derived,class Base>
-struct iter_adaptor_base
-{
-  typedef iter_adaptor_selector<
-    typename Base::iterator_category> selector;
-  typedef typename mpl::apply2<
-    selector,Derived,Base>::type      type;
-};
-
-template<class Derived,class Base>
-class iter_adaptor:public iter_adaptor_base<Derived,Base>::type
-{
-protected:
-  iter_adaptor(){}
-  explicit iter_adaptor(const Base& b_):b(b_){}
-
-  const Base& base_reference()const{return b;}
-  Base&       base_reference(){return b;}
-
-private:
-  Base b;
-};
-
-} /* namespace multi_index::detail */
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/modify_key_adaptor.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/modify_key_adaptor.hpp
deleted file mode 100644
index 6df89b18386..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/modify_key_adaptor.hpp
+++ /dev/null
@@ -1,49 +0,0 @@
-/* Copyright 2003-2013 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_DETAIL_MODIFY_KEY_ADAPTOR_HPP
-#define BOOST_MULTI_INDEX_DETAIL_MODIFY_KEY_ADAPTOR_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-/* Functional adaptor to resolve modify_key as a call to modify.
- * Preferred over compose_f_gx and stuff cause it eliminates problems
- * with references to references, dealing with function pointers, etc.
- */
-
-template<typename Fun,typename Value,typename KeyFromValue>
-struct modify_key_adaptor
-{
-
-  modify_key_adaptor(Fun f_,KeyFromValue kfv_):f(f_),kfv(kfv_){}
-
-  void operator()(Value& x)
-  {
-    f(kfv(x));
-  }
-
-private:
-  Fun          f;
-  KeyFromValue kfv;
-};
-
-} /* namespace multi_index::detail */
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/no_duplicate_tags.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/no_duplicate_tags.hpp
deleted file mode 100644
index ba216ed82cf..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/no_duplicate_tags.hpp
+++ /dev/null
@@ -1,97 +0,0 @@
-/* Copyright 2003-2013 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_DETAIL_NO_DUPLICATE_TAGS_HPP
-#define BOOST_MULTI_INDEX_DETAIL_NO_DUPLICATE_TAGS_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <boost/mpl/fold.hpp>
-#include <boost/mpl/set/set0.hpp>
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-/* no_duplicate_tags check at compile-time that a tag list
- * has no duplicate tags.
- * The algorithm deserves some explanation: tags
- * are sequentially inserted into a mpl::set if they were
- * not already present. Due to the magic of mpl::set
- * (mpl::has_key is contant time), this operation takes linear
- * time, and even MSVC++ 6.5 handles it gracefully (other obvious
- * solutions are quadratic.)
- */
-
-struct duplicate_tag_mark{};
-
-struct duplicate_tag_marker
-{
-  template <typename MplSet,typename Tag>
-  struct apply
-  {
-    typedef mpl::s_item<
-      typename mpl::if_<mpl::has_key<MplSet,Tag>,duplicate_tag_mark,Tag>::type,
-      MplSet
-    > type;
-  };
-};
-
-template<typename TagList>
-struct no_duplicate_tags
-{
-  typedef typename mpl::fold<
-    TagList,
-    mpl::set0<>,
-    duplicate_tag_marker
-  >::type aux;
- 
-  BOOST_STATIC_CONSTANT(
-    bool,value=!(mpl::has_key<aux,duplicate_tag_mark>::value));
-};
-
-/* Variant for an index list: duplication is checked
- * across all the indices.
- */
-
-struct duplicate_tag_list_marker
-{
-  template <typename MplSet,typename Index>
-  struct apply:mpl::fold<
-    BOOST_DEDUCED_TYPENAME Index::tag_list,
-    MplSet,
-    duplicate_tag_marker>
-  {
-  };
-};
-
-template<typename IndexList>
-struct no_duplicate_tags_in_index_list
-{
-  typedef typename mpl::fold<
-    IndexList,
-    mpl::set0<>,
-    duplicate_tag_list_marker
-  >::type aux;
- 
-  BOOST_STATIC_CONSTANT(
-    bool,value=!(mpl::has_key<aux,duplicate_tag_mark>::value));
-};
-
-} /* namespace multi_index::detail */
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/node_type.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/node_type.hpp
deleted file mode 100644
index 7fe85cf968b..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/node_type.hpp
+++ /dev/null
@@ -1,66 +0,0 @@
-/* Copyright 2003-2013 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_DETAIL_NODE_TYPE_HPP
-#define BOOST_MULTI_INDEX_DETAIL_NODE_TYPE_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <boost/detail/workaround.hpp>
-#include <boost/mpl/bind.hpp>
-#include <boost/mpl/reverse_iter_fold.hpp>
-#include <boost/mpl/deref.hpp>
-#include <boost/multi_index_container_fwd.hpp>
-#include <boost/multi_index/detail/header_holder.hpp>
-#include <boost/multi_index/detail/index_node_base.hpp>
-#include <boost/multi_index/detail/is_index_list.hpp>
-#include <boost/static_assert.hpp>
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-/* MPL machinery to construct the internal node type associated to an
- * index list.
- */
-
-struct index_node_applier
-{
-  template<typename IndexSpecifierIterator,typename Super>
-  struct apply
-  {
-    typedef typename mpl::deref<IndexSpecifierIterator>::type index_specifier;
-    typedef typename index_specifier::
-      BOOST_NESTED_TEMPLATE node_class<Super>::type type;
-  }; 
-};
-
-template<typename Value,typename IndexSpecifierList,typename Allocator>
-struct multi_index_node_type
-{
-  BOOST_STATIC_ASSERT(detail::is_index_list<IndexSpecifierList>::value);
-
-  typedef typename mpl::reverse_iter_fold<
-    IndexSpecifierList,
-    index_node_base<Value,Allocator>,
-    mpl::bind2<index_node_applier,mpl::_2,mpl::_1>
-  >::type type;
-};
-
-} /* namespace multi_index::detail */
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/ord_index_args.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/ord_index_args.hpp
deleted file mode 100644
index 3e2641f2f4d..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/ord_index_args.hpp
+++ /dev/null
@@ -1,83 +0,0 @@
-/* Copyright 2003-2013 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_DETAIL_ORD_INDEX_ARGS_HPP
-#define BOOST_MULTI_INDEX_DETAIL_ORD_INDEX_ARGS_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <boost/mpl/aux_/na.hpp>
-#include <boost/mpl/eval_if.hpp>
-#include <boost/mpl/identity.hpp>
-#include <boost/mpl/if.hpp>
-#include <boost/multi_index/tag.hpp>
-#include <boost/static_assert.hpp>
-#include <boost/type_traits/is_same.hpp>
-#include <functional>
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-/* Oredered index specifiers can be instantiated in two forms:
- *
- *   (ordered_unique|ordered_non_unique)<
- *     KeyFromValue,Compare=std::less<KeyFromValue::result_type> >
- *   (ordered_unique|ordered_non_unique)<
- *     TagList,KeyFromValue,Compare=std::less<KeyFromValue::result_type> >
- *
- * index_args implements the machinery to accept this argument-dependent
- * polymorphism.
- */
-
-template<typename KeyFromValue>
-struct index_args_default_compare
-{
-  typedef std::less<typename KeyFromValue::result_type> type;
-};
-
-template<typename Arg1,typename Arg2,typename Arg3>
-struct ordered_index_args
-{
-  typedef is_tag<Arg1> full_form;
-
-  typedef typename mpl::if_<
-    full_form,
-    Arg1,
-    tag< > >::type                                   tag_list_type;
-  typedef typename mpl::if_<
-    full_form,
-    Arg2,
-    Arg1>::type                                      key_from_value_type;
-  typedef typename mpl::if_<
-    full_form,
-    Arg3,
-    Arg2>::type                                      supplied_compare_type;
-  typedef typename mpl::eval_if<
-    mpl::is_na<supplied_compare_type>,
-    index_args_default_compare<key_from_value_type>,
-    mpl::identity<supplied_compare_type>
-  >::type                                            compare_type;
-
-  BOOST_STATIC_ASSERT(is_tag<tag_list_type>::value);
-  BOOST_STATIC_ASSERT(!mpl::is_na<key_from_value_type>::value);
-  BOOST_STATIC_ASSERT(!mpl::is_na<compare_type>::value);
-};
-
-} /* namespace multi_index::detail */
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/ord_index_impl.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/ord_index_impl.hpp
deleted file mode 100644
index 040cb989630..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/ord_index_impl.hpp
+++ /dev/null
@@ -1,1567 +0,0 @@
-/* Copyright 2003-2015 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- *
- * The internal implementation of red-black trees is based on that of SGI STL
- * stl_tree.h file: 
- *
- * Copyright (c) 1996,1997
- * Silicon Graphics Computer Systems, Inc.
- *
- * Permission to use, copy, modify, distribute and sell this software
- * and its documentation for any purpose is hereby granted without fee,
- * provided that the above copyright notice appear in all copies and
- * that both that copyright notice and this permission notice appear
- * in supporting documentation.  Silicon Graphics makes no
- * representations about the suitability of this software for any
- * purpose.  It is provided "as is" without express or implied warranty.
- *
- *
- * Copyright (c) 1994
- * Hewlett-Packard Company
- *
- * Permission to use, copy, modify, distribute and sell this software
- * and its documentation for any purpose is hereby granted without fee,
- * provided that the above copyright notice appear in all copies and
- * that both that copyright notice and this permission notice appear
- * in supporting documentation.  Hewlett-Packard Company makes no
- * representations about the suitability of this software for any
- * purpose.  It is provided "as is" without express or implied warranty.
- *
- */
-
-#ifndef BOOST_MULTI_INDEX_DETAIL_ORD_INDEX_IMPL_HPP
-#define BOOST_MULTI_INDEX_DETAIL_ORD_INDEX_IMPL_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <algorithm>
-#include <boost/call_traits.hpp>
-#include <boost/detail/no_exceptions_support.hpp>
-#include <boost/detail/workaround.hpp>
-#include <boost/foreach_fwd.hpp>
-#include <boost/iterator/reverse_iterator.hpp>
-#include <boost/move/core.hpp>
-#include <boost/mpl/bool.hpp>
-#include <boost/mpl/if.hpp>
-#include <boost/mpl/push_front.hpp>
-#include <boost/multi_index/detail/access_specifier.hpp>
-#include <boost/multi_index/detail/bidir_node_iterator.hpp>
-#include <boost/multi_index/detail/do_not_copy_elements_tag.hpp>
-#include <boost/multi_index/detail/index_node_base.hpp>
-#include <boost/multi_index/detail/modify_key_adaptor.hpp>
-#include <boost/multi_index/detail/ord_index_node.hpp>
-#include <boost/multi_index/detail/ord_index_ops.hpp>
-#include <boost/multi_index/detail/safe_mode.hpp>
-#include <boost/multi_index/detail/scope_guard.hpp>
-#include <boost/multi_index/detail/unbounded.hpp>
-#include <boost/multi_index/detail/value_compare.hpp>
-#include <boost/multi_index/detail/vartempl_support.hpp>
-#include <boost/multi_index/detail/ord_index_impl_fwd.hpp>
-#include <boost/ref.hpp>
-#include <boost/tuple/tuple.hpp>
-#include <boost/type_traits/is_same.hpp>
-#include <utility>
-
-#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
-#include <initializer_list>
-#endif
-
-#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
-#include <boost/archive/archive_exception.hpp>
-#include <boost/bind.hpp>
-#include <boost/multi_index/detail/duplicates_iterator.hpp>
-#include <boost/throw_exception.hpp> 
-#endif
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING)
-#define BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT_OF(x)                    \
-  detail::scope_guard BOOST_JOIN(check_invariant_,__LINE__)=                 \
-    detail::make_obj_guard(x,&ordered_index_impl::check_invariant_);         \
-  BOOST_JOIN(check_invariant_,__LINE__).touch();
-#define BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT                          \
-  BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT_OF(*this)
-#else
-#define BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT_OF(x)
-#define BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT
-#endif
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-/* ordered_index adds a layer of ordered indexing to a given Super and accepts
- * an augmenting policy for optional addition of order statistics.
- */
-
-/* Most of the implementation of unique and non-unique indices is
- * shared. We tell from one another on instantiation time by using
- * these tags.
- */
-
-struct ordered_unique_tag{};
-struct ordered_non_unique_tag{};
-
-template<
-  typename KeyFromValue,typename Compare,
-  typename SuperMeta,typename TagList,typename Category,typename AugmentPolicy
->
-class ordered_index;
-
-template<
-  typename KeyFromValue,typename Compare,
-  typename SuperMeta,typename TagList,typename Category,typename AugmentPolicy
->
-class ordered_index_impl:
-  BOOST_MULTI_INDEX_PROTECTED_IF_MEMBER_TEMPLATE_FRIENDS SuperMeta::type
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-  ,public safe_mode::safe_container<
-    ordered_index_impl<
-      KeyFromValue,Compare,SuperMeta,TagList,Category,AugmentPolicy> >
-#endif
-
-{ 
-#if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING)&&\
-    BOOST_WORKAROUND(__MWERKS__,<=0x3003)
-/* The "ISO C++ Template Parser" option in CW8.3 has a problem with the
- * lifetime of const references bound to temporaries --precisely what
- * scopeguards are.
- */
-
-#pragma parse_mfunc_templ off
-#endif
-
-  typedef typename SuperMeta::type                   super;
-
-protected:
-  typedef ordered_index_node<
-    AugmentPolicy,typename super::node_type>         node_type;
-
-protected: /* for the benefit of AugmentPolicy::augmented_interface */
-  typedef typename node_type::impl_type              node_impl_type;
-  typedef typename node_impl_type::pointer           node_impl_pointer;
-
-public:
-  /* types */
-
-  typedef typename KeyFromValue::result_type         key_type;
-  typedef typename node_type::value_type             value_type;
-  typedef KeyFromValue                               key_from_value;
-  typedef Compare                                    key_compare;
-  typedef value_comparison<
-    value_type,KeyFromValue,Compare>                 value_compare;
-  typedef tuple<key_from_value,key_compare>          ctor_args;
-  typedef typename super::final_allocator_type       allocator_type;
-  typedef typename allocator_type::reference         reference;
-  typedef typename allocator_type::const_reference   const_reference;
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-  typedef safe_mode::safe_iterator<
-    bidir_node_iterator<node_type>,
-    ordered_index_impl>                              iterator;
-#else
-  typedef bidir_node_iterator<node_type>             iterator;
-#endif
-
-  typedef iterator                                   const_iterator;
-
-  typedef std::size_t                                size_type;      
-  typedef std::ptrdiff_t                             difference_type;
-  typedef typename allocator_type::pointer           pointer;
-  typedef typename allocator_type::const_pointer     const_pointer;
-  typedef typename
-    boost::reverse_iterator<iterator>                reverse_iterator;
-  typedef typename
-    boost::reverse_iterator<const_iterator>          const_reverse_iterator;
-  typedef TagList                                    tag_list;
-
-protected:
-  typedef typename super::final_node_type            final_node_type;
-  typedef tuples::cons<
-    ctor_args, 
-    typename super::ctor_args_list>                  ctor_args_list;
-  typedef typename mpl::push_front<
-    typename super::index_type_list,
-    ordered_index<
-      KeyFromValue,Compare,
-      SuperMeta,TagList,Category,AugmentPolicy
-    > >::type                                        index_type_list;
-  typedef typename mpl::push_front<
-    typename super::iterator_type_list,
-    iterator>::type    iterator_type_list;
-  typedef typename mpl::push_front<
-    typename super::const_iterator_type_list,
-    const_iterator>::type                            const_iterator_type_list;
-  typedef typename super::copy_map_type              copy_map_type;
-
-#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
-  typedef typename super::index_saver_type           index_saver_type;
-  typedef typename super::index_loader_type          index_loader_type;
-#endif
-
-protected:
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-  typedef safe_mode::safe_container<
-    ordered_index_impl>                              safe_super;
-#endif
-
-  typedef typename call_traits<
-    value_type>::param_type                          value_param_type;
-  typedef typename call_traits<
-    key_type>::param_type                            key_param_type;
-
-  /* Needed to avoid commas in BOOST_MULTI_INDEX_OVERLOADS_TO_VARTEMPL
-   * expansion.
-   */
-
-  typedef std::pair<iterator,bool>                   emplace_return_type;
-
-public:
-
-  /* construct/copy/destroy
-   * Default and copy ctors are in the protected section as indices are
-   * not supposed to be created on their own. No range ctor either.
-   * Assignment operators defined at ordered_index rather than here.
-   */
-
-  allocator_type get_allocator()const BOOST_NOEXCEPT
-  {
-    return this->final().get_allocator();
-  }
-
-  /* iterators */
-
-  iterator
-    begin()BOOST_NOEXCEPT{return make_iterator(leftmost());}
-  const_iterator
-    begin()const BOOST_NOEXCEPT{return make_iterator(leftmost());}
-  iterator
-    end()BOOST_NOEXCEPT{return make_iterator(header());}
-  const_iterator
-    end()const BOOST_NOEXCEPT{return make_iterator(header());}
-  reverse_iterator
-    rbegin()BOOST_NOEXCEPT{return boost::make_reverse_iterator(end());}
-  const_reverse_iterator
-    rbegin()const BOOST_NOEXCEPT{return boost::make_reverse_iterator(end());}
-  reverse_iterator
-    rend()BOOST_NOEXCEPT{return boost::make_reverse_iterator(begin());}
-  const_reverse_iterator
-    rend()const BOOST_NOEXCEPT{return boost::make_reverse_iterator(begin());}
-  const_iterator
-    cbegin()const BOOST_NOEXCEPT{return begin();}
-  const_iterator
-    cend()const BOOST_NOEXCEPT{return end();}
-  const_reverse_iterator
-    crbegin()const BOOST_NOEXCEPT{return rbegin();}
-  const_reverse_iterator
-    crend()const BOOST_NOEXCEPT{return rend();}
- 
-  iterator iterator_to(const value_type& x)
-  {
-    return make_iterator(node_from_value<node_type>(&x));
-  }
-
-  const_iterator iterator_to(const value_type& x)const
-  {
-    return make_iterator(node_from_value<node_type>(&x));
-  }
-
-  /* capacity */
-
-  bool      empty()const BOOST_NOEXCEPT{return this->final_empty_();}
-  size_type size()const BOOST_NOEXCEPT{return this->final_size_();}
-  size_type max_size()const BOOST_NOEXCEPT{return this->final_max_size_();}
-
-  /* modifiers */
-
-  BOOST_MULTI_INDEX_OVERLOADS_TO_VARTEMPL(
-    emplace_return_type,emplace,emplace_impl)
-
-  BOOST_MULTI_INDEX_OVERLOADS_TO_VARTEMPL_EXTRA_ARG(
-    iterator,emplace_hint,emplace_hint_impl,iterator,position)
-
-  std::pair<iterator,bool> insert(const value_type& x)
-  {
-    BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT;
-    std::pair<final_node_type*,bool> p=this->final_insert_(x);
-    return std::pair<iterator,bool>(make_iterator(p.first),p.second);
-  }
-
-  std::pair<iterator,bool> insert(BOOST_RV_REF(value_type) x)
-  {
-    BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT;
-    std::pair<final_node_type*,bool> p=this->final_insert_rv_(x);
-    return std::pair<iterator,bool>(make_iterator(p.first),p.second);
-  }
-
-  iterator insert(iterator position,const value_type& x)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
-    BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT;
-    std::pair<final_node_type*,bool> p=this->final_insert_(
-      x,static_cast<final_node_type*>(position.get_node()));
-    return make_iterator(p.first);
-  }
-    
-  iterator insert(iterator position,BOOST_RV_REF(value_type) x)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
-    BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT;
-    std::pair<final_node_type*,bool> p=this->final_insert_rv_(
-      x,static_cast<final_node_type*>(position.get_node()));
-    return make_iterator(p.first);
-  }
-
-  template<typename InputIterator>
-  void insert(InputIterator first,InputIterator last)
-  {
-    BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT;
-    node_type* hint=header(); /* end() */
-    for(;first!=last;++first){
-      hint=this->final_insert_ref_(
-        *first,static_cast<final_node_type*>(hint)).first;
-      node_type::increment(hint);
-    }
-  }
-
-#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
-  void insert(std::initializer_list<value_type> list)
-  {
-    insert(list.begin(),list.end());
-  }
-#endif
-
-  iterator erase(iterator position)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
-    BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT;
-    this->final_erase_(static_cast<final_node_type*>(position++.get_node()));
-    return position;
-  }
-  
-  size_type erase(key_param_type x)
-  {
-    BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT;
-    std::pair<iterator,iterator> p=equal_range(x);
-    size_type s=0;
-    while(p.first!=p.second){
-      p.first=erase(p.first);
-      ++s;
-    }
-    return s;
-  }
-
-  iterator erase(iterator first,iterator last)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(first);
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(last);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(first,*this);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(last,*this);
-    BOOST_MULTI_INDEX_CHECK_VALID_RANGE(first,last);
-    BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT;
-    while(first!=last){
-      first=erase(first);
-    }
-    return first;
-  }
-
-  bool replace(iterator position,const value_type& x)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
-    BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT;
-    return this->final_replace_(
-      x,static_cast<final_node_type*>(position.get_node()));
-  }
-
-  bool replace(iterator position,BOOST_RV_REF(value_type) x)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
-    BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT;
-    return this->final_replace_rv_(
-      x,static_cast<final_node_type*>(position.get_node()));
-  }
-
-  template<typename Modifier>
-  bool modify(iterator position,Modifier mod)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
-    BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT;
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-    /* MSVC++ 6.0 optimizer on safe mode code chokes if this
-     * this is not added. Left it for all compilers as it does no
-     * harm.
-     */
-
-    position.detach();
-#endif
-
-    return this->final_modify_(
-      mod,static_cast<final_node_type*>(position.get_node()));
-  }
-
-  template<typename Modifier,typename Rollback>
-  bool modify(iterator position,Modifier mod,Rollback back_)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
-    BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT;
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-    /* MSVC++ 6.0 optimizer on safe mode code chokes if this
-     * this is not added. Left it for all compilers as it does no
-     * harm.
-     */
-
-    position.detach();
-#endif
-
-    return this->final_modify_(
-      mod,back_,static_cast<final_node_type*>(position.get_node()));
-  }
-  
-  template<typename Modifier>
-  bool modify_key(iterator position,Modifier mod)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
-    BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT;
-    return modify(
-      position,modify_key_adaptor<Modifier,value_type,KeyFromValue>(mod,key));
-  }
-
-  template<typename Modifier,typename Rollback>
-  bool modify_key(iterator position,Modifier mod,Rollback back_)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
-    BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT;
-    return modify(
-      position,
-      modify_key_adaptor<Modifier,value_type,KeyFromValue>(mod,key),
-      modify_key_adaptor<Rollback,value_type,KeyFromValue>(back_,key));
-  }
-
-  void swap(
-    ordered_index<
-      KeyFromValue,Compare,SuperMeta,TagList,Category,AugmentPolicy>& x)
-  {
-    BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT;
-    BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT_OF(x);
-    this->final_swap_(x.final());
-  }
-
-  void clear()BOOST_NOEXCEPT
-  {
-    BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT;
-    this->final_clear_();
-  }
-
-  /* observers */
-
-  key_from_value key_extractor()const{return key;}
-  key_compare    key_comp()const{return comp_;}
-  value_compare  value_comp()const{return value_compare(key,comp_);}
-
-  /* set operations */
-
-  /* Internally, these ops rely on const_iterator being the same
-   * type as iterator.
-   */
-
-  template<typename CompatibleKey>
-  iterator find(const CompatibleKey& x)const
-  {
-    return make_iterator(ordered_index_find(root(),header(),key,x,comp_));
-  }
-
-  template<typename CompatibleKey,typename CompatibleCompare>
-  iterator find(
-    const CompatibleKey& x,const CompatibleCompare& comp)const
-  {
-    return make_iterator(ordered_index_find(root(),header(),key,x,comp));
-  }
-
-  template<typename CompatibleKey>
-  size_type count(const CompatibleKey& x)const
-  {
-    return count(x,comp_);
-  }
-
-  template<typename CompatibleKey,typename CompatibleCompare>
-  size_type count(const CompatibleKey& x,const CompatibleCompare& comp)const
-  {
-    std::pair<iterator,iterator> p=equal_range(x,comp);
-    size_type n=std::distance(p.first,p.second);
-    return n;
-  }
-
-  template<typename CompatibleKey>
-  iterator lower_bound(const CompatibleKey& x)const
-  {
-    return make_iterator(
-      ordered_index_lower_bound(root(),header(),key,x,comp_));
-  }
-
-  template<typename CompatibleKey,typename CompatibleCompare>
-  iterator lower_bound(
-    const CompatibleKey& x,const CompatibleCompare& comp)const
-  {
-    return make_iterator(
-      ordered_index_lower_bound(root(),header(),key,x,comp));
-  }
-
-  template<typename CompatibleKey>
-  iterator upper_bound(const CompatibleKey& x)const
-  {
-    return make_iterator(
-      ordered_index_upper_bound(root(),header(),key,x,comp_));
-  }
-
-  template<typename CompatibleKey,typename CompatibleCompare>
-  iterator upper_bound(
-    const CompatibleKey& x,const CompatibleCompare& comp)const
-  {
-    return make_iterator(
-      ordered_index_upper_bound(root(),header(),key,x,comp));
-  }
-
-  template<typename CompatibleKey>
-  std::pair<iterator,iterator> equal_range(
-    const CompatibleKey& x)const
-  {
-    std::pair<node_type*,node_type*> p=
-      ordered_index_equal_range(root(),header(),key,x,comp_);
-    return std::pair<iterator,iterator>(
-      make_iterator(p.first),make_iterator(p.second));
-  }
-
-  template<typename CompatibleKey,typename CompatibleCompare>
-  std::pair<iterator,iterator> equal_range(
-    const CompatibleKey& x,const CompatibleCompare& comp)const
-  {
-    std::pair<node_type*,node_type*> p=
-      ordered_index_equal_range(root(),header(),key,x,comp);
-    return std::pair<iterator,iterator>(
-      make_iterator(p.first),make_iterator(p.second));
-  }
-
-  /* range */
-
-  template<typename LowerBounder,typename UpperBounder>
-  std::pair<iterator,iterator>
-  range(LowerBounder lower,UpperBounder upper)const
-  {
-    typedef typename mpl::if_<
-      is_same<LowerBounder,unbounded_type>,
-      BOOST_DEDUCED_TYPENAME mpl::if_<
-        is_same<UpperBounder,unbounded_type>,
-        both_unbounded_tag,
-        lower_unbounded_tag
-      >::type,
-      BOOST_DEDUCED_TYPENAME mpl::if_<
-        is_same<UpperBounder,unbounded_type>,
-        upper_unbounded_tag,
-        none_unbounded_tag
-      >::type
-    >::type dispatch;
-
-    return range(lower,upper,dispatch());
-  }
-
-BOOST_MULTI_INDEX_PROTECTED_IF_MEMBER_TEMPLATE_FRIENDS:
-  ordered_index_impl(const ctor_args_list& args_list,const allocator_type& al):
-    super(args_list.get_tail(),al),
-    key(tuples::get<0>(args_list.get_head())),
-    comp_(tuples::get<1>(args_list.get_head()))
-  {
-    empty_initialize();
-  }
-
-  ordered_index_impl(
-    const ordered_index_impl<
-      KeyFromValue,Compare,SuperMeta,TagList,Category,AugmentPolicy>& x):
-    super(x),
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-    safe_super(),
-#endif
-
-    key(x.key),
-    comp_(x.comp_)
-  {
-    /* Copy ctor just takes the key and compare objects from x. The rest is
-     * done in a subsequent call to copy_().
-     */
-  }
-
-  ordered_index_impl(
-     const ordered_index_impl<
-       KeyFromValue,Compare,SuperMeta,TagList,Category,AugmentPolicy>& x,
-     do_not_copy_elements_tag):
-    super(x,do_not_copy_elements_tag()),
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-    safe_super(),
-#endif
-
-    key(x.key),
-    comp_(x.comp_)
-  {
-    empty_initialize();
-  }
-
-  ~ordered_index_impl()
-  {
-    /* the container is guaranteed to be empty by now */
-  }
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-  iterator       make_iterator(node_type* node){return iterator(node,this);}
-  const_iterator make_iterator(node_type* node)const
-    {return const_iterator(node,const_cast<ordered_index_impl*>(this));}
-#else
-  iterator       make_iterator(node_type* node){return iterator(node);}
-  const_iterator make_iterator(node_type* node)const
-                   {return const_iterator(node);}
-#endif
-
-  void copy_(
-    const ordered_index_impl<
-      KeyFromValue,Compare,SuperMeta,TagList,Category,AugmentPolicy>& x,
-    const copy_map_type& map)
-  {
-    if(!x.root()){
-      empty_initialize();
-    }
-    else{
-      header()->color()=x.header()->color();
-      AugmentPolicy::copy(x.header()->impl(),header()->impl());
-
-      node_type* root_cpy=map.find(static_cast<final_node_type*>(x.root()));
-      header()->parent()=root_cpy->impl();
-
-      node_type* leftmost_cpy=map.find(
-        static_cast<final_node_type*>(x.leftmost()));
-      header()->left()=leftmost_cpy->impl();
-
-      node_type* rightmost_cpy=map.find(
-        static_cast<final_node_type*>(x.rightmost()));
-      header()->right()=rightmost_cpy->impl();
-
-      typedef typename copy_map_type::const_iterator copy_map_iterator;
-      for(copy_map_iterator it=map.begin(),it_end=map.end();it!=it_end;++it){
-        node_type* org=it->first;
-        node_type* cpy=it->second;
-
-        cpy->color()=org->color();
-        AugmentPolicy::copy(org->impl(),cpy->impl());
-
-        node_impl_pointer parent_org=org->parent();
-        if(parent_org==node_impl_pointer(0))cpy->parent()=node_impl_pointer(0);
-        else{
-          node_type* parent_cpy=map.find(
-            static_cast<final_node_type*>(node_type::from_impl(parent_org)));
-          cpy->parent()=parent_cpy->impl();
-          if(parent_org->left()==org->impl()){
-            parent_cpy->left()=cpy->impl();
-          }
-          else if(parent_org->right()==org->impl()){
-            /* header() does not satisfy this nor the previous check */
-            parent_cpy->right()=cpy->impl();
-          }
-        }
-
-        if(org->left()==node_impl_pointer(0))
-          cpy->left()=node_impl_pointer(0);
-        if(org->right()==node_impl_pointer(0))
-          cpy->right()=node_impl_pointer(0);
-      }
-    }
-    
-    super::copy_(x,map);
-  }
-
-  template<typename Variant>
-  final_node_type* insert_(
-    value_param_type v,final_node_type*& x,Variant variant)
-  {
-    link_info inf;
-    if(!link_point(key(v),inf,Category())){
-      return static_cast<final_node_type*>(node_type::from_impl(inf.pos));
-    }
-
-    final_node_type* res=super::insert_(v,x,variant);
-    if(res==x){
-      node_impl_type::link(
-        static_cast<node_type*>(x)->impl(),inf.side,inf.pos,header()->impl());
-    }
-    return res;
-  }
-
-  template<typename Variant>
-  final_node_type* insert_(
-    value_param_type v,node_type* position,final_node_type*& x,Variant variant)
-  {
-    link_info inf;
-    if(!hinted_link_point(key(v),position,inf,Category())){
-      return static_cast<final_node_type*>(node_type::from_impl(inf.pos));
-    }
-
-    final_node_type* res=super::insert_(v,position,x,variant);
-    if(res==x){
-      node_impl_type::link(
-        static_cast<node_type*>(x)->impl(),inf.side,inf.pos,header()->impl());
-    }
-    return res;
-  }
-
-  void erase_(node_type* x)
-  {
-    node_impl_type::rebalance_for_erase(
-      x->impl(),header()->parent(),header()->left(),header()->right());
-    super::erase_(x);
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-    detach_iterators(x);
-#endif
-  }
-
-  void delete_all_nodes_()
-  {
-    delete_all_nodes(root());
-  }
-
-  void clear_()
-  {
-    super::clear_();
-    empty_initialize();
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-    safe_super::detach_dereferenceable_iterators();
-#endif
-  }
-
-  void swap_(
-    ordered_index_impl<
-      KeyFromValue,Compare,SuperMeta,TagList,Category,AugmentPolicy>& x)
-  {
-    std::swap(key,x.key);
-    std::swap(comp_,x.comp_);
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-    safe_super::swap(x);
-#endif
-
-    super::swap_(x);
-  }
-
-  void swap_elements_(
-    ordered_index_impl<
-      KeyFromValue,Compare,SuperMeta,TagList,Category,AugmentPolicy>& x)
-  {
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-    safe_super::swap(x);
-#endif
-
-    super::swap_elements_(x);
-  }
-
-  template<typename Variant>
-  bool replace_(value_param_type v,node_type* x,Variant variant)
-  {
-    if(in_place(v,x,Category())){
-      return super::replace_(v,x,variant);
-    }
-
-    node_type* next=x;
-    node_type::increment(next);
-
-    node_impl_type::rebalance_for_erase(
-      x->impl(),header()->parent(),header()->left(),header()->right());
-
-    BOOST_TRY{
-      link_info inf;
-      if(link_point(key(v),inf,Category())&&super::replace_(v,x,variant)){
-        node_impl_type::link(x->impl(),inf.side,inf.pos,header()->impl());
-        return true;
-      }
-      node_impl_type::restore(x->impl(),next->impl(),header()->impl());
-      return false;
-    }
-    BOOST_CATCH(...){
-      node_impl_type::restore(x->impl(),next->impl(),header()->impl());
-      BOOST_RETHROW;
-    }
-    BOOST_CATCH_END
-  }
-
-  bool modify_(node_type* x)
-  {
-    bool b;
-    BOOST_TRY{
-      b=in_place(x->value(),x,Category());
-    }
-    BOOST_CATCH(...){
-      erase_(x);
-      BOOST_RETHROW;
-    }
-    BOOST_CATCH_END
-    if(!b){
-      node_impl_type::rebalance_for_erase(
-        x->impl(),header()->parent(),header()->left(),header()->right());
-      BOOST_TRY{
-        link_info inf;
-        if(!link_point(key(x->value()),inf,Category())){
-          super::erase_(x);
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-          detach_iterators(x);
-#endif
-          return false;
-        }
-        node_impl_type::link(x->impl(),inf.side,inf.pos,header()->impl());
-      }
-      BOOST_CATCH(...){
-        super::erase_(x);
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-        detach_iterators(x);
-#endif
-
-        BOOST_RETHROW;
-      }
-      BOOST_CATCH_END
-    }
-
-    BOOST_TRY{
-      if(!super::modify_(x)){
-        node_impl_type::rebalance_for_erase(
-          x->impl(),header()->parent(),header()->left(),header()->right());
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-        detach_iterators(x);
-#endif
-
-        return false;
-      }
-      else return true;
-    }
-    BOOST_CATCH(...){
-      node_impl_type::rebalance_for_erase(
-        x->impl(),header()->parent(),header()->left(),header()->right());
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-      detach_iterators(x);
-#endif
-
-      BOOST_RETHROW;
-    }
-    BOOST_CATCH_END
-  }
-
-  bool modify_rollback_(node_type* x)
-  {
-    if(in_place(x->value(),x,Category())){
-      return super::modify_rollback_(x);
-    }
-
-    node_type* next=x;
-    node_type::increment(next);
-
-    node_impl_type::rebalance_for_erase(
-      x->impl(),header()->parent(),header()->left(),header()->right());
-
-    BOOST_TRY{
-      link_info inf;
-      if(link_point(key(x->value()),inf,Category())&&
-         super::modify_rollback_(x)){
-        node_impl_type::link(x->impl(),inf.side,inf.pos,header()->impl());
-        return true;
-      }
-      node_impl_type::restore(x->impl(),next->impl(),header()->impl());
-      return false;
-    }
-    BOOST_CATCH(...){
-      node_impl_type::restore(x->impl(),next->impl(),header()->impl());
-      BOOST_RETHROW;
-    }
-    BOOST_CATCH_END
-  }
-
-#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
-  /* serialization */
-
-  template<typename Archive>
-  void save_(
-    Archive& ar,const unsigned int version,const index_saver_type& sm)const
-  {
-    save_(ar,version,sm,Category());
-  }
-
-  template<typename Archive>
-  void load_(Archive& ar,const unsigned int version,const index_loader_type& lm)
-  {
-    load_(ar,version,lm,Category());
-  }
-#endif
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING)
-  /* invariant stuff */
-
-  bool invariant_()const
-  {
-    if(size()==0||begin()==end()){
-      if(size()!=0||begin()!=end()||
-         header()->left()!=header()->impl()||
-         header()->right()!=header()->impl())return false;
-    }
-    else{
-      if((size_type)std::distance(begin(),end())!=size())return false;
-
-      std::size_t len=node_impl_type::black_count(
-        leftmost()->impl(),root()->impl());
-      for(const_iterator it=begin(),it_end=end();it!=it_end;++it){
-        node_type* x=it.get_node();
-        node_type* left_x=node_type::from_impl(x->left());
-        node_type* right_x=node_type::from_impl(x->right());
-
-        if(x->color()==red){
-          if((left_x&&left_x->color()==red)||
-             (right_x&&right_x->color()==red))return false;
-        }
-        if(left_x&&comp_(key(x->value()),key(left_x->value())))return false;
-        if(right_x&&comp_(key(right_x->value()),key(x->value())))return false;
-        if(!left_x&&!right_x&&
-           node_impl_type::black_count(x->impl(),root()->impl())!=len)
-          return false;
-        if(!AugmentPolicy::invariant(x->impl()))return false;
-      }
-    
-      if(leftmost()->impl()!=node_impl_type::minimum(root()->impl()))
-        return false;
-      if(rightmost()->impl()!=node_impl_type::maximum(root()->impl()))
-        return false;
-    }
-
-    return super::invariant_();
-  }
-
-  
-  /* This forwarding function eases things for the boost::mem_fn construct
-   * in BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT. Actually,
-   * final_check_invariant is already an inherited member function of
-   * ordered_index_impl.
-   */
-  void check_invariant_()const{this->final_check_invariant_();}
-#endif
-
-protected: /* for the benefit of AugmentPolicy::augmented_interface */
-  node_type* header()const{return this->final_header();}
-  node_type* root()const{return node_type::from_impl(header()->parent());}
-  node_type* leftmost()const{return node_type::from_impl(header()->left());}
-  node_type* rightmost()const{return node_type::from_impl(header()->right());}
-
-private:
-  void empty_initialize()
-  {
-    header()->color()=red;
-    /* used to distinguish header() from root, in iterator.operator++ */
-    
-    header()->parent()=node_impl_pointer(0);
-    header()->left()=header()->impl();
-    header()->right()=header()->impl();
-  }
-
-  struct link_info
-  {
-    /* coverity[uninit_ctor]: suppress warning */
-    link_info():side(to_left){}
-
-    ordered_index_side side;
-    node_impl_pointer  pos;
-  };
-
-  bool link_point(key_param_type k,link_info& inf,ordered_unique_tag)
-  {
-    node_type* y=header();
-    node_type* x=root();
-    bool c=true;
-    while(x){
-      y=x;
-      c=comp_(k,key(x->value()));
-      x=node_type::from_impl(c?x->left():x->right());
-    }
-    node_type* yy=y;
-    if(c){
-      if(yy==leftmost()){
-        inf.side=to_left;
-        inf.pos=y->impl();
-        return true;
-      }
-      else node_type::decrement(yy);
-    }
-
-    if(comp_(key(yy->value()),k)){
-      inf.side=c?to_left:to_right;
-      inf.pos=y->impl();
-      return true;
-    }
-    else{
-      inf.pos=yy->impl();
-      return false;
-    }
-  }
-
-  bool link_point(key_param_type k,link_info& inf,ordered_non_unique_tag)
-  {
-    node_type* y=header();
-    node_type* x=root();
-    bool c=true;
-    while (x){
-     y=x;
-     c=comp_(k,key(x->value()));
-     x=node_type::from_impl(c?x->left():x->right());
-    }
-    inf.side=c?to_left:to_right;
-    inf.pos=y->impl();
-    return true;
-  }
-
-  bool lower_link_point(key_param_type k,link_info& inf,ordered_non_unique_tag)
-  {
-    node_type* y=header();
-    node_type* x=root();
-    bool c=false;
-    while (x){
-     y=x;
-     c=comp_(key(x->value()),k);
-     x=node_type::from_impl(c?x->right():x->left());
-    }
-    inf.side=c?to_right:to_left;
-    inf.pos=y->impl();
-    return true;
-  }
-
-  bool hinted_link_point(
-    key_param_type k,node_type* position,link_info& inf,ordered_unique_tag)
-  {
-    if(position->impl()==header()->left()){ 
-      if(size()>0&&comp_(k,key(position->value()))){
-        inf.side=to_left;
-        inf.pos=position->impl();
-        return true;
-      }
-      else return link_point(k,inf,ordered_unique_tag());
-    } 
-    else if(position==header()){ 
-      if(comp_(key(rightmost()->value()),k)){
-        inf.side=to_right;
-        inf.pos=rightmost()->impl();
-        return true;
-      }
-      else return link_point(k,inf,ordered_unique_tag());
-    } 
-    else{
-      node_type* before=position;
-      node_type::decrement(before);
-      if(comp_(key(before->value()),k)&&comp_(k,key(position->value()))){
-        if(before->right()==node_impl_pointer(0)){
-          inf.side=to_right;
-          inf.pos=before->impl();
-          return true;
-        }
-        else{
-          inf.side=to_left;
-          inf.pos=position->impl();
-          return true;
-        }
-      } 
-      else return link_point(k,inf,ordered_unique_tag());
-    }
-  }
-
-  bool hinted_link_point(
-    key_param_type k,node_type* position,link_info& inf,ordered_non_unique_tag)
-  {
-    if(position->impl()==header()->left()){ 
-      if(size()>0&&!comp_(key(position->value()),k)){
-        inf.side=to_left;
-        inf.pos=position->impl();
-        return true;
-      }
-      else return lower_link_point(k,inf,ordered_non_unique_tag());
-    } 
-    else if(position==header()){
-      if(!comp_(k,key(rightmost()->value()))){
-        inf.side=to_right;
-        inf.pos=rightmost()->impl();
-        return true;
-      }
-      else return link_point(k,inf,ordered_non_unique_tag());
-    } 
-    else{
-      node_type* before=position;
-      node_type::decrement(before);
-      if(!comp_(k,key(before->value()))){
-        if(!comp_(key(position->value()),k)){
-          if(before->right()==node_impl_pointer(0)){
-            inf.side=to_right;
-            inf.pos=before->impl();
-            return true;
-          }
-          else{
-            inf.side=to_left;
-            inf.pos=position->impl();
-            return true;
-          }
-        }
-        else return lower_link_point(k,inf,ordered_non_unique_tag());
-      } 
-      else return link_point(k,inf,ordered_non_unique_tag());
-    }
-  }
-
-  void delete_all_nodes(node_type* x)
-  {
-    if(!x)return;
-
-    delete_all_nodes(node_type::from_impl(x->left()));
-    delete_all_nodes(node_type::from_impl(x->right()));
-    this->final_delete_node_(static_cast<final_node_type*>(x));
-  }
-
-  bool in_place(value_param_type v,node_type* x,ordered_unique_tag)
-  {
-    node_type* y;
-    if(x!=leftmost()){
-      y=x;
-      node_type::decrement(y);
-      if(!comp_(key(y->value()),key(v)))return false;
-    }
-
-    y=x;
-    node_type::increment(y);
-    return y==header()||comp_(key(v),key(y->value()));
-  }
-
-  bool in_place(value_param_type v,node_type* x,ordered_non_unique_tag)
-  {
-    node_type* y;
-    if(x!=leftmost()){
-      y=x;
-      node_type::decrement(y);
-      if(comp_(key(v),key(y->value())))return false;
-    }
-
-    y=x;
-    node_type::increment(y);
-    return y==header()||!comp_(key(y->value()),key(v));
-  }
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-  void detach_iterators(node_type* x)
-  {
-    iterator it=make_iterator(x);
-    safe_mode::detach_equivalent_iterators(it);
-  }
-#endif
-
-  template<BOOST_MULTI_INDEX_TEMPLATE_PARAM_PACK>
-  std::pair<iterator,bool> emplace_impl(BOOST_MULTI_INDEX_FUNCTION_PARAM_PACK)
-  {
-    BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT;
-    std::pair<final_node_type*,bool>p=
-      this->final_emplace_(BOOST_MULTI_INDEX_FORWARD_PARAM_PACK);
-    return std::pair<iterator,bool>(make_iterator(p.first),p.second);
-  }
-
-  template<BOOST_MULTI_INDEX_TEMPLATE_PARAM_PACK>
-  iterator emplace_hint_impl(
-    iterator position,BOOST_MULTI_INDEX_FUNCTION_PARAM_PACK)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
-    BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT;
-    std::pair<final_node_type*,bool>p=
-      this->final_emplace_hint_(
-        static_cast<final_node_type*>(position.get_node()),
-        BOOST_MULTI_INDEX_FORWARD_PARAM_PACK);
-    return make_iterator(p.first);
-  }
-
-  template<typename LowerBounder,typename UpperBounder>
-  std::pair<iterator,iterator>
-  range(LowerBounder lower,UpperBounder upper,none_unbounded_tag)const
-  {
-    node_type* y=header();
-    node_type* z=root();
-
-    while(z){
-      if(!lower(key(z->value()))){
-        z=node_type::from_impl(z->right());
-      }
-      else if(!upper(key(z->value()))){
-        y=z;
-        z=node_type::from_impl(z->left());
-      }
-      else{
-        return std::pair<iterator,iterator>(
-          make_iterator(
-            lower_range(node_type::from_impl(z->left()),z,lower)),
-          make_iterator(
-            upper_range(node_type::from_impl(z->right()),y,upper)));
-      }
-    }
-
-    return std::pair<iterator,iterator>(make_iterator(y),make_iterator(y));
-  }
-
-  template<typename LowerBounder,typename UpperBounder>
-  std::pair<iterator,iterator>
-  range(LowerBounder,UpperBounder upper,lower_unbounded_tag)const
-  {
-    return std::pair<iterator,iterator>(
-      begin(),
-      make_iterator(upper_range(root(),header(),upper)));
-  }
-
-  template<typename LowerBounder,typename UpperBounder>
-  std::pair<iterator,iterator>
-  range(LowerBounder lower,UpperBounder,upper_unbounded_tag)const
-  {
-    return std::pair<iterator,iterator>(
-      make_iterator(lower_range(root(),header(),lower)),
-      end());
-  }
-
-  template<typename LowerBounder,typename UpperBounder>
-  std::pair<iterator,iterator>
-  range(LowerBounder,UpperBounder,both_unbounded_tag)const
-  {
-    return std::pair<iterator,iterator>(begin(),end());
-  }
-
-  template<typename LowerBounder>
-  node_type * lower_range(node_type* top,node_type* y,LowerBounder lower)const
-  {
-    while(top){
-      if(lower(key(top->value()))){
-        y=top;
-        top=node_type::from_impl(top->left());
-      }
-      else top=node_type::from_impl(top->right());
-    }
-
-    return y;
-  }
-
-  template<typename UpperBounder>
-  node_type * upper_range(node_type* top,node_type* y,UpperBounder upper)const
-  {
-    while(top){
-      if(!upper(key(top->value()))){
-        y=top;
-        top=node_type::from_impl(top->left());
-      }
-      else top=node_type::from_impl(top->right());
-    }
-
-    return y;
-  }
-
-#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
-  template<typename Archive>
-  void save_(
-    Archive& ar,const unsigned int version,const index_saver_type& sm,
-    ordered_unique_tag)const
-  {
-    super::save_(ar,version,sm);
-  }
-
-  template<typename Archive>
-  void load_(
-    Archive& ar,const unsigned int version,const index_loader_type& lm,
-    ordered_unique_tag)
-  {
-    super::load_(ar,version,lm);
-  }
-
-  template<typename Archive>
-  void save_(
-    Archive& ar,const unsigned int version,const index_saver_type& sm,
-    ordered_non_unique_tag)const
-  {
-    typedef duplicates_iterator<node_type,value_compare> dup_iterator;
-
-    sm.save(
-      dup_iterator(begin().get_node(),end().get_node(),value_comp()),
-      dup_iterator(end().get_node(),value_comp()),
-      ar,version);
-    super::save_(ar,version,sm);
-  }
-
-  template<typename Archive>
-  void load_(
-    Archive& ar,const unsigned int version,const index_loader_type& lm,
-    ordered_non_unique_tag)
-  {
-    lm.load(
-      ::boost::bind(
-        &ordered_index_impl::rearranger,this,
-        ::boost::arg<1>(),::boost::arg<2>()),
-      ar,version);
-    super::load_(ar,version,lm);
-  }
-
-  void rearranger(node_type* position,node_type *x)
-  {
-    if(!position||comp_(key(position->value()),key(x->value()))){
-      position=lower_bound(key(x->value())).get_node();
-    }
-    else if(comp_(key(x->value()),key(position->value()))){
-      /* inconsistent rearrangement */
-      throw_exception(
-        archive::archive_exception(
-          archive::archive_exception::other_exception));
-    }
-    else node_type::increment(position);
-
-    if(position!=x){
-      node_impl_type::rebalance_for_erase(
-        x->impl(),header()->parent(),header()->left(),header()->right());
-      node_impl_type::restore(
-        x->impl(),position->impl(),header()->impl());
-    }
-  }
-#endif /* serialization */
-
-protected: /* for the benefit of AugmentPolicy::augmented_interface */
-  key_from_value key;
-  key_compare    comp_;
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING)&&\
-    BOOST_WORKAROUND(__MWERKS__,<=0x3003)
-#pragma parse_mfunc_templ reset
-#endif
-};
-
-template<
-  typename KeyFromValue,typename Compare,
-  typename SuperMeta,typename TagList,typename Category,typename AugmentPolicy
->
-class ordered_index:
-  public AugmentPolicy::template augmented_interface<
-    ordered_index_impl<
-      KeyFromValue,Compare,SuperMeta,TagList,Category,AugmentPolicy
-    >
-  >::type
-{
-  typedef typename AugmentPolicy::template
-    augmented_interface<
-      ordered_index_impl<
-        KeyFromValue,Compare,
-        SuperMeta,TagList,Category,AugmentPolicy
-      >
-    >::type                                       super;
-public:
-  typedef typename super::ctor_args_list          ctor_args_list;
-  typedef typename super::allocator_type          allocator_type;
-  typedef typename super::iterator                iterator;
-
-  /* construct/copy/destroy
-   * Default and copy ctors are in the protected section as indices are
-   * not supposed to be created on their own. No range ctor either.
-   */
-
-  ordered_index& operator=(const ordered_index& x)
-  {
-    this->final()=x.final();
-    return *this;
-  }
-
-#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
-  ordered_index& operator=(
-    std::initializer_list<BOOST_DEDUCED_TYPENAME super::value_type> list)
-  {
-    this->final()=list;
-    return *this;
-  }
-#endif
-
-protected:
-  ordered_index(
-    const ctor_args_list& args_list,const allocator_type& al):
-    super(args_list,al){}
-
-  ordered_index(const ordered_index& x):super(x){};
-
-  ordered_index(const ordered_index& x,do_not_copy_elements_tag):
-    super(x,do_not_copy_elements_tag()){};
-};
-
-/* comparison */
-
-template<
-  typename KeyFromValue1,typename Compare1,
-  typename SuperMeta1,typename TagList1,typename Category1,
-  typename AugmentPolicy1,
-  typename KeyFromValue2,typename Compare2,
-  typename SuperMeta2,typename TagList2,typename Category2,
-  typename AugmentPolicy2
->
-bool operator==(
-  const ordered_index<
-    KeyFromValue1,Compare1,SuperMeta1,TagList1,Category1,AugmentPolicy1>& x,
-  const ordered_index<
-    KeyFromValue2,Compare2,SuperMeta2,TagList2,Category2,AugmentPolicy2>& y)
-{
-  return x.size()==y.size()&&std::equal(x.begin(),x.end(),y.begin());
-}
-
-template<
-  typename KeyFromValue1,typename Compare1,
-  typename SuperMeta1,typename TagList1,typename Category1,
-  typename AugmentPolicy1,
-  typename KeyFromValue2,typename Compare2,
-  typename SuperMeta2,typename TagList2,typename Category2,
-  typename AugmentPolicy2
->
-bool operator<(
-  const ordered_index<
-    KeyFromValue1,Compare1,SuperMeta1,TagList1,Category1,AugmentPolicy1>& x,
-  const ordered_index<
-    KeyFromValue2,Compare2,SuperMeta2,TagList2,Category2,AugmentPolicy2>& y)
-{
-  return std::lexicographical_compare(x.begin(),x.end(),y.begin(),y.end());
-}
-
-template<
-  typename KeyFromValue1,typename Compare1,
-  typename SuperMeta1,typename TagList1,typename Category1,
-  typename AugmentPolicy1,
-  typename KeyFromValue2,typename Compare2,
-  typename SuperMeta2,typename TagList2,typename Category2,
-  typename AugmentPolicy2
->
-bool operator!=(
-  const ordered_index<
-    KeyFromValue1,Compare1,SuperMeta1,TagList1,Category1,AugmentPolicy1>& x,
-  const ordered_index<
-    KeyFromValue2,Compare2,SuperMeta2,TagList2,Category2,AugmentPolicy2>& y)
-{
-  return !(x==y);
-}
-
-template<
-  typename KeyFromValue1,typename Compare1,
-  typename SuperMeta1,typename TagList1,typename Category1,
-  typename AugmentPolicy1,
-  typename KeyFromValue2,typename Compare2,
-  typename SuperMeta2,typename TagList2,typename Category2,
-  typename AugmentPolicy2
->
-bool operator>(
-  const ordered_index<
-    KeyFromValue1,Compare1,SuperMeta1,TagList1,Category1,AugmentPolicy1>& x,
-  const ordered_index<
-    KeyFromValue2,Compare2,SuperMeta2,TagList2,Category2,AugmentPolicy2>& y)
-{
-  return y<x;
-}
-
-template<
-  typename KeyFromValue1,typename Compare1,
-  typename SuperMeta1,typename TagList1,typename Category1,
-  typename AugmentPolicy1,
-  typename KeyFromValue2,typename Compare2,
-  typename SuperMeta2,typename TagList2,typename Category2,
-  typename AugmentPolicy2
->
-bool operator>=(
-  const ordered_index<
-    KeyFromValue1,Compare1,SuperMeta1,TagList1,Category1,AugmentPolicy1>& x,
-  const ordered_index<
-    KeyFromValue2,Compare2,SuperMeta2,TagList2,Category2,AugmentPolicy2>& y)
-{
-  return !(x<y);
-}
-
-template<
-  typename KeyFromValue1,typename Compare1,
-  typename SuperMeta1,typename TagList1,typename Category1,
-  typename AugmentPolicy1,
-  typename KeyFromValue2,typename Compare2,
-  typename SuperMeta2,typename TagList2,typename Category2,
-  typename AugmentPolicy2
->
-bool operator<=(
-  const ordered_index<
-    KeyFromValue1,Compare1,SuperMeta1,TagList1,Category1,AugmentPolicy1>& x,
-  const ordered_index<
-    KeyFromValue2,Compare2,SuperMeta2,TagList2,Category2,AugmentPolicy2>& y)
-{
-  return !(x>y);
-}
-
-/*  specialized algorithms */
-
-template<
-  typename KeyFromValue,typename Compare,
-  typename SuperMeta,typename TagList,typename Category,typename AugmentPolicy
->
-void swap(
-  ordered_index<
-    KeyFromValue,Compare,SuperMeta,TagList,Category,AugmentPolicy>& x,
-  ordered_index<
-    KeyFromValue,Compare,SuperMeta,TagList,Category,AugmentPolicy>& y)
-{
-  x.swap(y);
-}
-
-} /* namespace multi_index::detail */
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-/* Boost.Foreach compatibility */
-
-template<
-  typename KeyFromValue,typename Compare,
-  typename SuperMeta,typename TagList,typename Category,typename AugmentPolicy
->
-inline boost::mpl::true_* boost_foreach_is_noncopyable(
-  boost::multi_index::detail::ordered_index<
-    KeyFromValue,Compare,SuperMeta,TagList,Category,AugmentPolicy>*&,
-  boost_foreach_argument_dependent_lookup_hack)
-{
-  return 0;
-}
-
-#undef BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT
-#undef BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT_OF
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/ord_index_impl_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/ord_index_impl_fwd.hpp
deleted file mode 100644
index 6590ef05fdd..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/ord_index_impl_fwd.hpp
+++ /dev/null
@@ -1,128 +0,0 @@
-/* Copyright 2003-2015 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_DETAIL_ORD_INDEX_IMPL_FWD_HPP
-#define BOOST_MULTI_INDEX_DETAIL_ORD_INDEX_IMPL_FWD_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-template<
-  typename KeyFromValue,typename Compare,
-  typename SuperMeta,typename TagList,typename Category,typename AugmentPolicy
->
-class ordered_index;
-
-template<
-  typename KeyFromValue1,typename Compare1,
-  typename SuperMeta1,typename TagList1,typename Category1,
-  typename AugmentPolicy1,
-  typename KeyFromValue2,typename Compare2,
-  typename SuperMeta2,typename TagList2,typename Category2,
-  typename AugmentPolicy2
->
-bool operator==(
-  const ordered_index<
-    KeyFromValue1,Compare1,SuperMeta1,TagList1,Category1,AugmentPolicy1>& x,
-  const ordered_index<
-    KeyFromValue2,Compare2,SuperMeta2,TagList2,Category2,AugmentPolicy2>& y);
-
-template<
-  typename KeyFromValue1,typename Compare1,
-  typename SuperMeta1,typename TagList1,typename Category1,
-  typename AugmentPolicy1,
-  typename KeyFromValue2,typename Compare2,
-  typename SuperMeta2,typename TagList2,typename Category2,
-  typename AugmentPolicy2
->
-bool operator<(
-  const ordered_index<
-    KeyFromValue1,Compare1,SuperMeta1,TagList1,Category1,AugmentPolicy1>& x,
-  const ordered_index<
-    KeyFromValue2,Compare2,SuperMeta2,TagList2,Category2,AugmentPolicy2>& y);
-
-template<
-  typename KeyFromValue1,typename Compare1,
-  typename SuperMeta1,typename TagList1,typename Category1,
-  typename AugmentPolicy1,
-  typename KeyFromValue2,typename Compare2,
-  typename SuperMeta2,typename TagList2,typename Category2,
-  typename AugmentPolicy2
->
-bool operator!=(
-  const ordered_index<
-    KeyFromValue1,Compare1,SuperMeta1,TagList1,Category1,AugmentPolicy1>& x,
-  const ordered_index<
-    KeyFromValue2,Compare2,SuperMeta2,TagList2,Category2,AugmentPolicy2>& y);
-
-template<
-  typename KeyFromValue1,typename Compare1,
-  typename SuperMeta1,typename TagList1,typename Category1,
-  typename AugmentPolicy1,
-  typename KeyFromValue2,typename Compare2,
-  typename SuperMeta2,typename TagList2,typename Category2,
-  typename AugmentPolicy2
->
-bool operator>(
-  const ordered_index<
-    KeyFromValue1,Compare1,SuperMeta1,TagList1,Category1,AugmentPolicy1>& x,
-  const ordered_index<
-    KeyFromValue2,Compare2,SuperMeta2,TagList2,Category2,AugmentPolicy2>& y);
-
-template<
-  typename KeyFromValue1,typename Compare1,
-  typename SuperMeta1,typename TagList1,typename Category1,
-  typename AugmentPolicy1,
-  typename KeyFromValue2,typename Compare2,
-  typename SuperMeta2,typename TagList2,typename Category2,
-  typename AugmentPolicy2
->
-bool operator>=(
-  const ordered_index<
-    KeyFromValue1,Compare1,SuperMeta1,TagList1,Category1,AugmentPolicy1>& x,
-  const ordered_index<
-    KeyFromValue2,Compare2,SuperMeta2,TagList2,Category2,AugmentPolicy2>& y);
-
-template<
-  typename KeyFromValue1,typename Compare1,
-  typename SuperMeta1,typename TagList1,typename Category1,
-  typename AugmentPolicy1,
-  typename KeyFromValue2,typename Compare2,
-  typename SuperMeta2,typename TagList2,typename Category2,
-  typename AugmentPolicy2
->
-bool operator<=(
-  const ordered_index<
-    KeyFromValue1,Compare1,SuperMeta1,TagList1,Category1,AugmentPolicy1>& x,
-  const ordered_index<
-    KeyFromValue2,Compare2,SuperMeta2,TagList2,Category2,AugmentPolicy2>& y);
-
-template<
-  typename KeyFromValue,typename Compare,
-  typename SuperMeta,typename TagList,typename Category,typename AugmentPolicy
->
-void swap(
-  ordered_index<
-    KeyFromValue,Compare,SuperMeta,TagList,Category,AugmentPolicy>& x,
-  ordered_index<
-    KeyFromValue,Compare,SuperMeta,TagList,Category,AugmentPolicy>& y);
-
-} /* namespace multi_index::detail */
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/ord_index_node.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/ord_index_node.hpp
deleted file mode 100644
index e7af0377fb9..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/ord_index_node.hpp
+++ /dev/null
@@ -1,658 +0,0 @@
-/* Copyright 2003-2015 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- *
- * The internal implementation of red-black trees is based on that of SGI STL
- * stl_tree.h file: 
- *
- * Copyright (c) 1996,1997
- * Silicon Graphics Computer Systems, Inc.
- *
- * Permission to use, copy, modify, distribute and sell this software
- * and its documentation for any purpose is hereby granted without fee,
- * provided that the above copyright notice appear in all copies and
- * that both that copyright notice and this permission notice appear
- * in supporting documentation.  Silicon Graphics makes no
- * representations about the suitability of this software for any
- * purpose.  It is provided "as is" without express or implied warranty.
- *
- *
- * Copyright (c) 1994
- * Hewlett-Packard Company
- *
- * Permission to use, copy, modify, distribute and sell this software
- * and its documentation for any purpose is hereby granted without fee,
- * provided that the above copyright notice appear in all copies and
- * that both that copyright notice and this permission notice appear
- * in supporting documentation.  Hewlett-Packard Company makes no
- * representations about the suitability of this software for any
- * purpose.  It is provided "as is" without express or implied warranty.
- *
- */
-
-#ifndef BOOST_MULTI_INDEX_DETAIL_ORD_INDEX_NODE_HPP
-#define BOOST_MULTI_INDEX_DETAIL_ORD_INDEX_NODE_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <cstddef>
-#include <boost/detail/allocator_utilities.hpp>
-#include <boost/multi_index/detail/raw_ptr.hpp>
-
-#if !defined(BOOST_MULTI_INDEX_DISABLE_COMPRESSED_ORDERED_INDEX_NODES)
-#include <boost/mpl/and.hpp>
-#include <boost/mpl/if.hpp>
-#include <boost/multi_index/detail/uintptr_type.hpp>
-#include <boost/type_traits/alignment_of.hpp>
-#include <boost/type_traits/is_same.hpp>
-#endif
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-/* definition of red-black nodes for ordered_index */
-
-enum ordered_index_color{red=false,black=true};
-enum ordered_index_side{to_left=false,to_right=true};
-
-template<typename AugmentPolicy,typename Allocator>
-struct ordered_index_node_impl; /* fwd decl. */
-
-template<typename AugmentPolicy,typename Allocator>
-struct ordered_index_node_std_base
-{
-  typedef typename
-  boost::detail::allocator::rebind_to<
-    Allocator,
-    ordered_index_node_impl<AugmentPolicy,Allocator>
-  >::type::pointer                                   pointer;
-  typedef typename
-  boost::detail::allocator::rebind_to<
-    Allocator,
-    ordered_index_node_impl<AugmentPolicy,Allocator>
-  >::type::const_pointer                             const_pointer;
-  typedef ordered_index_color&                       color_ref;
-  typedef pointer&                                   parent_ref;
-
-  ordered_index_color& color(){return color_;}
-  ordered_index_color  color()const{return color_;}
-  pointer&             parent(){return parent_;}
-  pointer              parent()const{return parent_;}
-  pointer&             left(){return left_;}
-  pointer              left()const{return left_;}
-  pointer&             right(){return right_;}
-  pointer              right()const{return right_;}
-
-private:
-  ordered_index_color color_; 
-  pointer             parent_;
-  pointer             left_;
-  pointer             right_;
-};
-
-#if !defined(BOOST_MULTI_INDEX_DISABLE_COMPRESSED_ORDERED_INDEX_NODES)
-/* If ordered_index_node_impl has even alignment, we can use the least
- * significant bit of one of the ordered_index_node_impl pointers to
- * store color information. This typically reduces the size of
- * ordered_index_node_impl by 25%.
- */
-
-#if defined(BOOST_MSVC)
-/* This code casts pointers to an integer type that has been computed
- * to be large enough to hold the pointer, however the metaprogramming
- * logic is not always spotted by the VC++ code analyser that issues a
- * long list of warnings.
- */
-
-#pragma warning(push)
-#pragma warning(disable:4312 4311)
-#endif
-
-template<typename AugmentPolicy,typename Allocator>
-struct ordered_index_node_compressed_base
-{
-  typedef ordered_index_node_impl<
-    AugmentPolicy,Allocator>*            pointer;
-  typedef const ordered_index_node_impl<
-    AugmentPolicy,Allocator>*            const_pointer;
-
-  struct color_ref
-  {
-    color_ref(uintptr_type* r_):r(r_){}
-    
-    operator ordered_index_color()const
-    {
-      return ordered_index_color(*r&uintptr_type(1));
-    }
-    
-    color_ref& operator=(ordered_index_color c)
-    {
-      *r&=~uintptr_type(1);
-      *r|=uintptr_type(c);
-      return *this;
-    }
-    
-    color_ref& operator=(const color_ref& x)
-    {
-      return operator=(x.operator ordered_index_color());
-    }
-    
-  private:
-    uintptr_type* r;
-  };
-  
-  struct parent_ref
-  {
-    parent_ref(uintptr_type* r_):r(r_){}
-    
-    operator pointer()const
-    {
-      return (pointer)(void*)(*r&~uintptr_type(1));
-    }
-    
-    parent_ref& operator=(pointer p)
-    {
-      *r=((uintptr_type)(void*)p)|(*r&uintptr_type(1));
-      return *this;
-    }
-    
-    parent_ref& operator=(const parent_ref& x)
-    {
-      return operator=(x.operator pointer());
-    }
-
-    pointer operator->()const
-    {
-      return operator pointer();
-    }
-
-  private:
-    uintptr_type* r;
-  };
-  
-  color_ref           color(){return color_ref(&parentcolor_);}
-  ordered_index_color color()const
-  {
-    return ordered_index_color(parentcolor_&uintptr_type(1));
-  }
-
-  parent_ref parent(){return parent_ref(&parentcolor_);}
-  pointer    parent()const
-  {
-    return (pointer)(void*)(parentcolor_&~uintptr_type(1));
-  }
-
-  pointer& left(){return left_;}
-  pointer  left()const{return left_;}
-  pointer& right(){return right_;}
-  pointer  right()const{return right_;}
-
-private:
-  uintptr_type parentcolor_;
-  pointer      left_;
-  pointer      right_;
-};
-#if defined(BOOST_MSVC)
-#pragma warning(pop)
-#endif
-#endif
-
-template<typename AugmentPolicy,typename Allocator>
-struct ordered_index_node_impl_base:
-
-#if !defined(BOOST_MULTI_INDEX_DISABLE_COMPRESSED_ORDERED_INDEX_NODES)
-  AugmentPolicy::template augmented_node<
-    typename mpl::if_c<
-      !(has_uintptr_type::value)||
-      (alignment_of<
-        ordered_index_node_compressed_base<AugmentPolicy,Allocator>
-       >::value%2)||
-      !(is_same<
-        typename boost::detail::allocator::rebind_to<
-          Allocator,
-          ordered_index_node_impl<AugmentPolicy,Allocator>
-        >::type::pointer,
-        ordered_index_node_impl<AugmentPolicy,Allocator>*>::value),
-      ordered_index_node_std_base<AugmentPolicy,Allocator>,
-      ordered_index_node_compressed_base<AugmentPolicy,Allocator>
-    >::type
-  >::type
-#else
-  AugmentPolicy::template augmented_node<
-    ordered_index_node_std_base<AugmentPolicy,Allocator>
-  >::type
-#endif
-
-{};
-
-template<typename AugmentPolicy,typename Allocator>
-struct ordered_index_node_impl:
-  ordered_index_node_impl_base<AugmentPolicy,Allocator>
-{
-private:
-  typedef ordered_index_node_impl_base<AugmentPolicy,Allocator> super;
-
-public:
-  typedef typename super::color_ref                             color_ref;
-  typedef typename super::parent_ref                            parent_ref;
-  typedef typename super::pointer                               pointer;
-  typedef typename super::const_pointer                         const_pointer;
-
-  /* interoperability with bidir_node_iterator */
-
-  static void increment(pointer& x)
-  {
-    if(x->right()!=pointer(0)){
-      x=x->right();
-      while(x->left()!=pointer(0))x=x->left();
-    }
-    else{
-      pointer y=x->parent();
-      while(x==y->right()){
-        x=y;
-        y=y->parent();
-      }
-      if(x->right()!=y)x=y;
-    }
-  }
-
-  static void decrement(pointer& x)
-  {
-    if(x->color()==red&&x->parent()->parent()==x){
-      x=x->right();
-    }
-    else if(x->left()!=pointer(0)){
-      pointer y=x->left();
-      while(y->right()!=pointer(0))y=y->right();
-      x=y;
-    }else{
-      pointer y=x->parent();
-      while(x==y->left()){
-        x=y;
-        y=y->parent();
-      }
-      x=y;
-    }
-  }
-
-  /* algorithmic stuff */
-
-  static void rotate_left(pointer x,parent_ref root)
-  {
-    pointer y=x->right();
-    x->right()=y->left();
-    if(y->left()!=pointer(0))y->left()->parent()=x;
-    y->parent()=x->parent();
-    
-    if(x==root)                    root=y;
-    else if(x==x->parent()->left())x->parent()->left()=y;
-    else                           x->parent()->right()=y;
-    y->left()=x;
-    x->parent()=y;
-    AugmentPolicy::rotate_left(x,y);
-  }
-
-  static pointer minimum(pointer x)
-  {
-    while(x->left()!=pointer(0))x=x->left();
-    return x;
-  }
-
-  static pointer maximum(pointer x)
-  {
-    while(x->right()!=pointer(0))x=x->right();
-    return x;
-  }
-
-  static void rotate_right(pointer x,parent_ref root)
-  {
-    pointer y=x->left();
-    x->left()=y->right();
-    if(y->right()!=pointer(0))y->right()->parent()=x;
-    y->parent()=x->parent();
-
-    if(x==root)                     root=y;
-    else if(x==x->parent()->right())x->parent()->right()=y;
-    else                            x->parent()->left()=y;
-    y->right()=x;
-    x->parent()=y;
-    AugmentPolicy::rotate_right(x,y);
-  }
-
-  static void rebalance(pointer x,parent_ref root)
-  {
-    x->color()=red;
-    while(x!=root&&x->parent()->color()==red){
-      if(x->parent()==x->parent()->parent()->left()){
-        pointer y=x->parent()->parent()->right();
-        if(y!=pointer(0)&&y->color()==red){
-          x->parent()->color()=black;
-          y->color()=black;
-          x->parent()->parent()->color()=red;
-          x=x->parent()->parent();
-        }
-        else{
-          if(x==x->parent()->right()){
-            x=x->parent();
-            rotate_left(x,root);
-          }
-          x->parent()->color()=black;
-          x->parent()->parent()->color()=red;
-          rotate_right(x->parent()->parent(),root);
-        }
-      }
-      else{
-        pointer y=x->parent()->parent()->left();
-        if(y!=pointer(0)&&y->color()==red){
-          x->parent()->color()=black;
-          y->color()=black;
-          x->parent()->parent()->color()=red;
-          x=x->parent()->parent();
-        }
-        else{
-          if(x==x->parent()->left()){
-            x=x->parent();
-            rotate_right(x,root);
-          }
-          x->parent()->color()=black;
-          x->parent()->parent()->color()=red;
-          rotate_left(x->parent()->parent(),root);
-        }
-      }
-    }
-    root->color()=black;
-  }
-
-  static void link(
-    pointer x,ordered_index_side side,pointer position,pointer header)
-  {
-    if(side==to_left){
-      position->left()=x;  /* also makes leftmost=x when parent==header */
-      if(position==header){
-        header->parent()=x;
-        header->right()=x;
-      }
-      else if(position==header->left()){
-        header->left()=x;  /* maintain leftmost pointing to min node */
-      }
-    }
-    else{
-      position->right()=x;
-      if(position==header->right()){
-        header->right()=x; /* maintain rightmost pointing to max node */
-      }
-    }
-    x->parent()=position;
-    x->left()=pointer(0);
-    x->right()=pointer(0);
-    AugmentPolicy::add(x,pointer(header->parent()));
-    ordered_index_node_impl::rebalance(x,header->parent());
-  }
-
-  static pointer rebalance_for_erase(
-    pointer z,parent_ref root,pointer& leftmost,pointer& rightmost)
-  {
-    pointer y=z;
-    pointer x=pointer(0);
-    pointer x_parent=pointer(0);
-    if(y->left()==pointer(0)){    /* z has at most one non-null child. y==z. */
-      x=y->right();               /* x might be null */
-    }
-    else{
-      if(y->right()==pointer(0)){ /* z has exactly one non-null child. y==z. */
-        x=y->left();              /* x is not null */
-      }
-      else{                       /* z has two non-null children.  Set y to */
-        y=y->right();             /* z's successor. x might be null.        */
-        while(y->left()!=pointer(0))y=y->left();
-        x=y->right();
-      }
-    }
-    AugmentPolicy::remove(y,pointer(root));
-    if(y!=z){
-      AugmentPolicy::copy(z,y);
-      z->left()->parent()=y;   /* relink y in place of z. y is z's successor */
-      y->left()=z->left();
-      if(y!=z->right()){
-        x_parent=y->parent();
-        if(x!=pointer(0))x->parent()=y->parent();
-        y->parent()->left()=x; /* y must be a child of left */
-        y->right()=z->right();
-        z->right()->parent()=y;
-      }
-      else{
-        x_parent=y;
-      }
-
-      if(root==z)                    root=y;
-      else if(z->parent()->left()==z)z->parent()->left()=y;
-      else                           z->parent()->right()=y;
-      y->parent()=z->parent();
-      ordered_index_color c=y->color();
-      y->color()=z->color();
-      z->color()=c;
-      y=z;                    /* y now points to node to be actually deleted */
-    }
-    else{                     /* y==z */
-      x_parent=y->parent();
-      if(x!=pointer(0))x->parent()=y->parent();   
-      if(root==z){
-        root=x;
-      }
-      else{
-        if(z->parent()->left()==z)z->parent()->left()=x;
-        else                      z->parent()->right()=x;
-      }
-      if(leftmost==z){
-        if(z->right()==pointer(0)){ /* z->left() must be null also */
-          leftmost=z->parent();
-        }
-        else{              
-          leftmost=minimum(x);      /* makes leftmost==header if z==root */
-        }
-      }
-      if(rightmost==z){
-        if(z->left()==pointer(0)){  /* z->right() must be null also */
-          rightmost=z->parent();
-        }
-        else{                   /* x==z->left() */
-          rightmost=maximum(x); /* makes rightmost==header if z==root */
-        }
-      }
-    }
-    if(y->color()!=red){
-      while(x!=root&&(x==pointer(0)|| x->color()==black)){
-        if(x==x_parent->left()){
-          pointer w=x_parent->right();
-          if(w->color()==red){
-            w->color()=black;
-            x_parent->color()=red;
-            rotate_left(x_parent,root);
-            w=x_parent->right();
-          }
-          if((w->left()==pointer(0)||w->left()->color()==black) &&
-             (w->right()==pointer(0)||w->right()->color()==black)){
-            w->color()=red;
-            x=x_parent;
-            x_parent=x_parent->parent();
-          } 
-          else{
-            if(w->right()==pointer(0 )
-                || w->right()->color()==black){
-              if(w->left()!=pointer(0)) w->left()->color()=black;
-              w->color()=red;
-              rotate_right(w,root);
-              w=x_parent->right();
-            }
-            w->color()=x_parent->color();
-            x_parent->color()=black;
-            if(w->right()!=pointer(0))w->right()->color()=black;
-            rotate_left(x_parent,root);
-            break;
-          }
-        } 
-        else{                   /* same as above,with right <-> left */
-          pointer w=x_parent->left();
-          if(w->color()==red){
-            w->color()=black;
-            x_parent->color()=red;
-            rotate_right(x_parent,root);
-            w=x_parent->left();
-          }
-          if((w->right()==pointer(0)||w->right()->color()==black) &&
-             (w->left()==pointer(0)||w->left()->color()==black)){
-            w->color()=red;
-            x=x_parent;
-            x_parent=x_parent->parent();
-          }
-          else{
-            if(w->left()==pointer(0)||w->left()->color()==black){
-              if(w->right()!=pointer(0))w->right()->color()=black;
-              w->color()=red;
-              rotate_left(w,root);
-              w=x_parent->left();
-            }
-            w->color()=x_parent->color();
-            x_parent->color()=black;
-            if(w->left()!=pointer(0))w->left()->color()=black;
-            rotate_right(x_parent,root);
-            break;
-          }
-        }
-      }
-      if(x!=pointer(0))x->color()=black;
-    }
-    return y;
-  }
-
-  static void restore(pointer x,pointer position,pointer header)
-  {
-    if(position->left()==pointer(0)||position->left()==header){
-      link(x,to_left,position,header);
-    }
-    else{
-      decrement(position);
-      link(x,to_right,position,header);
-    }
-  }
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING)
-  /* invariant stuff */
-
-  static std::size_t black_count(pointer node,pointer root)
-  {
-    if(node==pointer(0))return 0;
-    std::size_t sum=0;
-    for(;;){
-      if(node->color()==black)++sum;
-      if(node==root)break;
-      node=node->parent();
-    } 
-    return sum;
-  }
-#endif
-};
-
-template<typename AugmentPolicy,typename Super>
-struct ordered_index_node_trampoline:
-  ordered_index_node_impl<
-    AugmentPolicy,
-    typename boost::detail::allocator::rebind_to<
-      typename Super::allocator_type,
-      char
-    >::type
-  >
-{
-  typedef ordered_index_node_impl<
-    AugmentPolicy,
-    typename boost::detail::allocator::rebind_to<
-      typename Super::allocator_type,
-      char
-    >::type
-  > impl_type;
-};
-
-template<typename AugmentPolicy,typename Super>
-struct ordered_index_node:
-  Super,ordered_index_node_trampoline<AugmentPolicy,Super>
-{
-private:
-  typedef ordered_index_node_trampoline<AugmentPolicy,Super> trampoline;
-
-public:
-  typedef typename trampoline::impl_type     impl_type;
-  typedef typename trampoline::color_ref     impl_color_ref;
-  typedef typename trampoline::parent_ref    impl_parent_ref;
-  typedef typename trampoline::pointer       impl_pointer;
-  typedef typename trampoline::const_pointer const_impl_pointer;
-
-  impl_color_ref      color(){return trampoline::color();}
-  ordered_index_color color()const{return trampoline::color();}
-  impl_parent_ref     parent(){return trampoline::parent();}
-  impl_pointer        parent()const{return trampoline::parent();}
-  impl_pointer&       left(){return trampoline::left();}
-  impl_pointer        left()const{return trampoline::left();}
-  impl_pointer&       right(){return trampoline::right();}
-  impl_pointer        right()const{return trampoline::right();}
-
-  impl_pointer impl()
-  {
-    return static_cast<impl_pointer>(
-      static_cast<impl_type*>(static_cast<trampoline*>(this)));
-  }
-
-  const_impl_pointer impl()const
-  {
-    return static_cast<const_impl_pointer>(
-      static_cast<const impl_type*>(static_cast<const trampoline*>(this)));
-  }
-
-  static ordered_index_node* from_impl(impl_pointer x)
-  {
-    return
-      static_cast<ordered_index_node*>(
-        static_cast<trampoline*>(
-          raw_ptr<impl_type*>(x)));
-  }
-
-  static const ordered_index_node* from_impl(const_impl_pointer x)
-  {
-    return
-      static_cast<const ordered_index_node*>(
-        static_cast<const trampoline*>(
-          raw_ptr<const impl_type*>(x)));
-  }
-
-  /* interoperability with bidir_node_iterator */
-
-  static void increment(ordered_index_node*& x)
-  {
-    impl_pointer xi=x->impl();
-    trampoline::increment(xi);
-    x=from_impl(xi);
-  }
-
-  static void decrement(ordered_index_node*& x)
-  {
-    impl_pointer xi=x->impl();
-    trampoline::decrement(xi);
-    x=from_impl(xi);
-  }
-};
-
-} /* namespace multi_index::detail */
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/ord_index_ops.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/ord_index_ops.hpp
deleted file mode 100644
index 84d5cacae19..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/ord_index_ops.hpp
+++ /dev/null
@@ -1,266 +0,0 @@
-/* Copyright 2003-2014 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- *
- * The internal implementation of red-black trees is based on that of SGI STL
- * stl_tree.h file: 
- *
- * Copyright (c) 1996,1997
- * Silicon Graphics Computer Systems, Inc.
- *
- * Permission to use, copy, modify, distribute and sell this software
- * and its documentation for any purpose is hereby granted without fee,
- * provided that the above copyright notice appear in all copies and
- * that both that copyright notice and this permission notice appear
- * in supporting documentation.  Silicon Graphics makes no
- * representations about the suitability of this software for any
- * purpose.  It is provided "as is" without express or implied warranty.
- *
- *
- * Copyright (c) 1994
- * Hewlett-Packard Company
- *
- * Permission to use, copy, modify, distribute and sell this software
- * and its documentation for any purpose is hereby granted without fee,
- * provided that the above copyright notice appear in all copies and
- * that both that copyright notice and this permission notice appear
- * in supporting documentation.  Hewlett-Packard Company makes no
- * representations about the suitability of this software for any
- * purpose.  It is provided "as is" without express or implied warranty.
- *
- */
-
-#ifndef BOOST_MULTI_INDEX_DETAIL_ORD_INDEX_OPS_HPP
-#define BOOST_MULTI_INDEX_DETAIL_ORD_INDEX_OPS_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <boost/mpl/and.hpp>
-#include <boost/multi_index/detail/promotes_arg.hpp>
-#include <utility>
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-/* Common code for index memfuns having templatized and
- * non-templatized versions.
- * Implementation note: When CompatibleKey is consistently promoted to
- * KeyFromValue::result_type for comparison, the promotion is made once in
- * advance to increase efficiency.
- */
-
-template<
-  typename Node,typename KeyFromValue,
-  typename CompatibleKey,typename CompatibleCompare
->
-inline Node* ordered_index_find(
-  Node* top,Node* y,const KeyFromValue& key,const CompatibleKey& x,
-  const CompatibleCompare& comp)
-{
-  typedef typename KeyFromValue::result_type key_type;
-
-  return ordered_index_find(
-    top,y,key,x,comp,
-    mpl::and_<
-      promotes_1st_arg<CompatibleCompare,CompatibleKey,key_type>,
-      promotes_2nd_arg<CompatibleCompare,key_type,CompatibleKey> >());
-}
-
-template<
-  typename Node,typename KeyFromValue,
-  typename CompatibleCompare
->
-inline Node* ordered_index_find(
-  Node* top,Node* y,const KeyFromValue& key,
-  const BOOST_DEDUCED_TYPENAME KeyFromValue::result_type& x,
-  const CompatibleCompare& comp,mpl::true_)
-{
-  return ordered_index_find(top,y,key,x,comp,mpl::false_());
-}
-
-template<
-  typename Node,typename KeyFromValue,
-  typename CompatibleKey,typename CompatibleCompare
->
-inline Node* ordered_index_find(
-  Node* top,Node* y,const KeyFromValue& key,const CompatibleKey& x,
-  const CompatibleCompare& comp,mpl::false_)
-{
-  Node* y0=y;
-
-  while (top){
-    if(!comp(key(top->value()),x)){
-      y=top;
-      top=Node::from_impl(top->left());
-    }
-    else top=Node::from_impl(top->right());
-  }
-    
-  return (y==y0||comp(x,key(y->value())))?y0:y;
-}
-
-template<
-  typename Node,typename KeyFromValue,
-  typename CompatibleKey,typename CompatibleCompare
->
-inline Node* ordered_index_lower_bound(
-  Node* top,Node* y,const KeyFromValue& key,const CompatibleKey& x,
-  const CompatibleCompare& comp)
-{
-  typedef typename KeyFromValue::result_type key_type;
-
-  return ordered_index_lower_bound(
-    top,y,key,x,comp,
-    promotes_2nd_arg<CompatibleCompare,key_type,CompatibleKey>());
-}
-
-template<
-  typename Node,typename KeyFromValue,
-  typename CompatibleCompare
->
-inline Node* ordered_index_lower_bound(
-  Node* top,Node* y,const KeyFromValue& key,
-  const BOOST_DEDUCED_TYPENAME KeyFromValue::result_type& x,
-  const CompatibleCompare& comp,mpl::true_)
-{
-  return ordered_index_lower_bound(top,y,key,x,comp,mpl::false_());
-}
-
-template<
-  typename Node,typename KeyFromValue,
-  typename CompatibleKey,typename CompatibleCompare
->
-inline Node* ordered_index_lower_bound(
-  Node* top,Node* y,const KeyFromValue& key,const CompatibleKey& x,
-  const CompatibleCompare& comp,mpl::false_)
-{
-  while(top){
-    if(!comp(key(top->value()),x)){
-      y=top;
-      top=Node::from_impl(top->left());
-    }
-    else top=Node::from_impl(top->right());
-  }
-
-  return y;
-}
-
-template<
-  typename Node,typename KeyFromValue,
-  typename CompatibleKey,typename CompatibleCompare
->
-inline Node* ordered_index_upper_bound(
-  Node* top,Node* y,const KeyFromValue& key,const CompatibleKey& x,
-  const CompatibleCompare& comp)
-{
-  typedef typename KeyFromValue::result_type key_type;
-
-  return ordered_index_upper_bound(
-    top,y,key,x,comp,
-    promotes_1st_arg<CompatibleCompare,CompatibleKey,key_type>());
-}
-
-template<
-  typename Node,typename KeyFromValue,
-  typename CompatibleCompare
->
-inline Node* ordered_index_upper_bound(
-  Node* top,Node* y,const KeyFromValue& key,
-  const BOOST_DEDUCED_TYPENAME KeyFromValue::result_type& x,
-  const CompatibleCompare& comp,mpl::true_)
-{
-  return ordered_index_upper_bound(top,y,key,x,comp,mpl::false_());
-}
-
-template<
-  typename Node,typename KeyFromValue,
-  typename CompatibleKey,typename CompatibleCompare
->
-inline Node* ordered_index_upper_bound(
-  Node* top,Node* y,const KeyFromValue& key,const CompatibleKey& x,
-  const CompatibleCompare& comp,mpl::false_)
-{
-  while(top){
-    if(comp(x,key(top->value()))){
-      y=top;
-      top=Node::from_impl(top->left());
-    }
-    else top=Node::from_impl(top->right());
-  }
-
-  return y;
-}
-
-template<
-  typename Node,typename KeyFromValue,
-  typename CompatibleKey,typename CompatibleCompare
->
-inline std::pair<Node*,Node*> ordered_index_equal_range(
-  Node* top,Node* y,const KeyFromValue& key,const CompatibleKey& x,
-  const CompatibleCompare& comp)
-{
-  typedef typename KeyFromValue::result_type key_type;
-
-  return ordered_index_equal_range(
-    top,y,key,x,comp,
-    mpl::and_<
-      promotes_1st_arg<CompatibleCompare,CompatibleKey,key_type>,
-      promotes_2nd_arg<CompatibleCompare,key_type,CompatibleKey> >());
-}
-
-template<
-  typename Node,typename KeyFromValue,
-  typename CompatibleCompare
->
-inline std::pair<Node*,Node*> ordered_index_equal_range(
-  Node* top,Node* y,const KeyFromValue& key,
-  const BOOST_DEDUCED_TYPENAME KeyFromValue::result_type& x,
-  const CompatibleCompare& comp,mpl::true_)
-{
-  return ordered_index_equal_range(top,y,key,x,comp,mpl::false_());
-}
-
-template<
-  typename Node,typename KeyFromValue,
-  typename CompatibleKey,typename CompatibleCompare
->
-inline std::pair<Node*,Node*> ordered_index_equal_range(
-  Node* top,Node* y,const KeyFromValue& key,const CompatibleKey& x,
-  const CompatibleCompare& comp,mpl::false_)
-{
-  while(top){
-    if(comp(key(top->value()),x)){
-      top=Node::from_impl(top->right());
-    }
-    else if(comp(x,key(top->value()))){
-      y=top;
-      top=Node::from_impl(top->left());
-    }
-    else{
-      return std::pair<Node*,Node*>(
-        ordered_index_lower_bound(
-          Node::from_impl(top->left()),top,key,x,comp,mpl::false_()),
-        ordered_index_upper_bound(
-          Node::from_impl(top->right()),y,key,x,comp,mpl::false_()));
-    }
-  }
-
-  return std::pair<Node*,Node*>(y,y);
-}
-
-} /* namespace multi_index::detail */
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/promotes_arg.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/promotes_arg.hpp
deleted file mode 100644
index 7a11b6e9fbe..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/promotes_arg.hpp
+++ /dev/null
@@ -1,83 +0,0 @@
-/* Copyright 2003-2017 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_DETAIL_PROMOTES_ARG_HPP
-#define BOOST_MULTI_INDEX_DETAIL_PROMOTES_ARG_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <boost/detail/workaround.hpp>
-
-/* Metafunctions to check if f(arg1,arg2) promotes either arg1 to the type of
- * arg2 or viceversa. By default, (i.e. if it cannot be determined), no
- * promotion is assumed.
- */
-
-#if BOOST_WORKAROUND(BOOST_MSVC,<1400)
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-template<typename F,typename Arg1,typename Arg2>
-struct promotes_1st_arg:mpl::false_{};
-
-template<typename F,typename Arg1,typename Arg2>
-struct promotes_2nd_arg:mpl::false_{};
-
-} /* namespace multi_index::detail */
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#else
-
-#include <boost/mpl/and.hpp>
-#include <boost/mpl/bool.hpp>
-#include <boost/mpl/not.hpp>
-#include <boost/multi_index/detail/is_transparent.hpp>
-#include <boost/type_traits/is_convertible.hpp>
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-  
-template<typename F,typename Arg1,typename Arg2>
-struct promotes_1st_arg:
-  mpl::and_<
-    mpl::not_<is_transparent<F,Arg1,Arg2> >,
-    is_convertible<const Arg1,Arg2>,
-    is_transparent<F,Arg2,Arg2>
-  >
-{};
-
-template<typename F,typename Arg1,typename Arg2>
-struct promotes_2nd_arg:
-  mpl::and_<
-    mpl::not_<is_transparent<F,Arg1,Arg2> >,
-    is_convertible<const Arg2,Arg1>,
-    is_transparent<F,Arg1,Arg1>
-  >
-{};
-
-} /* namespace multi_index::detail */
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/raw_ptr.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/raw_ptr.hpp
deleted file mode 100644
index c32007435c0..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/raw_ptr.hpp
+++ /dev/null
@@ -1,52 +0,0 @@
-/* Copyright 2003-2015 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_DETAIL_RAW_PTR_HPP
-#define BOOST_MULTI_INDEX_DETAIL_RAW_PTR_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <boost/mpl/bool.hpp>
-#include <boost/type_traits/is_same.hpp>
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-/* gets the underlying pointer of a pointer-like value */
-
-template<typename RawPointer>
-inline RawPointer raw_ptr(RawPointer const& p,mpl::true_)
-{
-  return p;
-}
-
-template<typename RawPointer,typename Pointer>
-inline RawPointer raw_ptr(Pointer const& p,mpl::false_)
-{
-  return p==Pointer(0)?0:&*p;
-}
-
-template<typename RawPointer,typename Pointer>
-inline RawPointer raw_ptr(Pointer const& p)
-{
-  return raw_ptr<RawPointer>(p,is_same<RawPointer,Pointer>());
-}
-
-} /* namespace multi_index::detail */
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/restore_wstrict_aliasing.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/restore_wstrict_aliasing.hpp
deleted file mode 100644
index ee2c799d5a8..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/restore_wstrict_aliasing.hpp
+++ /dev/null
@@ -1,11 +0,0 @@
-/* Copyright 2003-2016 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#define BOOST_MULTI_INDEX_DETAIL_RESTORE_WSTRICT_ALIASING
-#include <boost/multi_index/detail/ignore_wstrict_aliasing.hpp>
-#undef BOOST_MULTI_INDEX_DETAIL_RESTORE_WSTRICT_ALIASING
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/rnd_index_loader.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/rnd_index_loader.hpp
deleted file mode 100644
index 4b00345a6d9..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/rnd_index_loader.hpp
+++ /dev/null
@@ -1,173 +0,0 @@
-/* Copyright 2003-2013 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_DETAIL_RND_INDEX_LOADER_HPP
-#define BOOST_MULTI_INDEX_DETAIL_RND_INDEX_LOADER_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <algorithm>
-#include <boost/detail/allocator_utilities.hpp>
-#include <boost/multi_index/detail/auto_space.hpp>
-#include <boost/multi_index/detail/rnd_index_ptr_array.hpp>
-#include <boost/noncopyable.hpp>
-#include <cstddef>
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-/* This class implements a serialization rearranger for random access
- * indices. In order to achieve O(n) performance, the following strategy
- * is followed: the nodes of the index are handled as if in a bidirectional
- * list, where the next pointers are stored in the original
- * random_access_index_ptr_array and the prev pointers are stored in
- * an auxiliary array. Rearranging of nodes in such a bidirectional list
- * is constant time. Once all the arrangements are performed (on destruction
- * time) the list is traversed in reverse order and
- * pointers are swapped and set accordingly so that they recover its
- * original semantics ( *(node->up())==node ) while retaining the
- * new order.
- */
-
-template<typename Allocator>
-class random_access_index_loader_base:private noncopyable
-{
-protected:
-  typedef random_access_index_node_impl<
-    typename boost::detail::allocator::rebind_to<
-      Allocator,
-      char
-    >::type
-  >                                                 node_impl_type;
-  typedef typename node_impl_type::pointer          node_impl_pointer;
-  typedef random_access_index_ptr_array<Allocator>  ptr_array;
-
-  random_access_index_loader_base(const Allocator& al_,ptr_array& ptrs_):
-    al(al_),
-    ptrs(ptrs_),
-    header(*ptrs.end()),
-    prev_spc(al,0),
-    preprocessed(false)
-  {}
-
-  ~random_access_index_loader_base()
-  {
-    if(preprocessed)
-    {
-      node_impl_pointer n=header;
-      next(n)=n;
-
-      for(std::size_t i=ptrs.size();i--;){
-        n=prev(n);
-        std::size_t d=position(n);
-        if(d!=i){
-          node_impl_pointer m=prev(next_at(i));
-          std::swap(m->up(),n->up());
-          next_at(d)=next_at(i);
-          std::swap(prev_at(d),prev_at(i));
-        }
-        next(n)=n;
-      }
-    }
-  }
-
-  void rearrange(node_impl_pointer position_,node_impl_pointer x)
-  {
-    preprocess(); /* only incur this penalty if rearrange() is ever called */
-    if(position_==node_impl_pointer(0))position_=header;
-    next(prev(x))=next(x);
-    prev(next(x))=prev(x);
-    prev(x)=position_;
-    next(x)=next(position_);
-    next(prev(x))=prev(next(x))=x;
-  }
-
-private:
-  void preprocess()
-  {
-    if(!preprocessed){
-      /* get space for the auxiliary prev array */
-      auto_space<node_impl_pointer,Allocator> tmp(al,ptrs.size()+1);
-      prev_spc.swap(tmp);
-
-      /* prev_spc elements point to the prev nodes */
-      std::rotate_copy(
-        &*ptrs.begin(),&*ptrs.end(),&*ptrs.end()+1,&*prev_spc.data());
-
-      /* ptrs elements point to the next nodes */
-      std::rotate(&*ptrs.begin(),&*ptrs.begin()+1,&*ptrs.end()+1);
-
-      preprocessed=true;
-    }
-  }
-
-  std::size_t position(node_impl_pointer x)const
-  {
-    return (std::size_t)(x->up()-ptrs.begin());
-  }
-
-  node_impl_pointer& next_at(std::size_t n)const
-  {
-    return *ptrs.at(n);
-  }
-
-  node_impl_pointer& prev_at(std::size_t n)const
-  {
-    return *(prev_spc.data()+n);
-  }
-
-  node_impl_pointer& next(node_impl_pointer x)const
-  {
-    return *(x->up());
-  }
-
-  node_impl_pointer& prev(node_impl_pointer x)const
-  {
-    return prev_at(position(x));
-  }
-
-  Allocator                               al;
-  ptr_array&                              ptrs;
-  node_impl_pointer                       header;
-  auto_space<node_impl_pointer,Allocator> prev_spc;
-  bool                                    preprocessed;
-};
-
-template<typename Node,typename Allocator>
-class random_access_index_loader:
-  private random_access_index_loader_base<Allocator>
-{
-  typedef random_access_index_loader_base<Allocator> super;
-  typedef typename super::node_impl_pointer          node_impl_pointer;
-  typedef typename super::ptr_array                  ptr_array;
-
-public:
-  random_access_index_loader(const Allocator& al_,ptr_array& ptrs_):
-    super(al_,ptrs_)
-  {}
-
-  void rearrange(Node* position_,Node *x)
-  {
-    super::rearrange(
-      position_?position_->impl():node_impl_pointer(0),x->impl());
-  }
-};
-
-} /* namespace multi_index::detail */
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/rnd_index_node.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/rnd_index_node.hpp
deleted file mode 100644
index ad61ea25dda..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/rnd_index_node.hpp
+++ /dev/null
@@ -1,273 +0,0 @@
-/* Copyright 2003-2015 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_DETAIL_RND_INDEX_NODE_HPP
-#define BOOST_MULTI_INDEX_DETAIL_RND_INDEX_NODE_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <algorithm>
-#include <boost/detail/allocator_utilities.hpp>
-#include <boost/integer/common_factor_rt.hpp>
-#include <boost/multi_index/detail/raw_ptr.hpp>
-#include <cstddef>
-#include <functional>
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-template<typename Allocator>
-struct random_access_index_node_impl
-{
-  typedef typename
-  boost::detail::allocator::rebind_to<
-    Allocator,random_access_index_node_impl
-  >::type::pointer                          pointer;
-  typedef typename
-  boost::detail::allocator::rebind_to<
-    Allocator,random_access_index_node_impl
-  >::type::const_pointer                    const_pointer;
-  typedef typename
-  boost::detail::allocator::rebind_to<
-    Allocator,pointer
-  >::type::pointer                          ptr_pointer;
-
-  ptr_pointer& up(){return up_;}
-  ptr_pointer  up()const{return up_;}
-
-  /* interoperability with rnd_node_iterator */
-
-  static void increment(pointer& x)
-  {
-    x=*(x->up()+1);
-  }
-
-  static void decrement(pointer& x)
-  {
-    x=*(x->up()-1);
-  }
-
-  static void advance(pointer& x,std::ptrdiff_t n)
-  {
-    x=*(x->up()+n);
-  }
-
-  static std::ptrdiff_t distance(pointer x,pointer y)
-  {
-    return y->up()-x->up();
-  }
-
-  /* algorithmic stuff */
-
-  static void relocate(ptr_pointer pos,ptr_pointer x)
-  {
-    pointer n=*x;
-    if(x<pos){
-      extract(x,pos);
-      *(pos-1)=n;
-      n->up()=pos-1;
-    }
-    else{
-      while(x!=pos){
-        *x=*(x-1);
-        (*x)->up()=x;
-        --x;
-      }
-      *pos=n;
-      n->up()=pos;
-    }
-  };
-
-  static void relocate(ptr_pointer pos,ptr_pointer first,ptr_pointer last)
-  {
-    ptr_pointer begin,middle,end;
-    if(pos<first){
-      begin=pos;
-      middle=first;
-      end=last;
-    }
-    else{
-      begin=first;
-      middle=last;
-      end=pos;
-    }
-
-    std::ptrdiff_t n=end-begin;
-    std::ptrdiff_t m=middle-begin;
-    std::ptrdiff_t n_m=n-m;
-    std::ptrdiff_t p=integer::gcd(n,m);
-
-    for(std::ptrdiff_t i=0;i<p;++i){
-      pointer tmp=begin[i];
-      for(std::ptrdiff_t j=i,k;;){
-        if(j<n_m)k=j+m;
-        else     k=j-n_m;
-        if(k==i){
-          *(begin+j)=tmp;
-          (*(begin+j))->up()=begin+j;
-          break;
-        }
-        else{
-          *(begin+j)=*(begin+k);
-          (*(begin+j))->up()=begin+j;
-        }
-
-        if(k<n_m)j=k+m;
-        else     j=k-n_m;
-        if(j==i){
-          *(begin+k)=tmp;
-          (*(begin+k))->up()=begin+k;
-          break;
-        }
-        else{
-          *(begin+k)=*(begin+j);
-          (*(begin+k))->up()=begin+k;
-        }
-      }
-    }
-  };
-
-  static void extract(ptr_pointer x,ptr_pointer pend)
-  {
-    --pend;
-    while(x!=pend){
-      *x=*(x+1);
-      (*x)->up()=x;
-      ++x;
-    }
-  }
-
-  static void transfer(
-    ptr_pointer pbegin0,ptr_pointer pend0,ptr_pointer pbegin1)
-  {
-    while(pbegin0!=pend0){
-      *pbegin1=*pbegin0++;
-      (*pbegin1)->up()=pbegin1;
-      ++pbegin1;
-    }
-  }
-
-  static void reverse(ptr_pointer pbegin,ptr_pointer pend)
-  {
-    std::ptrdiff_t d=(pend-pbegin)/2;
-    for(std::ptrdiff_t i=0;i<d;++i){
-      std::swap(*pbegin,*--pend);
-      (*pbegin)->up()=pbegin;
-      (*pend)->up()=pend;
-      ++pbegin;
-    }
-  }
-
-private:
-  ptr_pointer up_;
-};
-
-template<typename Super>
-struct random_access_index_node_trampoline:
-  random_access_index_node_impl<
-    typename boost::detail::allocator::rebind_to<
-      typename Super::allocator_type,
-      char
-    >::type
-  >
-{
-  typedef random_access_index_node_impl<
-    typename boost::detail::allocator::rebind_to<
-      typename Super::allocator_type,
-      char
-    >::type
-  > impl_type;
-};
-
-template<typename Super>
-struct random_access_index_node:
-  Super,random_access_index_node_trampoline<Super>
-{
-private:
-  typedef random_access_index_node_trampoline<Super> trampoline;
-
-public:
-  typedef typename trampoline::impl_type     impl_type;
-  typedef typename trampoline::pointer       impl_pointer;
-  typedef typename trampoline::const_pointer const_impl_pointer;
-  typedef typename trampoline::ptr_pointer   impl_ptr_pointer;
-
-  impl_ptr_pointer& up(){return trampoline::up();}
-  impl_ptr_pointer  up()const{return trampoline::up();}
-
-  impl_pointer impl()
-  {
-    return static_cast<impl_pointer>(
-      static_cast<impl_type*>(static_cast<trampoline*>(this)));
-  }
-
-  const_impl_pointer impl()const
-  {
-    return static_cast<const_impl_pointer>(
-      static_cast<const impl_type*>(static_cast<const trampoline*>(this)));
-  }
-
-  static random_access_index_node* from_impl(impl_pointer x)
-  {
-    return
-      static_cast<random_access_index_node*>(
-        static_cast<trampoline*>(
-          raw_ptr<impl_type*>(x)));
-  }
-
-  static const random_access_index_node* from_impl(const_impl_pointer x)
-  {
-    return
-      static_cast<const random_access_index_node*>(
-        static_cast<const trampoline*>(
-          raw_ptr<const impl_type*>(x)));
-  }
-
-  /* interoperability with rnd_node_iterator */
-
-  static void increment(random_access_index_node*& x)
-  {
-    impl_pointer xi=x->impl();
-    trampoline::increment(xi);
-    x=from_impl(xi);
-  }
-
-  static void decrement(random_access_index_node*& x)
-  {
-    impl_pointer xi=x->impl();
-    trampoline::decrement(xi);
-    x=from_impl(xi);
-  }
-
-  static void advance(random_access_index_node*& x,std::ptrdiff_t n)
-  {
-    impl_pointer xi=x->impl();
-    trampoline::advance(xi,n);
-    x=from_impl(xi);
-  }
-
-  static std::ptrdiff_t distance(
-    random_access_index_node* x,random_access_index_node* y)
-  {
-    return trampoline::distance(x->impl(),y->impl());
-  }
-};
-
-} /* namespace multi_index::detail */
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/rnd_index_ops.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/rnd_index_ops.hpp
deleted file mode 100644
index f5e76e4441f..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/rnd_index_ops.hpp
+++ /dev/null
@@ -1,203 +0,0 @@
-/* Copyright 2003-2015 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_DETAIL_RND_INDEX_OPS_HPP
-#define BOOST_MULTI_INDEX_DETAIL_RND_INDEX_OPS_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <algorithm>
-#include <boost/multi_index/detail/rnd_index_ptr_array.hpp>
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-/* Common code for random_access_index memfuns having templatized and
- * non-templatized versions.
- */
-
-template<typename Node,typename Allocator,typename Predicate>
-Node* random_access_index_remove(
-  random_access_index_ptr_array<Allocator>& ptrs,Predicate pred)
-{
-  typedef typename Node::value_type value_type;
-  typedef typename Node::impl_ptr_pointer impl_ptr_pointer;
-
-  impl_ptr_pointer first=ptrs.begin(),
-                   res=first,
-                   last=ptrs.end();
-  for(;first!=last;++first){
-    if(!pred(
-        const_cast<const value_type&>(Node::from_impl(*first)->value()))){
-      if(first!=res){
-        std::swap(*first,*res);
-        (*first)->up()=first;
-        (*res)->up()=res;
-      }
-      ++res;
-    }
-  }
-  return Node::from_impl(*res);
-}
-
-template<typename Node,typename Allocator,class BinaryPredicate>
-Node* random_access_index_unique(
-  random_access_index_ptr_array<Allocator>& ptrs,BinaryPredicate binary_pred)
-{
-  typedef typename Node::value_type       value_type;
-  typedef typename Node::impl_ptr_pointer impl_ptr_pointer;
-
-  impl_ptr_pointer first=ptrs.begin(),
-                   res=first,
-                   last=ptrs.end();
-  if(first!=last){
-    for(;++first!=last;){
-      if(!binary_pred(
-           const_cast<const value_type&>(Node::from_impl(*res)->value()),
-           const_cast<const value_type&>(Node::from_impl(*first)->value()))){
-        ++res;
-        if(first!=res){
-          std::swap(*first,*res);
-          (*first)->up()=first;
-          (*res)->up()=res;
-        }
-      }
-    }
-    ++res;
-  }
-  return Node::from_impl(*res);
-}
-
-template<typename Node,typename Allocator,typename Compare>
-void random_access_index_inplace_merge(
-  const Allocator& al,
-  random_access_index_ptr_array<Allocator>& ptrs,
-  BOOST_DEDUCED_TYPENAME Node::impl_ptr_pointer first1,Compare comp)
-{
-  typedef typename Node::value_type       value_type;
-  typedef typename Node::impl_pointer     impl_pointer;
-  typedef typename Node::impl_ptr_pointer impl_ptr_pointer;
-
-  auto_space<impl_pointer,Allocator> spc(al,ptrs.size());
-
-  impl_ptr_pointer first0=ptrs.begin(),
-                   last0=first1,
-                   last1=ptrs.end(),
-                   out=spc.data();
-  while(first0!=last0&&first1!=last1){
-    if(comp(
-        const_cast<const value_type&>(Node::from_impl(*first1)->value()),
-        const_cast<const value_type&>(Node::from_impl(*first0)->value()))){
-      *out++=*first1++;
-    }
-    else{
-      *out++=*first0++;
-    }
-  }
-  std::copy(&*first0,&*last0,&*out);
-  std::copy(&*first1,&*last1,&*out);
-
-  first1=ptrs.begin();
-  out=spc.data();
-  while(first1!=last1){
-    *first1=*out++;
-    (*first1)->up()=first1;
-    ++first1;
-  }
-}
-
-/* sorting */
-
-/* auxiliary stuff */
-
-template<typename Node,typename Compare>
-struct random_access_index_sort_compare
-{
-  typedef typename Node::impl_pointer first_argument_type;
-  typedef typename Node::impl_pointer second_argument_type;
-  typedef bool                        result_type;
-
-  random_access_index_sort_compare(Compare comp_=Compare()):comp(comp_){}
-
-  bool operator()(
-    typename Node::impl_pointer x,typename Node::impl_pointer y)const
-  {
-    typedef typename Node::value_type value_type;
-
-    return comp(
-      const_cast<const value_type&>(Node::from_impl(x)->value()),
-      const_cast<const value_type&>(Node::from_impl(y)->value()));
-  }
-
-private:
-  Compare comp;
-};
-
-template<typename Node,typename Allocator,class Compare>
-void random_access_index_sort(
-  const Allocator& al,
-  random_access_index_ptr_array<Allocator>& ptrs,
-  Compare comp)
-{
-  /* The implementation is extremely simple: an auxiliary
-   * array of pointers is sorted using stdlib facilities and
-   * then used to rearrange the index. This is suboptimal
-   * in space and time, but has some advantages over other
-   * possible approaches:
-   *   - Use std::stable_sort() directly on ptrs using some
-   *     special iterator in charge of maintaining pointers
-   *     and up() pointers in sync: we cannot guarantee
-   *     preservation of the container invariants in the face of
-   *     exceptions, if, for instance, std::stable_sort throws
-   *     when ptrs transitorily contains duplicate elements.
-   *   - Rewrite the internal algorithms of std::stable_sort
-   *     adapted for this case: besides being a fair amount of
-   *     work, making a stable sort compatible with Boost.MultiIndex
-   *     invariants (basically, no duplicates or missing elements
-   *     even if an exception is thrown) is complicated, error-prone
-   *     and possibly won't perform much better than the
-   *     solution adopted.
-   */
-
-  if(ptrs.size()<=1)return;
-
-  typedef typename Node::impl_pointer       impl_pointer;
-  typedef typename Node::impl_ptr_pointer   impl_ptr_pointer;
-  typedef random_access_index_sort_compare<
-    Node,Compare>                           ptr_compare;
-  
-  impl_ptr_pointer   first=ptrs.begin();
-  impl_ptr_pointer   last=ptrs.end();
-  auto_space<
-    impl_pointer,
-    Allocator>       spc(al,ptrs.size());
-  impl_ptr_pointer   buf=spc.data();
-
-  std::copy(&*first,&*last,&*buf);
-  std::stable_sort(&*buf,&*buf+ptrs.size(),ptr_compare(comp));
-
-  while(first!=last){
-    *first=*buf++;
-    (*first)->up()=first;
-    ++first;
-  }
-}
-
-} /* namespace multi_index::detail */
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/rnd_index_ptr_array.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/rnd_index_ptr_array.hpp
deleted file mode 100644
index bae1c851b8e..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/rnd_index_ptr_array.hpp
+++ /dev/null
@@ -1,144 +0,0 @@
-/* Copyright 2003-2013 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_DETAIL_RND_INDEX_PTR_ARRAY_HPP
-#define BOOST_MULTI_INDEX_DETAIL_RND_INDEX_PTR_ARRAY_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <algorithm>
-#include <boost/detail/allocator_utilities.hpp>
-#include <boost/multi_index/detail/auto_space.hpp>
-#include <boost/multi_index/detail/rnd_index_node.hpp>
-#include <boost/noncopyable.hpp>
-#include <cstddef>
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-/* pointer structure for use by random access indices */
-
-template<typename Allocator>
-class random_access_index_ptr_array:private noncopyable
-{
-  typedef random_access_index_node_impl<
-    typename boost::detail::allocator::rebind_to<
-      Allocator,
-      char
-    >::type
-  >                                                     node_impl_type;
-
-public:
-  typedef typename node_impl_type::pointer              value_type;
-  typedef typename boost::detail::allocator::rebind_to<
-    Allocator,value_type
-  >::type::pointer                                      pointer;
-
-  random_access_index_ptr_array(
-    const Allocator& al,value_type end_,std::size_t sz):
-    size_(sz),
-    capacity_(sz),
-    spc(al,capacity_+1)
-  {
-    *end()=end_;
-    end_->up()=end();
-  }
-
-  std::size_t size()const{return size_;}
-  std::size_t capacity()const{return capacity_;}
-
-  void room_for_one()
-  {
-    if(size_==capacity_){
-      reserve(capacity_<=10?15:capacity_+capacity_/2);
-    }
-  }
-
-  void reserve(std::size_t c)
-  {
-    if(c>capacity_)set_capacity(c);
-  }
-
-  void shrink_to_fit()
-  {
-    if(capacity_>size_)set_capacity(size_);
-  }
-
-  pointer begin()const{return ptrs();}
-  pointer end()const{return ptrs()+size_;}
-  pointer at(std::size_t n)const{return ptrs()+n;}
-
-  void push_back(value_type x)
-  {
-    *(end()+1)=*end();
-    (*(end()+1))->up()=end()+1;
-    *end()=x;
-    (*end())->up()=end();
-    ++size_;
-  }
-
-  void erase(value_type x)
-  {
-    node_impl_type::extract(x->up(),end()+1);
-    --size_;
-  }
-
-  void clear()
-  {
-    *begin()=*end();
-    (*begin())->up()=begin();
-    size_=0;
-  }
-
-  void swap(random_access_index_ptr_array& x)
-  {
-    std::swap(size_,x.size_);
-    std::swap(capacity_,x.capacity_);
-    spc.swap(x.spc);
-  }
-
-private:
-  std::size_t                      size_;
-  std::size_t                      capacity_;
-  auto_space<value_type,Allocator> spc;
-
-  pointer ptrs()const
-  {
-    return spc.data();
-  }
-
-  void set_capacity(std::size_t c)
-  {
-    auto_space<value_type,Allocator> spc1(spc.get_allocator(),c+1);
-    node_impl_type::transfer(begin(),end()+1,spc1.data());
-    spc.swap(spc1);
-    capacity_=c;
-  }
-};
-
-template<typename Allocator>
-void swap(
-  random_access_index_ptr_array<Allocator>& x,
-  random_access_index_ptr_array<Allocator>& y)
-{
-  x.swap(y);
-}
-
-} /* namespace multi_index::detail */
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/rnd_node_iterator.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/rnd_node_iterator.hpp
deleted file mode 100644
index 48026132fb7..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/rnd_node_iterator.hpp
+++ /dev/null
@@ -1,140 +0,0 @@
-/* Copyright 2003-2014 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_DETAIL_RND_NODE_ITERATOR_HPP
-#define BOOST_MULTI_INDEX_DETAIL_RND_NODE_ITERATOR_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <boost/operators.hpp>
-
-#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
-#include <boost/serialization/nvp.hpp>
-#include <boost/serialization/split_member.hpp>
-#endif
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-/* Iterator class for node-based indices with random access iterators. */
-
-template<typename Node>
-class rnd_node_iterator:
-  public random_access_iterator_helper<
-    rnd_node_iterator<Node>,
-    typename Node::value_type,
-    std::ptrdiff_t,
-    const typename Node::value_type*,
-    const typename Node::value_type&>
-{
-public:
-  /* coverity[uninit_ctor]: suppress warning */
-  rnd_node_iterator(){}
-  explicit rnd_node_iterator(Node* node_):node(node_){}
-
-  const typename Node::value_type& operator*()const
-  {
-    return node->value();
-  }
-
-  rnd_node_iterator& operator++()
-  {
-    Node::increment(node);
-    return *this;
-  }
-
-  rnd_node_iterator& operator--()
-  {
-    Node::decrement(node);
-    return *this;
-  }
-
-  rnd_node_iterator& operator+=(std::ptrdiff_t n)
-  {
-    Node::advance(node,n);
-    return *this;
-  }
-
-  rnd_node_iterator& operator-=(std::ptrdiff_t n)
-  {
-    Node::advance(node,-n);
-    return *this;
-  }
-
-#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
-  /* Serialization. As for why the following is public,
-   * see explanation in safe_mode_iterator notes in safe_mode.hpp.
-   */
-
-  BOOST_SERIALIZATION_SPLIT_MEMBER()
-
-  typedef typename Node::base_type node_base_type;
-
-  template<class Archive>
-  void save(Archive& ar,const unsigned int)const
-  {
-    node_base_type* bnode=node;
-    ar<<serialization::make_nvp("pointer",bnode);
-  }
-
-  template<class Archive>
-  void load(Archive& ar,const unsigned int)
-  {
-    node_base_type* bnode;
-    ar>>serialization::make_nvp("pointer",bnode);
-    node=static_cast<Node*>(bnode);
-  }
-#endif
-
-  /* get_node is not to be used by the user */
-
-  typedef Node node_type;
-
-  Node* get_node()const{return node;}
-
-private:
-  Node* node;
-};
-
-template<typename Node>
-bool operator==(
-  const rnd_node_iterator<Node>& x,
-  const rnd_node_iterator<Node>& y)
-{
-  return x.get_node()==y.get_node();
-}
-
-template<typename Node>
-bool operator<(
-  const rnd_node_iterator<Node>& x,
-  const rnd_node_iterator<Node>& y)
-{
-  return Node::distance(x.get_node(),y.get_node())>0;
-}
-
-template<typename Node>
-std::ptrdiff_t operator-(
-  const rnd_node_iterator<Node>& x,
-  const rnd_node_iterator<Node>& y)
-{
-  return Node::distance(y.get_node(),x.get_node());
-}
-
-} /* namespace multi_index::detail */
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/rnk_index_ops.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/rnk_index_ops.hpp
deleted file mode 100644
index fb233cf4973..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/rnk_index_ops.hpp
+++ /dev/null
@@ -1,300 +0,0 @@
-/* Copyright 2003-2017 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_DETAIL_RNK_INDEX_OPS_HPP
-#define BOOST_MULTI_INDEX_DETAIL_RNK_INDEX_OPS_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <boost/mpl/and.hpp>
-#include <boost/multi_index/detail/promotes_arg.hpp>
-#include <cstddef>
-#include <utility>
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-/* Common code for ranked_index memfuns having templatized and
- * non-templatized versions.
- */
-
-template<typename Pointer>
-inline std::size_t ranked_node_size(Pointer x)
-{
-  return x!=Pointer(0)?x->size:0;
-}
-
-template<typename Pointer>
-inline Pointer ranked_index_nth(std::size_t n,Pointer end_)
-{
-  Pointer top=end_->parent();
-  if(top==Pointer(0)||n>=top->size)return end_;
-
-  for(;;){
-    std::size_t s=ranked_node_size(top->left());
-    if(n==s)return top;
-    if(n<s)top=top->left();
-    else{
-      top=top->right();
-      n-=s+1;
-    }
-  }
-}
-
-template<typename Pointer>
-inline std::size_t ranked_index_rank(Pointer x,Pointer end_)
-{
-  Pointer top=end_->parent();
-  if(top==Pointer(0))return 0;
-  if(x==end_)return top->size;
-
-  std::size_t s=ranked_node_size(x->left());
-  while(x!=top){
-    Pointer z=x->parent();
-    if(x==z->right()){
-      s+=ranked_node_size(z->left())+1;
-    }
-    x=z;
-  }
-  return s;
-}
-
-template<
-  typename Node,typename KeyFromValue,
-  typename CompatibleKey,typename CompatibleCompare
->
-inline std::size_t ranked_index_find_rank(
-  Node* top,Node* y,const KeyFromValue& key,const CompatibleKey& x,
-  const CompatibleCompare& comp)
-{
-  typedef typename KeyFromValue::result_type key_type;
-
-  return ranked_index_find_rank(
-    top,y,key,x,comp,
-    mpl::and_<
-      promotes_1st_arg<CompatibleCompare,CompatibleKey,key_type>,
-      promotes_2nd_arg<CompatibleCompare,key_type,CompatibleKey> >());
-}
-
-template<
-  typename Node,typename KeyFromValue,
-  typename CompatibleCompare
->
-inline std::size_t ranked_index_find_rank(
-  Node* top,Node* y,const KeyFromValue& key,
-  const BOOST_DEDUCED_TYPENAME KeyFromValue::result_type& x,
-  const CompatibleCompare& comp,mpl::true_)
-{
-  return ranked_index_find_rank(top,y,key,x,comp,mpl::false_());
-}
-
-template<
-  typename Node,typename KeyFromValue,
-  typename CompatibleKey,typename CompatibleCompare
->
-inline std::size_t ranked_index_find_rank(
-  Node* top,Node* y,const KeyFromValue& key,const CompatibleKey& x,
-  const CompatibleCompare& comp,mpl::false_)
-{
-  if(!top)return 0;
-
-  std::size_t s=top->impl()->size,
-              s0=s;
-  Node*       y0=y;
-
-  do{
-    if(!comp(key(top->value()),x)){
-      y=top;
-      s-=ranked_node_size(y->right())+1;
-      top=Node::from_impl(top->left());
-    }
-    else top=Node::from_impl(top->right());
-  }while(top);
-    
-  return (y==y0||comp(x,key(y->value())))?s0:s;
-}
-
-template<
-  typename Node,typename KeyFromValue,
-  typename CompatibleKey,typename CompatibleCompare
->
-inline std::size_t ranked_index_lower_bound_rank(
-  Node* top,Node* y,const KeyFromValue& key,const CompatibleKey& x,
-  const CompatibleCompare& comp)
-{
-  typedef typename KeyFromValue::result_type key_type;
-
-  return ranked_index_lower_bound_rank(
-    top,y,key,x,comp,
-    promotes_2nd_arg<CompatibleCompare,key_type,CompatibleKey>());
-}
-
-template<
-  typename Node,typename KeyFromValue,
-  typename CompatibleCompare
->
-inline std::size_t ranked_index_lower_bound_rank(
-  Node* top,Node* y,const KeyFromValue& key,
-  const BOOST_DEDUCED_TYPENAME KeyFromValue::result_type& x,
-  const CompatibleCompare& comp,mpl::true_)
-{
-  return ranked_index_lower_bound_rank(top,y,key,x,comp,mpl::false_());
-}
-
-template<
-  typename Node,typename KeyFromValue,
-  typename CompatibleKey,typename CompatibleCompare
->
-inline std::size_t ranked_index_lower_bound_rank(
-  Node* top,Node* y,const KeyFromValue& key,const CompatibleKey& x,
-  const CompatibleCompare& comp,mpl::false_)
-{
-  if(!top)return 0;
-
-  std::size_t s=top->impl()->size;
-
-  do{
-    if(!comp(key(top->value()),x)){
-      y=top;
-      s-=ranked_node_size(y->right())+1;
-      top=Node::from_impl(top->left());
-    }
-    else top=Node::from_impl(top->right());
-  }while(top);
-
-  return s;
-}
-
-template<
-  typename Node,typename KeyFromValue,
-  typename CompatibleKey,typename CompatibleCompare
->
-inline std::size_t ranked_index_upper_bound_rank(
-  Node* top,Node* y,const KeyFromValue& key,const CompatibleKey& x,
-  const CompatibleCompare& comp)
-{
-  typedef typename KeyFromValue::result_type key_type;
-
-  return ranked_index_upper_bound_rank(
-    top,y,key,x,comp,
-    promotes_1st_arg<CompatibleCompare,CompatibleKey,key_type>());
-}
-
-template<
-  typename Node,typename KeyFromValue,
-  typename CompatibleCompare
->
-inline std::size_t ranked_index_upper_bound_rank(
-  Node* top,Node* y,const KeyFromValue& key,
-  const BOOST_DEDUCED_TYPENAME KeyFromValue::result_type& x,
-  const CompatibleCompare& comp,mpl::true_)
-{
-  return ranked_index_upper_bound_rank(top,y,key,x,comp,mpl::false_());
-}
-
-template<
-  typename Node,typename KeyFromValue,
-  typename CompatibleKey,typename CompatibleCompare
->
-inline std::size_t ranked_index_upper_bound_rank(
-  Node* top,Node* y,const KeyFromValue& key,const CompatibleKey& x,
-  const CompatibleCompare& comp,mpl::false_)
-{
-  if(!top)return 0;
-
-  std::size_t s=top->impl()->size;
-
-  do{
-    if(comp(x,key(top->value()))){
-      y=top;
-      s-=ranked_node_size(y->right())+1;
-      top=Node::from_impl(top->left());
-    }
-    else top=Node::from_impl(top->right());
-  }while(top);
-
-  return s;
-}
-
-template<
-  typename Node,typename KeyFromValue,
-  typename CompatibleKey,typename CompatibleCompare
->
-inline std::pair<std::size_t,std::size_t> ranked_index_equal_range_rank(
-  Node* top,Node* y,const KeyFromValue& key,const CompatibleKey& x,
-  const CompatibleCompare& comp)
-{
-  typedef typename KeyFromValue::result_type key_type;
-
-  return ranked_index_equal_range_rank(
-    top,y,key,x,comp,
-    mpl::and_<
-      promotes_1st_arg<CompatibleCompare,CompatibleKey,key_type>,
-      promotes_2nd_arg<CompatibleCompare,key_type,CompatibleKey> >());
-}
-
-template<
-  typename Node,typename KeyFromValue,
-  typename CompatibleCompare
->
-inline std::pair<std::size_t,std::size_t> ranked_index_equal_range_rank(
-  Node* top,Node* y,const KeyFromValue& key,
-  const BOOST_DEDUCED_TYPENAME KeyFromValue::result_type& x,
-  const CompatibleCompare& comp,mpl::true_)
-{
-  return ranked_index_equal_range_rank(top,y,key,x,comp,mpl::false_());
-}
-
-template<
-  typename Node,typename KeyFromValue,
-  typename CompatibleKey,typename CompatibleCompare
->
-inline std::pair<std::size_t,std::size_t> ranked_index_equal_range_rank(
-  Node* top,Node* y,const KeyFromValue& key,const CompatibleKey& x,
-  const CompatibleCompare& comp,mpl::false_)
-{
-  if(!top)return std::pair<std::size_t,std::size_t>(0,0);
-
-  std::size_t s=top->impl()->size;
-
-  do{
-    if(comp(key(top->value()),x)){
-      top=Node::from_impl(top->right());
-    }
-    else if(comp(x,key(top->value()))){
-      y=top;
-      s-=ranked_node_size(y->right())+1;
-      top=Node::from_impl(top->left());
-    }
-    else{
-      return std::pair<std::size_t,std::size_t>(
-        s-top->impl()->size+
-          ranked_index_lower_bound_rank(
-           Node::from_impl(top->left()),top,key,x,comp,mpl::false_()),
-        s-ranked_node_size(top->right())+
-          ranked_index_upper_bound_rank(
-            Node::from_impl(top->right()),y,key,x,comp,mpl::false_()));
-    }
-  }while(top);
-
-  return std::pair<std::size_t,std::size_t>(s,s);
-}
-
-} /* namespace multi_index::detail */
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/safe_mode.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/safe_mode.hpp
deleted file mode 100644
index 905270e9fb3..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/safe_mode.hpp
+++ /dev/null
@@ -1,588 +0,0 @@
-/* Copyright 2003-2013 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_DETAIL_SAFE_MODE_HPP
-#define BOOST_MULTI_INDEX_DETAIL_SAFE_MODE_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-/* Safe mode machinery, in the spirit of Cay Hortmann's "Safe STL"
- * (http://www.horstmann.com/safestl.html).
- * In this mode, containers of type Container are derived from
- * safe_container<Container>, and their corresponding iterators
- * are wrapped with safe_iterator. These classes provide
- * an internal record of which iterators are at a given moment associated
- * to a given container, and properly mark the iterators as invalid
- * when the container gets destroyed.
- * Iterators are chained in a single attached list, whose header is
- * kept by the container. More elaborate data structures would yield better
- * performance, but I decided to keep complexity to a minimum since
- * speed is not an issue here.
- * Safe mode iterators automatically check that only proper operations
- * are performed on them: for instance, an invalid iterator cannot be
- * dereferenced. Additionally, a set of utilty macros and functions are
- * provided that serve to implement preconditions and cooperate with
- * the framework within the container.
- * Iterators can also be unchecked, i.e. they do not have info about
- * which container they belong in. This situation arises when the iterator
- * is restored from a serialization archive: only information on the node
- * is available, and it is not possible to determine to which container
- * the iterator is associated to. The only sensible policy is to assume
- * unchecked iterators are valid, though this can certainly generate false
- * positive safe mode checks.
- * This is not a full-fledged safe mode framework, and is only intended
- * for use within the limits of Boost.MultiIndex.
- */
-
-/* Assertion macros. These resolve to no-ops if
- * !defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE).
- */
-
-#if !defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-#undef BOOST_MULTI_INDEX_SAFE_MODE_ASSERT
-#define BOOST_MULTI_INDEX_SAFE_MODE_ASSERT(expr,error_code) ((void)0)
-#else
-#if !defined(BOOST_MULTI_INDEX_SAFE_MODE_ASSERT)
-#include <boost/assert.hpp>
-#define BOOST_MULTI_INDEX_SAFE_MODE_ASSERT(expr,error_code) BOOST_ASSERT(expr)
-#endif
-#endif
-
-#define BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(it)                           \
-  BOOST_MULTI_INDEX_SAFE_MODE_ASSERT(                                        \
-    safe_mode::check_valid_iterator(it),                                     \
-    safe_mode::invalid_iterator);
-
-#define BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(it)                 \
-  BOOST_MULTI_INDEX_SAFE_MODE_ASSERT(                                        \
-    safe_mode::check_dereferenceable_iterator(it),                           \
-    safe_mode::not_dereferenceable_iterator);
-
-#define BOOST_MULTI_INDEX_CHECK_INCREMENTABLE_ITERATOR(it)                   \
-  BOOST_MULTI_INDEX_SAFE_MODE_ASSERT(                                        \
-    safe_mode::check_incrementable_iterator(it),                             \
-    safe_mode::not_incrementable_iterator);
-
-#define BOOST_MULTI_INDEX_CHECK_DECREMENTABLE_ITERATOR(it)                   \
-  BOOST_MULTI_INDEX_SAFE_MODE_ASSERT(                                        \
-    safe_mode::check_decrementable_iterator(it),                             \
-    safe_mode::not_decrementable_iterator);
-
-#define BOOST_MULTI_INDEX_CHECK_IS_OWNER(it,cont)                            \
-  BOOST_MULTI_INDEX_SAFE_MODE_ASSERT(                                        \
-    safe_mode::check_is_owner(it,cont),                                      \
-    safe_mode::not_owner);
-
-#define BOOST_MULTI_INDEX_CHECK_SAME_OWNER(it0,it1)                          \
-  BOOST_MULTI_INDEX_SAFE_MODE_ASSERT(                                        \
-    safe_mode::check_same_owner(it0,it1),                                    \
-    safe_mode::not_same_owner);
-
-#define BOOST_MULTI_INDEX_CHECK_VALID_RANGE(it0,it1)                         \
-  BOOST_MULTI_INDEX_SAFE_MODE_ASSERT(                                        \
-    safe_mode::check_valid_range(it0,it1),                                   \
-    safe_mode::invalid_range);
-
-#define BOOST_MULTI_INDEX_CHECK_OUTSIDE_RANGE(it,it0,it1)                    \
-  BOOST_MULTI_INDEX_SAFE_MODE_ASSERT(                                        \
-    safe_mode::check_outside_range(it,it0,it1),                              \
-    safe_mode::inside_range);
-
-#define BOOST_MULTI_INDEX_CHECK_IN_BOUNDS(it,n)                              \
-  BOOST_MULTI_INDEX_SAFE_MODE_ASSERT(                                        \
-    safe_mode::check_in_bounds(it,n),                                        \
-    safe_mode::out_of_bounds);
-
-#define BOOST_MULTI_INDEX_CHECK_DIFFERENT_CONTAINER(cont0,cont1)             \
-  BOOST_MULTI_INDEX_SAFE_MODE_ASSERT(                                        \
-    safe_mode::check_different_container(cont0,cont1),                       \
-    safe_mode::same_container);
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <algorithm>
-#include <boost/detail/iterator.hpp>
-#include <boost/multi_index/detail/access_specifier.hpp>
-#include <boost/multi_index/detail/iter_adaptor.hpp>
-#include <boost/multi_index/safe_mode_errors.hpp>
-#include <boost/noncopyable.hpp>
-
-#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
-#include <boost/serialization/split_member.hpp>
-#include <boost/serialization/version.hpp>
-#endif
-
-#if defined(BOOST_HAS_THREADS)
-#include <boost/detail/lightweight_mutex.hpp>
-#endif
-
-namespace boost{
-
-namespace multi_index{
-
-namespace safe_mode{
-
-/* Checking routines. Assume the best for unchecked iterators
- * (i.e. they pass the checking when there is not enough info
- * to know.)
- */
-
-template<typename Iterator>
-inline bool check_valid_iterator(const Iterator& it)
-{
-  return it.valid()||it.unchecked();
-}
-
-template<typename Iterator>
-inline bool check_dereferenceable_iterator(const Iterator& it)
-{
-  return (it.valid()&&it!=it.owner()->end())||it.unchecked();
-}
-
-template<typename Iterator>
-inline bool check_incrementable_iterator(const Iterator& it)
-{
-  return (it.valid()&&it!=it.owner()->end())||it.unchecked();
-}
-
-template<typename Iterator>
-inline bool check_decrementable_iterator(const Iterator& it)
-{
-  return (it.valid()&&it!=it.owner()->begin())||it.unchecked();
-}
-
-template<typename Iterator>
-inline bool check_is_owner(
-  const Iterator& it,const typename Iterator::container_type& cont)
-{
-  return (it.valid()&&it.owner()==&cont)||it.unchecked();
-}
-
-template<typename Iterator>
-inline bool check_same_owner(const Iterator& it0,const Iterator& it1)
-{
-  return (it0.valid()&&it1.valid()&&it0.owner()==it1.owner())||
-         it0.unchecked()||it1.unchecked();
-}
-
-template<typename Iterator>
-inline bool check_valid_range(const Iterator& it0,const Iterator& it1)
-{
-  if(!check_same_owner(it0,it1))return false;
-
-  if(it0.valid()){
-    Iterator last=it0.owner()->end();
-    if(it1==last)return true;
-
-    for(Iterator first=it0;first!=last;++first){
-      if(first==it1)return true;
-    }
-    return false;
-  }
-  return true;
-}
-
-template<typename Iterator>
-inline bool check_outside_range(
-  const Iterator& it,const Iterator& it0,const Iterator& it1)
-{
-  if(!check_same_owner(it0,it1))return false;
-
-  if(it0.valid()){
-    Iterator last=it0.owner()->end();
-    bool found=false;
-
-    Iterator first=it0;
-    for(;first!=last;++first){
-      if(first==it1)break;
-    
-      /* crucial that this check goes after previous break */
-    
-      if(first==it)found=true;
-    }
-    if(first!=it1)return false;
-    return !found;
-  }
-  return true;
-}
-
-template<typename Iterator,typename Difference>
-inline bool check_in_bounds(const Iterator& it,Difference n)
-{
-  if(it.unchecked())return true;
-  if(!it.valid())   return false;
-  if(n>0)           return it.owner()->end()-it>=n;
-  else              return it.owner()->begin()-it<=n;
-}
-
-template<typename Container>
-inline bool check_different_container(
-  const Container& cont0,const Container& cont1)
-{
-  return &cont0!=&cont1;
-}
-
-/* Invalidates all iterators equivalent to that given. Safe containers
- * must call this when deleting elements: the safe mode framework cannot
- * perform this operation automatically without outside help.
- */
-
-template<typename Iterator>
-inline void detach_equivalent_iterators(Iterator& it)
-{
-  if(it.valid()){
-    {
-#if defined(BOOST_HAS_THREADS)
-      boost::detail::lightweight_mutex::scoped_lock lock(it.cont->mutex);
-#endif
-
-      Iterator *prev_,*next_;
-      for(
-        prev_=static_cast<Iterator*>(&it.cont->header);
-        (next_=static_cast<Iterator*>(prev_->next))!=0;){
-        if(next_!=&it&&*next_==it){
-          prev_->next=next_->next;
-          next_->cont=0;
-        }
-        else prev_=next_;
-      }
-    }
-    it.detach();
-  }
-}
-
-template<typename Container> class safe_container; /* fwd decl. */
-
-} /* namespace multi_index::safe_mode */
-
-namespace detail{
-
-class safe_container_base;                 /* fwd decl. */
-
-class safe_iterator_base
-{
-public:
-  bool valid()const{return cont!=0;}
-  bool unchecked()const{return unchecked_;}
-
-  inline void detach();
-
-  void uncheck()
-  {
-    detach();
-    unchecked_=true;
-  }
-
-protected:
-  safe_iterator_base():cont(0),next(0),unchecked_(false){}
-
-  explicit safe_iterator_base(safe_container_base* cont_):
-    unchecked_(false)
-  {
-    attach(cont_);
-  }
-
-  safe_iterator_base(const safe_iterator_base& it):
-    unchecked_(it.unchecked_)
-  {
-    attach(it.cont);
-  }
-
-  safe_iterator_base& operator=(const safe_iterator_base& it)
-  {
-    unchecked_=it.unchecked_;
-    safe_container_base* new_cont=it.cont;
-    if(cont!=new_cont){
-      detach();
-      attach(new_cont);
-    }
-    return *this;
-  }
-
-  ~safe_iterator_base()
-  {
-    detach();
-  }
-
-  const safe_container_base* owner()const{return cont;}
-
-BOOST_MULTI_INDEX_PRIVATE_IF_MEMBER_TEMPLATE_FRIENDS:
-  friend class safe_container_base;
-
-#if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
-  template<typename>          friend class safe_mode::safe_container;
-  template<typename Iterator> friend
-    void safe_mode::detach_equivalent_iterators(Iterator&);
-#endif
-
-  inline void attach(safe_container_base* cont_);
-
-  safe_container_base* cont;
-  safe_iterator_base*  next;
-  bool                 unchecked_;
-};
-
-class safe_container_base:private noncopyable
-{
-public:
-  safe_container_base(){}
-
-BOOST_MULTI_INDEX_PROTECTED_IF_MEMBER_TEMPLATE_FRIENDS:
-  friend class safe_iterator_base;
-
-#if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
-  template<typename Iterator> friend
-    void safe_mode::detach_equivalent_iterators(Iterator&);
-#endif
-
-  ~safe_container_base()
-  {
-    /* Detaches all remaining iterators, which by now will
-     * be those pointing to the end of the container.
-     */
-
-    for(safe_iterator_base* it=header.next;it;it=it->next)it->cont=0;
-    header.next=0;
-  }
-
-  void swap(safe_container_base& x)
-  {
-    for(safe_iterator_base* it0=header.next;it0;it0=it0->next)it0->cont=&x;
-    for(safe_iterator_base* it1=x.header.next;it1;it1=it1->next)it1->cont=this;
-    std::swap(header.cont,x.header.cont);
-    std::swap(header.next,x.header.next);
-  }
-
-  safe_iterator_base header;
-
-#if defined(BOOST_HAS_THREADS)
-  boost::detail::lightweight_mutex mutex;
-#endif
-};
-
-void safe_iterator_base::attach(safe_container_base* cont_)
-{
-  cont=cont_;
-  if(cont){
-#if defined(BOOST_HAS_THREADS)
-    boost::detail::lightweight_mutex::scoped_lock lock(cont->mutex);
-#endif
-
-    next=cont->header.next;
-    cont->header.next=this;
-  }
-}
-
-void safe_iterator_base::detach()
-{
-  if(cont){
-#if defined(BOOST_HAS_THREADS)
-    boost::detail::lightweight_mutex::scoped_lock lock(cont->mutex);
-#endif
-
-    safe_iterator_base *prev_,*next_;
-    for(prev_=&cont->header;(next_=prev_->next)!=this;prev_=next_){}
-    prev_->next=next;
-    cont=0;
-  }
-}
-
-} /* namespace multi_index::detail */
-
-namespace safe_mode{
-
-/* In order to enable safe mode on a container:
- *   - The container must derive from safe_container<container_type>,
- *   - iterators must be generated via safe_iterator, which adapts a
- *     preexistent unsafe iterator class.
- */
- 
-template<typename Container>
-class safe_container;
-
-template<typename Iterator,typename Container>
-class safe_iterator:
-  public detail::iter_adaptor<safe_iterator<Iterator,Container>,Iterator>,
-  public detail::safe_iterator_base
-{
-  typedef detail::iter_adaptor<safe_iterator,Iterator> super;
-  typedef detail::safe_iterator_base                   safe_super;
-
-public:
-  typedef Container                                    container_type;
-  typedef typename Iterator::reference                 reference;
-  typedef typename Iterator::difference_type           difference_type;
-
-  safe_iterator(){}
-  explicit safe_iterator(safe_container<container_type>* cont_):
-    safe_super(cont_){}
-  template<typename T0>
-  safe_iterator(const T0& t0,safe_container<container_type>* cont_):
-    super(Iterator(t0)),safe_super(cont_){}
-  template<typename T0,typename T1>
-  safe_iterator(
-    const T0& t0,const T1& t1,safe_container<container_type>* cont_):
-    super(Iterator(t0,t1)),safe_super(cont_){}
-
-  safe_iterator& operator=(const safe_iterator& x)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(x);
-    this->base_reference()=x.base_reference();
-    safe_super::operator=(x);
-    return *this;
-  }
-
-  const container_type* owner()const
-  {
-    return
-      static_cast<const container_type*>(
-        static_cast<const safe_container<container_type>*>(
-          this->safe_super::owner()));
-  }
-
-  /* get_node is not to be used by the user */
-
-  typedef typename Iterator::node_type node_type;
-
-  node_type* get_node()const{return this->base_reference().get_node();}
-
-private:
-  friend class boost::multi_index::detail::iter_adaptor_access;
-
-  reference dereference()const
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(*this);
-    BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(*this);
-    return *(this->base_reference());
-  }
-
-  bool equal(const safe_iterator& x)const
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(*this);
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(x);
-    BOOST_MULTI_INDEX_CHECK_SAME_OWNER(*this,x);
-    return this->base_reference()==x.base_reference();
-  }
-
-  void increment()
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(*this);
-    BOOST_MULTI_INDEX_CHECK_INCREMENTABLE_ITERATOR(*this);
-    ++(this->base_reference());
-  }
-
-  void decrement()
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(*this);
-    BOOST_MULTI_INDEX_CHECK_DECREMENTABLE_ITERATOR(*this);
-    --(this->base_reference());
-  }
-
-  void advance(difference_type n)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(*this);
-    BOOST_MULTI_INDEX_CHECK_IN_BOUNDS(*this,n);
-    this->base_reference()+=n;
-  }
-
-  difference_type distance_to(const safe_iterator& x)const
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(*this);
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(x);
-    BOOST_MULTI_INDEX_CHECK_SAME_OWNER(*this,x);
-    return x.base_reference()-this->base_reference();
-  }
-
-#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
-  /* Serialization. Note that Iterator::save and Iterator:load
-   * are assumed to be defined and public: at first sight it seems
-   * like we could have resorted to the public serialization interface
-   * for doing the forwarding to the adapted iterator class:
-   *   ar<<base_reference();
-   *   ar>>base_reference();
-   * but this would cause incompatibilities if a saving
-   * program is in safe mode and the loading program is not, or
-   * viceversa --in safe mode, the archived iterator data is one layer
-   * deeper, this is especially relevant with XML archives.
-   * It'd be nice if Boost.Serialization provided some forwarding
-   * facility for use by adaptor classes.
-   */ 
-
-  friend class boost::serialization::access;
-
-  BOOST_SERIALIZATION_SPLIT_MEMBER()
-
-  template<class Archive>
-  void save(Archive& ar,const unsigned int version)const
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(*this);
-    this->base_reference().save(ar,version);
-  }
-
-  template<class Archive>
-  void load(Archive& ar,const unsigned int version)
-  {
-    this->base_reference().load(ar,version);
-    safe_super::uncheck();
-  }
-#endif
-};
-
-template<typename Container>
-class safe_container:public detail::safe_container_base
-{
-  typedef detail::safe_container_base super;
-
-public:
-  void detach_dereferenceable_iterators()
-  {
-    typedef typename Container::iterator iterator;
-
-    iterator end_=static_cast<Container*>(this)->end();
-    iterator *prev_,*next_;
-    for(
-      prev_=static_cast<iterator*>(&this->header);
-      (next_=static_cast<iterator*>(prev_->next))!=0;){
-      if(*next_!=end_){
-        prev_->next=next_->next;
-        next_->cont=0;
-      }
-      else prev_=next_;
-    }
-  }
-
-  void swap(safe_container<Container>& x)
-  {
-    super::swap(x);
-  }
-};
-
-} /* namespace multi_index::safe_mode */
-
-} /* namespace multi_index */
-
-#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
-namespace serialization{
-template<typename Iterator,typename Container>
-struct version<
-  boost::multi_index::safe_mode::safe_iterator<Iterator,Container>
->
-{
-  BOOST_STATIC_CONSTANT(
-    int,value=boost::serialization::version<Iterator>::value);
-};
-} /* namespace serialization */
-#endif
-
-} /* namespace boost */
-
-#endif /* BOOST_MULTI_INDEX_ENABLE_SAFE_MODE */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/scope_guard.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/scope_guard.hpp
deleted file mode 100644
index 116f8f50415..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/scope_guard.hpp
+++ /dev/null
@@ -1,453 +0,0 @@
-/* Copyright 2003-2013 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_DETAIL_SCOPE_GUARD_HPP
-#define BOOST_MULTI_INDEX_DETAIL_SCOPE_GUARD_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/detail/no_exceptions_support.hpp>
-#include <boost/mpl/if.hpp>
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-/* Until some official version of the ScopeGuard idiom makes it into Boost,
- * we locally define our own. This is a merely reformated version of
- * ScopeGuard.h as defined in:
- *   Alexandrescu, A., Marginean, P.:"Generic<Programming>: Change the Way You
- *     Write Exception-Safe Code - Forever", C/C++ Users Jornal, Dec 2000,
- *     http://www.drdobbs.com/184403758
- * with the following modifications:
- *   - General pretty formatting (pretty to my taste at least.)
- *   - Naming style changed to standard C++ library requirements.
- *   - Added scope_guard_impl4 and obj_scope_guard_impl3, (Boost.MultiIndex
- *     needs them). A better design would provide guards for many more
- *     arguments through the Boost Preprocessor Library.
- *   - Added scope_guard_impl_base::touch (see below.)
- *   - Removed RefHolder and ByRef, whose functionality is provided
- *     already by Boost.Ref.
- *   - Removed static make_guard's and make_obj_guard's, so that the code
- *     will work even if BOOST_NO_MEMBER_TEMPLATES is defined. This forces
- *     us to move some private ctors to public, though.
- *
- * NB: CodeWarrior Pro 8 seems to have problems looking up safe_execute
- * without an explicit qualification.
- * 
- * We also define the following variants of the idiom:
- * 
- *   - make_guard_if_c<bool>( ... )
- *   - make_guard_if<IntegralConstant>( ... )
- *   - make_obj_guard_if_c<bool>( ... )
- *   - make_obj_guard_if<IntegralConstant>( ... )
- * which may be used with a compile-time constant to yield
- * a "null_guard" if the boolean compile-time parameter is false,
- * or conversely, the guard is only constructed if the constant is true.
- * This is useful to avoid extra tagging, because the returned
- * null_guard can be optimzed comlpetely away by the compiler.
- */
-
-class scope_guard_impl_base
-{
-public:
-  scope_guard_impl_base():dismissed_(false){}
-  void dismiss()const{dismissed_=true;}
-
-  /* This helps prevent some "unused variable" warnings under, for instance,
-   * GCC 3.2.
-   */
-  void touch()const{}
-
-protected:
-  ~scope_guard_impl_base(){}
-
-  scope_guard_impl_base(const scope_guard_impl_base& other):
-    dismissed_(other.dismissed_)
-  {
-    other.dismiss();
-  }
-
-  template<typename J>
-  static void safe_execute(J& j){
-    BOOST_TRY{
-      if(!j.dismissed_)j.execute();
-    }
-    BOOST_CATCH(...){}
-    BOOST_CATCH_END
-  }
-  
-  mutable bool dismissed_;
-
-private:
-  scope_guard_impl_base& operator=(const scope_guard_impl_base&);
-};
-
-typedef const scope_guard_impl_base& scope_guard;
-
-struct null_guard : public scope_guard_impl_base
-{
-    template< class T1 >
-    null_guard( const T1& )
-    { }
-
-    template< class T1, class T2 >
-    null_guard( const T1&, const T2& )
-    { }
-
-    template< class T1, class T2, class T3 >
-    null_guard( const T1&, const T2&, const T3& )
-    { }
-
-    template< class T1, class T2, class T3, class T4 >
-    null_guard( const T1&, const T2&, const T3&, const T4& )
-    { }
-
-    template< class T1, class T2, class T3, class T4, class T5 >
-    null_guard( const T1&, const T2&, const T3&, const T4&, const T5& )
-    { }
-};
-
-template< bool cond, class T >
-struct null_guard_return
-{
-    typedef typename boost::mpl::if_c<cond,T,null_guard>::type type;
-};
-
-template<typename F>
-class scope_guard_impl0:public scope_guard_impl_base
-{
-public:
-  scope_guard_impl0(F fun):fun_(fun){}
-  ~scope_guard_impl0(){scope_guard_impl_base::safe_execute(*this);}
-  void execute(){fun_();}
-
-protected:
-
-  F fun_;
-};
-
-template<typename F> 
-inline scope_guard_impl0<F> make_guard(F fun)
-{
-  return scope_guard_impl0<F>(fun);
-}
-
-template<bool cond, typename F> 
-inline typename null_guard_return<cond,scope_guard_impl0<F> >::type  
-make_guard_if_c(F fun)
-{
-  return typename null_guard_return<cond,scope_guard_impl0<F> >::type(fun);
-}
-
-template<typename C, typename F> 
-inline typename null_guard_return<C::value,scope_guard_impl0<F> >::type  
-make_guard_if(F fun)
-{
-  return make_guard_if<C::value>(fun);
-}
-
-template<typename F,typename P1>
-class scope_guard_impl1:public scope_guard_impl_base
-{
-public:
-  scope_guard_impl1(F fun,P1 p1):fun_(fun),p1_(p1){}
-  ~scope_guard_impl1(){scope_guard_impl_base::safe_execute(*this);}
-  void execute(){fun_(p1_);}
-
-protected:
-  F        fun_;
-  const P1 p1_;
-};
-
-template<typename F,typename P1> 
-inline scope_guard_impl1<F,P1> make_guard(F fun,P1 p1)
-{
-  return scope_guard_impl1<F,P1>(fun,p1);
-}
-
-template<bool cond, typename F,typename P1> 
-inline typename null_guard_return<cond,scope_guard_impl1<F,P1> >::type 
-make_guard_if_c(F fun,P1 p1)
-{
-  return typename null_guard_return<cond,scope_guard_impl1<F,P1> >::type(fun,p1);
-}
-
-template<typename C, typename F,typename P1> 
-inline typename null_guard_return<C::value,scope_guard_impl1<F,P1> >::type 
-make_guard_if(F fun,P1 p1)
-{
-  return make_guard_if_c<C::value>(fun,p1);
-}
-
-template<typename F,typename P1,typename P2>
-class scope_guard_impl2:public scope_guard_impl_base
-{
-public:
-  scope_guard_impl2(F fun,P1 p1,P2 p2):fun_(fun),p1_(p1),p2_(p2){}
-  ~scope_guard_impl2(){scope_guard_impl_base::safe_execute(*this);}
-  void execute(){fun_(p1_,p2_);}
-
-protected:
-  F        fun_;
-  const P1 p1_;
-  const P2 p2_;
-};
-
-template<typename F,typename P1,typename P2>
-inline scope_guard_impl2<F,P1,P2> make_guard(F fun,P1 p1,P2 p2)
-{
-  return scope_guard_impl2<F,P1,P2>(fun,p1,p2);
-}
-
-template<bool cond, typename F,typename P1,typename P2>
-inline typename null_guard_return<cond,scope_guard_impl2<F,P1,P2> >::type
-make_guard_if_c(F fun,P1 p1,P2 p2)
-{
-  return typename null_guard_return<cond,scope_guard_impl2<F,P1,P2> >::type(fun,p1,p2);
-}
-
-template<typename C, typename F,typename P1,typename P2>
-inline typename null_guard_return<C::value,scope_guard_impl2<F,P1,P2> >::type
-make_guard_if(F fun,P1 p1,P2 p2)
-{
-  return make_guard_if_c<C::value>(fun,p1,p2);
-}
-
-template<typename F,typename P1,typename P2,typename P3>
-class scope_guard_impl3:public scope_guard_impl_base
-{
-public:
-  scope_guard_impl3(F fun,P1 p1,P2 p2,P3 p3):fun_(fun),p1_(p1),p2_(p2),p3_(p3){}
-  ~scope_guard_impl3(){scope_guard_impl_base::safe_execute(*this);}
-  void execute(){fun_(p1_,p2_,p3_);}
-
-protected:
-  F        fun_;
-  const P1 p1_;
-  const P2 p2_;
-  const P3 p3_;
-};
-
-template<typename F,typename P1,typename P2,typename P3>
-inline scope_guard_impl3<F,P1,P2,P3> make_guard(F fun,P1 p1,P2 p2,P3 p3)
-{
-  return scope_guard_impl3<F,P1,P2,P3>(fun,p1,p2,p3);
-}
-
-template<bool cond,typename F,typename P1,typename P2,typename P3>
-inline typename null_guard_return<cond,scope_guard_impl3<F,P1,P2,P3> >::type 
-make_guard_if_c(F fun,P1 p1,P2 p2,P3 p3)
-{
-  return typename null_guard_return<cond,scope_guard_impl3<F,P1,P2,P3> >::type(fun,p1,p2,p3);
-}
-
-template<typename C,typename F,typename P1,typename P2,typename P3>
-inline typename null_guard_return< C::value,scope_guard_impl3<F,P1,P2,P3> >::type 
-make_guard_if(F fun,P1 p1,P2 p2,P3 p3)
-{
-  return make_guard_if_c<C::value>(fun,p1,p2,p3);
-}
-
-template<typename F,typename P1,typename P2,typename P3,typename P4>
-class scope_guard_impl4:public scope_guard_impl_base
-{
-public:
-  scope_guard_impl4(F fun,P1 p1,P2 p2,P3 p3,P4 p4):
-    fun_(fun),p1_(p1),p2_(p2),p3_(p3),p4_(p4){}
-  ~scope_guard_impl4(){scope_guard_impl_base::safe_execute(*this);}
-  void execute(){fun_(p1_,p2_,p3_,p4_);}
-
-protected:
-  F        fun_;
-  const P1 p1_;
-  const P2 p2_;
-  const P3 p3_;
-  const P4 p4_;
-};
-
-template<typename F,typename P1,typename P2,typename P3,typename P4>
-inline scope_guard_impl4<F,P1,P2,P3,P4> make_guard(
-  F fun,P1 p1,P2 p2,P3 p3,P4 p4)
-{
-  return scope_guard_impl4<F,P1,P2,P3,P4>(fun,p1,p2,p3,p4);
-}
-
-template<bool cond, typename F,typename P1,typename P2,typename P3,typename P4>
-inline typename null_guard_return<cond,scope_guard_impl4<F,P1,P2,P3,P4> >::type 
-make_guard_if_c(
-  F fun,P1 p1,P2 p2,P3 p3,P4 p4)
-{
-  return typename null_guard_return<cond,scope_guard_impl4<F,P1,P2,P3,P4> >::type(fun,p1,p2,p3,p4);
-}
-
-template<typename C, typename F,typename P1,typename P2,typename P3,typename P4>
-inline typename null_guard_return<C::value,scope_guard_impl4<F,P1,P2,P3,P4> >::type 
-make_guard_if(
-  F fun,P1 p1,P2 p2,P3 p3,P4 p4)
-{
-  return make_guard_if_c<C::value>(fun,p1,p2,p3,p4);
-}
-
-template<class Obj,typename MemFun>
-class obj_scope_guard_impl0:public scope_guard_impl_base
-{
-public:
-  obj_scope_guard_impl0(Obj& obj,MemFun mem_fun):obj_(obj),mem_fun_(mem_fun){}
-  ~obj_scope_guard_impl0(){scope_guard_impl_base::safe_execute(*this);}
-  void execute(){(obj_.*mem_fun_)();}
-
-protected:
-  Obj&   obj_;
-  MemFun mem_fun_;
-};
-
-template<class Obj,typename MemFun>
-inline obj_scope_guard_impl0<Obj,MemFun> make_obj_guard(Obj& obj,MemFun mem_fun)
-{
-  return obj_scope_guard_impl0<Obj,MemFun>(obj,mem_fun);
-}
-
-template<bool cond, class Obj,typename MemFun>
-inline typename null_guard_return<cond,obj_scope_guard_impl0<Obj,MemFun> >::type 
-make_obj_guard_if_c(Obj& obj,MemFun mem_fun)
-{
-  return typename null_guard_return<cond,obj_scope_guard_impl0<Obj,MemFun> >::type(obj,mem_fun);
-}
-
-template<typename C, class Obj,typename MemFun>
-inline typename null_guard_return<C::value,obj_scope_guard_impl0<Obj,MemFun> >::type 
-make_obj_guard_if(Obj& obj,MemFun mem_fun)
-{
-  return make_obj_guard_if_c<C::value>(obj,mem_fun);
-}
-
-template<class Obj,typename MemFun,typename P1>
-class obj_scope_guard_impl1:public scope_guard_impl_base
-{
-public:
-  obj_scope_guard_impl1(Obj& obj,MemFun mem_fun,P1 p1):
-    obj_(obj),mem_fun_(mem_fun),p1_(p1){}
-  ~obj_scope_guard_impl1(){scope_guard_impl_base::safe_execute(*this);}
-  void execute(){(obj_.*mem_fun_)(p1_);}
-
-protected:
-  Obj&     obj_;
-  MemFun   mem_fun_;
-  const P1 p1_;
-};
-
-template<class Obj,typename MemFun,typename P1>
-inline obj_scope_guard_impl1<Obj,MemFun,P1> make_obj_guard(
-  Obj& obj,MemFun mem_fun,P1 p1)
-{
-  return obj_scope_guard_impl1<Obj,MemFun,P1>(obj,mem_fun,p1);
-}
-
-template<bool cond, class Obj,typename MemFun,typename P1>
-inline typename null_guard_return<cond,obj_scope_guard_impl1<Obj,MemFun,P1> >::type 
-make_obj_guard_if_c(  Obj& obj,MemFun mem_fun,P1 p1)
-{
-  return typename null_guard_return<cond,obj_scope_guard_impl1<Obj,MemFun,P1> >::type(obj,mem_fun,p1);
-}
-
-template<typename C, class Obj,typename MemFun,typename P1>
-inline typename null_guard_return<C::value,obj_scope_guard_impl1<Obj,MemFun,P1> >::type 
-make_obj_guard_if( Obj& obj,MemFun mem_fun,P1 p1)
-{
-  return make_obj_guard_if_c<C::value>(obj,mem_fun,p1);
-}
-
-template<class Obj,typename MemFun,typename P1,typename P2>
-class obj_scope_guard_impl2:public scope_guard_impl_base
-{
-public:
-  obj_scope_guard_impl2(Obj& obj,MemFun mem_fun,P1 p1,P2 p2):
-    obj_(obj),mem_fun_(mem_fun),p1_(p1),p2_(p2)
-  {}
-  ~obj_scope_guard_impl2(){scope_guard_impl_base::safe_execute(*this);}
-  void execute(){(obj_.*mem_fun_)(p1_,p2_);}
-
-protected:
-  Obj&     obj_;
-  MemFun   mem_fun_;
-  const P1 p1_;
-  const P2 p2_;
-};
-
-template<class Obj,typename MemFun,typename P1,typename P2>
-inline obj_scope_guard_impl2<Obj,MemFun,P1,P2>
-make_obj_guard(Obj& obj,MemFun mem_fun,P1 p1,P2 p2)
-{
-  return obj_scope_guard_impl2<Obj,MemFun,P1,P2>(obj,mem_fun,p1,p2);
-}
-
-template<bool cond, class Obj,typename MemFun,typename P1,typename P2>
-inline typename null_guard_return<cond,obj_scope_guard_impl2<Obj,MemFun,P1,P2> >::type
-make_obj_guard_if_c(Obj& obj,MemFun mem_fun,P1 p1,P2 p2)
-{
-  return typename null_guard_return<cond,obj_scope_guard_impl2<Obj,MemFun,P1,P2> >::type(obj,mem_fun,p1,p2);
-}
-
-template<typename C, class Obj,typename MemFun,typename P1,typename P2>
-inline typename null_guard_return<C::value,obj_scope_guard_impl2<Obj,MemFun,P1,P2> >::type
-make_obj_guard_if(Obj& obj,MemFun mem_fun,P1 p1,P2 p2)
-{
-  return make_obj_guard_if_c<C::value>(obj,mem_fun,p1,p2);
-}
-
-template<class Obj,typename MemFun,typename P1,typename P2,typename P3>
-class obj_scope_guard_impl3:public scope_guard_impl_base
-{
-public:
-  obj_scope_guard_impl3(Obj& obj,MemFun mem_fun,P1 p1,P2 p2,P3 p3):
-    obj_(obj),mem_fun_(mem_fun),p1_(p1),p2_(p2),p3_(p3)
-  {}
-  ~obj_scope_guard_impl3(){scope_guard_impl_base::safe_execute(*this);}
-  void execute(){(obj_.*mem_fun_)(p1_,p2_,p3_);}
-
-protected:
-  Obj&     obj_;
-  MemFun   mem_fun_;
-  const P1 p1_;
-  const P2 p2_;
-  const P3 p3_;
-};
-
-template<class Obj,typename MemFun,typename P1,typename P2,typename P3>
-inline obj_scope_guard_impl3<Obj,MemFun,P1,P2,P3>
-make_obj_guard(Obj& obj,MemFun mem_fun,P1 p1,P2 p2,P3 p3)
-{
-  return obj_scope_guard_impl3<Obj,MemFun,P1,P2,P3>(obj,mem_fun,p1,p2,p3);
-}
-
-template<bool cond, class Obj,typename MemFun,typename P1,typename P2,typename P3>
-inline typename null_guard_return<cond,obj_scope_guard_impl3<Obj,MemFun,P1,P2,P3> >::type
-make_obj_guard_if_c(Obj& obj,MemFun mem_fun,P1 p1,P2 p2,P3 p3)
-{
-  return typename null_guard_return<cond,obj_scope_guard_impl3<Obj,MemFun,P1,P2,P3> >::type(obj,mem_fun,p1,p2,p3);
-}
-
-template<typename C, class Obj,typename MemFun,typename P1,typename P2,typename P3>
-inline typename null_guard_return<C::value,obj_scope_guard_impl3<Obj,MemFun,P1,P2,P3> >::type
-make_obj_guard_if(Obj& obj,MemFun mem_fun,P1 p1,P2 p2,P3 p3)
-{
-  return make_obj_guard_if_c<C::value>(obj,mem_fun,p1,p2,p3);
-}
-
-} /* namespace multi_index::detail */
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/seq_index_node.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/seq_index_node.hpp
deleted file mode 100644
index 85b345af938..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/seq_index_node.hpp
+++ /dev/null
@@ -1,217 +0,0 @@
-/* Copyright 2003-2015 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_DETAIL_SEQ_INDEX_NODE_HPP
-#define BOOST_MULTI_INDEX_DETAIL_SEQ_INDEX_NODE_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <algorithm>
-#include <boost/detail/allocator_utilities.hpp>
-#include <boost/multi_index/detail/raw_ptr.hpp>
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-/* doubly-linked node for use by sequenced_index */
-
-template<typename Allocator>
-struct sequenced_index_node_impl
-{
-  typedef typename
-  boost::detail::allocator::rebind_to<
-    Allocator,sequenced_index_node_impl
-  >::type::pointer                      pointer;
-  typedef typename
-  boost::detail::allocator::rebind_to<
-    Allocator,sequenced_index_node_impl
-  >::type::const_pointer                const_pointer;
-
-  pointer& prior(){return prior_;}
-  pointer  prior()const{return prior_;}
-  pointer& next(){return next_;}
-  pointer  next()const{return next_;}
-
-  /* interoperability with bidir_node_iterator */
-
-  static void increment(pointer& x){x=x->next();}
-  static void decrement(pointer& x){x=x->prior();}
-
-  /* algorithmic stuff */
-
-  static void link(pointer x,pointer header)
-  {
-    x->prior()=header->prior();
-    x->next()=header;
-    x->prior()->next()=x->next()->prior()=x;
-  };
-
-  static void unlink(pointer x)
-  {
-    x->prior()->next()=x->next();
-    x->next()->prior()=x->prior();
-  }
-
-  static void relink(pointer position,pointer x)
-  {
-    unlink(x);
-    x->prior()=position->prior();
-    x->next()=position;
-    x->prior()->next()=x->next()->prior()=x;
-  }
-
-  static void relink(pointer position,pointer x,pointer y)
-  {
-    /* position is assumed not to be in [x,y) */
-
-    if(x!=y){
-      pointer z=y->prior();
-      x->prior()->next()=y;
-      y->prior()=x->prior();
-      x->prior()=position->prior();
-      z->next()=position;
-      x->prior()->next()=x;
-      z->next()->prior()=z;
-    }
-  }
-
-  static void reverse(pointer header)
-  {
-    pointer x=header;
-    do{
-      pointer y=x->next();
-      std::swap(x->prior(),x->next());
-      x=y;
-    }while(x!=header);
-  }
-
-  static void swap(pointer x,pointer y)
-  {
-    /* This swap function does not exchange the header nodes,
-     * but rather their pointers. This is *not* used for implementing
-     * sequenced_index::swap.
-     */
-
-    if(x->next()!=x){
-      if(y->next()!=y){
-        std::swap(x->next(),y->next());
-        std::swap(x->prior(),y->prior());
-        x->next()->prior()=x->prior()->next()=x;
-        y->next()->prior()=y->prior()->next()=y;
-      }
-      else{
-        y->next()=x->next();
-        y->prior()=x->prior();
-        x->next()=x->prior()=x;
-        y->next()->prior()=y->prior()->next()=y;
-      }
-    }
-    else if(y->next()!=y){
-      x->next()=y->next();
-      x->prior()=y->prior();
-      y->next()=y->prior()=y;
-      x->next()->prior()=x->prior()->next()=x;
-    }
-  }
-
-private:
-  pointer prior_;
-  pointer next_;
-};
-
-template<typename Super>
-struct sequenced_index_node_trampoline:
-  sequenced_index_node_impl<
-    typename boost::detail::allocator::rebind_to<
-      typename Super::allocator_type,
-      char
-    >::type
-  >
-{
-  typedef sequenced_index_node_impl<
-    typename boost::detail::allocator::rebind_to<
-      typename Super::allocator_type,
-      char
-    >::type
-  > impl_type;
-};
-
-template<typename Super>
-struct sequenced_index_node:Super,sequenced_index_node_trampoline<Super>
-{
-private:
-  typedef sequenced_index_node_trampoline<Super> trampoline;
-
-public:
-  typedef typename trampoline::impl_type         impl_type;
-  typedef typename trampoline::pointer           impl_pointer;
-  typedef typename trampoline::const_pointer     const_impl_pointer;
-
-  impl_pointer& prior(){return trampoline::prior();}
-  impl_pointer  prior()const{return trampoline::prior();}
-  impl_pointer& next(){return trampoline::next();}
-  impl_pointer  next()const{return trampoline::next();}
-
-  impl_pointer impl()
-  {
-    return static_cast<impl_pointer>(
-      static_cast<impl_type*>(static_cast<trampoline*>(this)));
-  }
-
-  const_impl_pointer impl()const
-  {
-    return static_cast<const_impl_pointer>(
-      static_cast<const impl_type*>(static_cast<const trampoline*>(this)));
-  }
-
-  static sequenced_index_node* from_impl(impl_pointer x)
-  {
-    return
-      static_cast<sequenced_index_node*>(
-        static_cast<trampoline*>(
-          raw_ptr<impl_type*>(x)));
-  }
-
-  static const sequenced_index_node* from_impl(const_impl_pointer x)
-  {
-    return
-      static_cast<const sequenced_index_node*>(
-        static_cast<const trampoline*>(
-          raw_ptr<const impl_type*>(x)));
-  }
-
-  /* interoperability with bidir_node_iterator */
-
-  static void increment(sequenced_index_node*& x)
-  {
-    impl_pointer xi=x->impl();
-    trampoline::increment(xi);
-    x=from_impl(xi);
-  }
-
-  static void decrement(sequenced_index_node*& x)
-  {
-    impl_pointer xi=x->impl();
-    trampoline::decrement(xi);
-    x=from_impl(xi);
-  }
-};
-
-} /* namespace multi_index::detail */
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/seq_index_ops.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/seq_index_ops.hpp
deleted file mode 100644
index 142bdd9dd9a..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/seq_index_ops.hpp
+++ /dev/null
@@ -1,203 +0,0 @@
-/* Copyright 2003-2016 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_DETAIL_SEQ_INDEX_OPS_HPP
-#define BOOST_MULTI_INDEX_DETAIL_SEQ_INDEX_OPS_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <boost/detail/no_exceptions_support.hpp>
-#include <boost/multi_index/detail/seq_index_node.hpp>
-#include <boost/limits.hpp>
-#include <boost/type_traits/aligned_storage.hpp>
-#include <boost/type_traits/alignment_of.hpp> 
-#include <cstddef>
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-/* Common code for sequenced_index memfuns having templatized and
- * non-templatized versions.
- */
-
-template <typename SequencedIndex,typename Predicate>
-void sequenced_index_remove(SequencedIndex& x,Predicate pred)
-{
-  typedef typename SequencedIndex::iterator iterator;
-  iterator first=x.begin(),last=x.end();
-  while(first!=last){
-    if(pred(*first))x.erase(first++);
-    else ++first;
-  }
-}
-
-template <typename SequencedIndex,class BinaryPredicate>
-void sequenced_index_unique(SequencedIndex& x,BinaryPredicate binary_pred)
-{
-  typedef typename SequencedIndex::iterator iterator;
-  iterator first=x.begin();
-  iterator last=x.end();
-  if(first!=last){
-    for(iterator middle=first;++middle!=last;middle=first){
-      if(binary_pred(*middle,*first))x.erase(middle);
-      else first=middle;
-    }
-  }
-}
-
-template <typename SequencedIndex,typename Compare>
-void sequenced_index_merge(SequencedIndex& x,SequencedIndex& y,Compare comp)
-{
-  typedef typename SequencedIndex::iterator iterator;
-  if(&x!=&y){
-    iterator first0=x.begin(),last0=x.end();
-    iterator first1=y.begin(),last1=y.end();
-    while(first0!=last0&&first1!=last1){
-      if(comp(*first1,*first0))x.splice(first0,y,first1++);
-      else ++first0;
-    }
-    x.splice(last0,y,first1,last1);
-  }
-}
-
-/* sorting  */
-
-/* auxiliary stuff */
-
-template<typename Node,typename Compare>
-void sequenced_index_collate(
-  BOOST_DEDUCED_TYPENAME Node::impl_type* x,
-  BOOST_DEDUCED_TYPENAME Node::impl_type* y,
-  Compare comp)
-{
-  typedef typename Node::impl_type    impl_type;
-  typedef typename Node::impl_pointer impl_pointer;
-
-  impl_pointer first0=x->next();
-  impl_pointer last0=x;
-  impl_pointer first1=y->next();
-  impl_pointer last1=y;
-  while(first0!=last0&&first1!=last1){
-    if(comp(
-        Node::from_impl(first1)->value(),Node::from_impl(first0)->value())){
-      impl_pointer tmp=first1->next();
-      impl_type::relink(first0,first1);
-      first1=tmp;
-    }
-    else first0=first0->next();
-  }
-  impl_type::relink(last0,first1,last1);
-}
-
-/* Some versions of CGG require a bogus typename in counter_spc
- * inside sequenced_index_sort if the following is defined
- * also inside sequenced_index_sort.
- */
-
-BOOST_STATIC_CONSTANT(
-  std::size_t,
-  sequenced_index_sort_max_fill=
-    (std::size_t)std::numeric_limits<std::size_t>::digits+1);
-
-#include <boost/multi_index/detail/ignore_wstrict_aliasing.hpp>
-
-template<typename Node,typename Compare>
-void sequenced_index_sort(Node* header,Compare comp)
-{
-  /* Musser's mergesort, see http://www.cs.rpi.edu/~musser/gp/List/lists1.html.
-   * The implementation is a little convoluted: in the original code
-   * counter elements and carry are std::lists: here we do not want
-   * to use multi_index instead, so we do things at a lower level, managing
-   * directly the internal node representation.
-   * Incidentally, the implementations I've seen of this algorithm (SGI,
-   * Dinkumware, STLPort) are not exception-safe: this is. Moreover, we do not
-   * use any dynamic storage.
-   */
-
-  if(header->next()==header->impl()||
-     header->next()->next()==header->impl())return;
-
-  typedef typename Node::impl_type      impl_type;
-  typedef typename Node::impl_pointer   impl_pointer;
-
-  typedef typename aligned_storage<
-    sizeof(impl_type),
-    alignment_of<impl_type>::value
-  >::type                               carry_spc_type;
-  carry_spc_type                        carry_spc;
-  impl_type&                            carry=
-    *reinterpret_cast<impl_type*>(&carry_spc);
-  typedef typename aligned_storage<
-    sizeof(
-      impl_type
-        [sequenced_index_sort_max_fill]),
-    alignment_of<
-      impl_type
-        [sequenced_index_sort_max_fill]
-    >::value
-  >::type                               counter_spc_type;
-  counter_spc_type                      counter_spc;
-  impl_type*                            counter=
-    reinterpret_cast<impl_type*>(&counter_spc);
-  std::size_t                           fill=0;
-
-  carry.prior()=carry.next()=static_cast<impl_pointer>(&carry);
-  counter[0].prior()=counter[0].next()=static_cast<impl_pointer>(&counter[0]);
-
-  BOOST_TRY{
-    while(header->next()!=header->impl()){
-      impl_type::relink(carry.next(),header->next());
-      std::size_t i=0;
-      while(i<fill&&counter[i].next()!=static_cast<impl_pointer>(&counter[i])){
-        sequenced_index_collate<Node>(&carry,&counter[i++],comp);
-      }
-      impl_type::swap(
-        static_cast<impl_pointer>(&carry),
-        static_cast<impl_pointer>(&counter[i]));
-      if(i==fill){
-        ++fill;
-        counter[fill].prior()=counter[fill].next()=
-          static_cast<impl_pointer>(&counter[fill]);
-      }
-    }
-
-    for(std::size_t i=1;i<fill;++i){
-      sequenced_index_collate<Node>(&counter[i],&counter[i-1],comp);
-    }
-    impl_type::swap(
-      header->impl(),static_cast<impl_pointer>(&counter[fill-1]));
-  }
-  BOOST_CATCH(...)
-  {
-    impl_type::relink(
-      header->impl(),carry.next(),static_cast<impl_pointer>(&carry));
-    for(std::size_t i=0;i<=fill;++i){
-      impl_type::relink(
-        header->impl(),counter[i].next(),
-        static_cast<impl_pointer>(&counter[i]));
-    }
-    BOOST_RETHROW;
-  }
-  BOOST_CATCH_END
-}
-
-#include <boost/multi_index/detail/restore_wstrict_aliasing.hpp>
-
-} /* namespace multi_index::detail */
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/serialization_version.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/serialization_version.hpp
deleted file mode 100644
index ccd8bb4f791..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/serialization_version.hpp
+++ /dev/null
@@ -1,73 +0,0 @@
-/* Copyright 2003-2013 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_DETAIL_SERIALIZATION_VERSION_HPP
-#define BOOST_MULTI_INDEX_DETAIL_SERIALIZATION_VERSION_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <boost/serialization/split_member.hpp>
-#include <boost/serialization/version.hpp>
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-/* Helper class for storing and retrieving a given type serialization class
- * version while avoiding saving the number multiple times in the same
- * archive.
- * Behavior undefined if template partial specialization is not supported.
- */
-
-template<typename T>
-struct serialization_version
-{
-  serialization_version():
-    value(boost::serialization::version<serialization_version>::value){}
-
-  serialization_version& operator=(unsigned int x){value=x;return *this;};
-
-  operator unsigned int()const{return value;}
-
-private:
-  friend class boost::serialization::access;
-
-  BOOST_SERIALIZATION_SPLIT_MEMBER()
-
-  template<class Archive>
-  void save(Archive&,const unsigned int)const{}
-
-  template<class Archive>
-  void load(Archive&,const unsigned int version)
-  {
-    this->value=version;
-  }
-
-  unsigned int value;
-};
-
-} /* namespace multi_index::detail */
-
-} /* namespace multi_index */
-
-namespace serialization {
-template<typename T>
-struct version<boost::multi_index::detail::serialization_version<T> >
-{
-  BOOST_STATIC_CONSTANT(int,value=version<T>::value);
-};
-} /* namespace serialization */
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/uintptr_type.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/uintptr_type.hpp
deleted file mode 100644
index 9c92d01d4de..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/uintptr_type.hpp
+++ /dev/null
@@ -1,76 +0,0 @@
-/* Copyright 2003-2013 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_DETAIL_UINTPTR_TYPE_HPP
-#define BOOST_MULTI_INDEX_DETAIL_UINTPTR_TYPE_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <boost/mpl/bool.hpp>
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-/* has_uintptr_type is an MPL integral constant determining whether
- * there exists an unsigned integral type with the same size as
- * void *.
- * uintptr_type is such a type if has_uintptr is true, or unsigned int
- * otherwise.
- * Note that uintptr_type is more restrictive than C99 uintptr_t,
- * where an integral type with size greater than that of void *
- * would be conformant.
- */
-
-template<int N>struct uintptr_candidates;
-template<>struct uintptr_candidates<-1>{typedef unsigned int           type;};
-template<>struct uintptr_candidates<0> {typedef unsigned int           type;};
-template<>struct uintptr_candidates<1> {typedef unsigned short         type;};
-template<>struct uintptr_candidates<2> {typedef unsigned long          type;};
-
-#if defined(BOOST_HAS_LONG_LONG)
-template<>struct uintptr_candidates<3> {typedef boost::ulong_long_type type;};
-#else
-template<>struct uintptr_candidates<3> {typedef unsigned int           type;};
-#endif
-
-#if defined(BOOST_HAS_MS_INT64)
-template<>struct uintptr_candidates<4> {typedef unsigned __int64       type;};
-#else
-template<>struct uintptr_candidates<4> {typedef unsigned int           type;};
-#endif
-
-struct uintptr_aux
-{
-  BOOST_STATIC_CONSTANT(int,index=
-    sizeof(void*)==sizeof(uintptr_candidates<0>::type)?0:
-    sizeof(void*)==sizeof(uintptr_candidates<1>::type)?1:
-    sizeof(void*)==sizeof(uintptr_candidates<2>::type)?2:
-    sizeof(void*)==sizeof(uintptr_candidates<3>::type)?3:
-    sizeof(void*)==sizeof(uintptr_candidates<4>::type)?4:-1);
-
-  BOOST_STATIC_CONSTANT(bool,has_uintptr_type=(index>=0));
-
-  typedef uintptr_candidates<index>::type type;
-};
-
-typedef mpl::bool_<uintptr_aux::has_uintptr_type> has_uintptr_type;
-typedef uintptr_aux::type                         uintptr_type;
-
-} /* namespace multi_index::detail */
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/unbounded.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/unbounded.hpp
deleted file mode 100644
index dc09be1770d..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/unbounded.hpp
+++ /dev/null
@@ -1,66 +0,0 @@
-/* Copyright 2003-2013 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_DETAIL_UNBOUNDED_HPP
-#define BOOST_MULTI_INDEX_DETAIL_UNBOUNDED_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <boost/detail/workaround.hpp>
-
-namespace boost{
-
-namespace multi_index{
-
-/* dummy type and variable for use in ordered_index::range() */
-
-/* ODR-abiding technique shown at the example attached to
- * http://lists.boost.org/Archives/boost/2006/07/108355.php
- */
-
-namespace detail{class unbounded_helper;}
-
-detail::unbounded_helper unbounded(detail::unbounded_helper);
-
-namespace detail{
-
-class unbounded_helper
-{
-  unbounded_helper(){}
-  unbounded_helper(const unbounded_helper&){}
-  friend unbounded_helper multi_index::unbounded(unbounded_helper);
-};
-
-typedef unbounded_helper (*unbounded_type)(unbounded_helper);
-
-} /* namespace multi_index::detail */
-
-inline detail::unbounded_helper unbounded(detail::unbounded_helper)
-{
-  return detail::unbounded_helper();
-}
-
-/* tags used in the implementation of range */
-
-namespace detail{
-
-struct none_unbounded_tag{};
-struct lower_unbounded_tag{};
-struct upper_unbounded_tag{};
-struct both_unbounded_tag{};
-
-} /* namespace multi_index::detail */
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/value_compare.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/value_compare.hpp
deleted file mode 100644
index ac42e8779aa..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/value_compare.hpp
+++ /dev/null
@@ -1,56 +0,0 @@
-/* Copyright 2003-2015 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_DETAIL_VALUE_COMPARE_HPP
-#define BOOST_MULTI_INDEX_DETAIL_VALUE_COMPARE_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <boost/call_traits.hpp>
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-template<typename Value,typename KeyFromValue,typename Compare>
-struct value_comparison
-{
-  typedef Value first_argument_type;
-  typedef Value second_argument_type;
-  typedef bool  result_type;
-
-  value_comparison(
-    const KeyFromValue& key_=KeyFromValue(),const Compare& comp_=Compare()):
-    key(key_),comp(comp_)
-  {
-  }
-
-  bool operator()(
-    typename call_traits<Value>::param_type x,
-    typename call_traits<Value>::param_type y)const
-  {
-    return comp(key(x),key(y));
-  }
-
-private:
-  KeyFromValue key;
-  Compare      comp;
-};
-
-} /* namespace multi_index::detail */
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/vartempl_support.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/detail/vartempl_support.hpp
deleted file mode 100644
index 06ff430f4be..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/detail/vartempl_support.hpp
+++ /dev/null
@@ -1,247 +0,0 @@
-/* Copyright 2003-2013 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_DETAIL_VARTEMPL_SUPPORT_HPP
-#define BOOST_MULTI_INDEX_DETAIL_VARTEMPL_SUPPORT_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-/* Utilities for emulation of variadic template functions. Variadic packs are
- * replaced by lists of BOOST_MULTI_INDEX_LIMIT_VARTEMPL_ARGS parameters:
- *
- *   - typename... Args            --> BOOST_MULTI_INDEX_TEMPLATE_PARAM_PACK
- *   - Args&&... args              --> BOOST_MULTI_INDEX_FUNCTION_PARAM_PACK
- *   - std::forward<Args>(args)... --> BOOST_MULTI_INDEX_FORWARD_PARAM_PACK
- *
- * Forwarding emulated with Boost.Move. A template functions foo_imp
- * defined in such way accepts *exactly* BOOST_MULTI_INDEX_LIMIT_VARTEMPL_ARGS
- * arguments: variable number of arguments is emulated by providing a set of
- * overloads foo forwarding to foo_impl with
- * 
- *   BOOST_MULTI_INDEX_OVERLOADS_TO_VARTEMPL
- *   BOOST_MULTI_INDEX_OVERLOADS_TO_VARTEMPL_EXTRA_ARG (initial extra arg)
- *
- * which fill the extra args with boost::multi_index::detail::noarg's.
- * boost::multi_index::detail::vartempl_placement_new works the opposite
- * way: it acceps a full a pointer x to Value and a
- * BOOST_MULTI_INDEX_FUNCTION_PARAM_PACK and forwards to
- * new(x) Value(args) where args is the argument pack after discarding
- * noarg's.
- *
- * Emulation decays to the real thing when the compiler supports variadic
- * templates and move semantics natively.
- */
-
-#include <boost/config.hpp>
-
-#if defined(BOOST_NO_CXX11_RVALUE_REFERENCES)||\
-    defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-
-#include <boost/move/core.hpp>
-#include <boost/move/utility.hpp>
-#include <boost/preprocessor/arithmetic/add.hpp>
-#include <boost/preprocessor/arithmetic/sub.hpp>
-#include <boost/preprocessor/cat.hpp>
-#include <boost/preprocessor/control/if.hpp>
-#include <boost/preprocessor/facilities/empty.hpp>
-#include <boost/preprocessor/facilities/intercept.hpp>
-#include <boost/preprocessor/logical/and.hpp>
-#include <boost/preprocessor/punctuation/comma.hpp>
-#include <boost/preprocessor/punctuation/comma_if.hpp>
-#include <boost/preprocessor/repetition/enum.hpp>
-#include <boost/preprocessor/repetition/enum_params.hpp>
-#include <boost/preprocessor/repetition/repeat_from_to.hpp>
-#include <boost/preprocessor/seq/elem.hpp>
-
-#if !defined(BOOST_MULTI_INDEX_LIMIT_VARTEMPL_ARGS)
-#define BOOST_MULTI_INDEX_LIMIT_VARTEMPL_ARGS 5
-#endif
-
-#define BOOST_MULTI_INDEX_TEMPLATE_PARAM_PACK                        \
-BOOST_PP_ENUM_PARAMS(                                                \
-  BOOST_MULTI_INDEX_LIMIT_VARTEMPL_ARGS,typename T)
-
-#define BOOST_MULTI_INDEX_VARTEMPL_ARG(z,n,_)                        \
-BOOST_FWD_REF(BOOST_PP_CAT(T,n)) BOOST_PP_CAT(t,n)
-
-#define BOOST_MULTI_INDEX_FUNCTION_PARAM_PACK                        \
-BOOST_PP_ENUM(                                                       \
-  BOOST_MULTI_INDEX_LIMIT_VARTEMPL_ARGS,                             \
-  BOOST_MULTI_INDEX_VARTEMPL_ARG,~)
-
-#define BOOST_MULTI_INDEX_VARTEMPL_FORWARD_ARG(z,n,_)                \
-boost::forward<BOOST_PP_CAT(T,n)>(BOOST_PP_CAT(t,n))
-
-#define BOOST_MULTI_INDEX_FORWARD_PARAM_PACK                         \
-BOOST_PP_ENUM(                                                       \
-  BOOST_MULTI_INDEX_LIMIT_VARTEMPL_ARGS,                             \
-  BOOST_MULTI_INDEX_VARTEMPL_FORWARD_ARG,~)
-
-namespace boost{namespace multi_index{namespace detail{
-struct noarg{};
-}}}
-
-/* call vartempl function without args */
-
-#define BOOST_MULTI_INDEX_NULL_PARAM_PACK                            \
-BOOST_PP_ENUM_PARAMS(                                                \
-  BOOST_MULTI_INDEX_LIMIT_VARTEMPL_ARGS,                             \
-  boost::multi_index::detail::noarg() BOOST_PP_INTERCEPT)
-
-#define BOOST_MULTI_INDEX_TEMPLATE_N(n)                              \
-template<BOOST_PP_ENUM_PARAMS(n,typename T)>
-
-#define BOOST_MULTI_INDEX_TEMPLATE_0(n)
-
-#define BOOST_MULTI_INDEX_OVERLOADS_TO_VARTEMPL_AUX(z,n,data)        \
-BOOST_PP_IF(n,                                                       \
-  BOOST_MULTI_INDEX_TEMPLATE_N,                                      \
-  BOOST_MULTI_INDEX_TEMPLATE_0)(n)                                   \
-BOOST_PP_SEQ_ELEM(0,data) /* ret */                                  \
-BOOST_PP_SEQ_ELEM(1,data) /* name_from */ (                          \
-  BOOST_PP_ENUM(n,BOOST_MULTI_INDEX_VARTEMPL_ARG,~))                 \
-{                                                                    \
-  return BOOST_PP_SEQ_ELEM(2,data) /* name_to */ (                   \
-    BOOST_PP_ENUM(n,BOOST_MULTI_INDEX_VARTEMPL_FORWARD_ARG,~)        \
-    BOOST_PP_COMMA_IF(                                               \
-      BOOST_PP_AND(                                                  \
-        n,BOOST_PP_SUB(BOOST_MULTI_INDEX_LIMIT_VARTEMPL_ARGS,n)))    \
-    BOOST_PP_ENUM_PARAMS(                                            \
-      BOOST_PP_SUB(BOOST_MULTI_INDEX_LIMIT_VARTEMPL_ARGS,n),         \
-      boost::multi_index::detail::noarg() BOOST_PP_INTERCEPT)        \
-  );                                                                 \
-}
-
-#define BOOST_MULTI_INDEX_OVERLOADS_TO_VARTEMPL(                     \
-  ret,name_from,name_to)                                             \
-BOOST_PP_REPEAT_FROM_TO(                                             \
-  0,BOOST_PP_ADD(BOOST_MULTI_INDEX_LIMIT_VARTEMPL_ARGS,1),           \
-  BOOST_MULTI_INDEX_OVERLOADS_TO_VARTEMPL_AUX,                       \
-  (ret)(name_from)(name_to))
-
-#define BOOST_MULTI_INDEX_OVERLOADS_TO_VARTEMPL_EXTRA_ARG_AUX(       \
-  z,n,data)                                                          \
-BOOST_PP_IF(n,                                                       \
-  BOOST_MULTI_INDEX_TEMPLATE_N,                                      \
-  BOOST_MULTI_INDEX_TEMPLATE_0)(n)                                   \
-BOOST_PP_SEQ_ELEM(0,data) /* ret */                                  \
-BOOST_PP_SEQ_ELEM(1,data) /* name_from */ (                          \
-  BOOST_PP_SEQ_ELEM(3,data) BOOST_PP_SEQ_ELEM(4,data) /* extra arg */\
-  BOOST_PP_COMMA_IF(n)                                               \
-  BOOST_PP_ENUM(n,BOOST_MULTI_INDEX_VARTEMPL_ARG,~))                 \
-{                                                                    \
-  return BOOST_PP_SEQ_ELEM(2,data) /* name_to */ (                   \
-    BOOST_PP_SEQ_ELEM(4,data) /* extra_arg_name */                   \
-    BOOST_PP_COMMA_IF(n)                                             \
-    BOOST_PP_ENUM(n,BOOST_MULTI_INDEX_VARTEMPL_FORWARD_ARG,~)        \
-    BOOST_PP_COMMA_IF(                                               \
-      BOOST_PP_SUB(BOOST_MULTI_INDEX_LIMIT_VARTEMPL_ARGS,n))         \
-    BOOST_PP_ENUM_PARAMS(                                            \
-      BOOST_PP_SUB(BOOST_MULTI_INDEX_LIMIT_VARTEMPL_ARGS,n),         \
-      boost::multi_index::detail::noarg() BOOST_PP_INTERCEPT)        \
-  );                                                                 \
-}
-
-#define BOOST_MULTI_INDEX_OVERLOADS_TO_VARTEMPL_EXTRA_ARG(           \
-  ret,name_from,name_to,extra_arg_type,extra_arg_name)               \
-BOOST_PP_REPEAT_FROM_TO(                                             \
-  0,BOOST_PP_ADD(BOOST_MULTI_INDEX_LIMIT_VARTEMPL_ARGS,1),           \
-  BOOST_MULTI_INDEX_OVERLOADS_TO_VARTEMPL_EXTRA_ARG_AUX,             \
-  (ret)(name_from)(name_to)(extra_arg_type)(extra_arg_name))
-
-namespace boost{
-  
-namespace multi_index{
-  
-namespace detail{
-
-#define BOOST_MULTI_INDEX_VARTEMPL_TO_PLACEMENT_NEW_AUX(z,n,name)    \
-template<                                                            \
-  typename Value                                                     \
-  BOOST_PP_COMMA_IF(n)                                               \
-  BOOST_PP_ENUM_PARAMS(n,typename T)                                 \
->                                                                    \
-Value* name(                                                         \
-  Value* x                                                           \
-  BOOST_PP_COMMA_IF(n)                                               \
-  BOOST_PP_ENUM(n,BOOST_MULTI_INDEX_VARTEMPL_ARG,~)                  \
-  BOOST_PP_COMMA_IF(                                                 \
-    BOOST_PP_SUB(BOOST_MULTI_INDEX_LIMIT_VARTEMPL_ARGS,n))           \
-  BOOST_PP_ENUM_PARAMS(                                              \
-    BOOST_PP_SUB(BOOST_MULTI_INDEX_LIMIT_VARTEMPL_ARGS,n),           \
-    BOOST_FWD_REF(noarg) BOOST_PP_INTERCEPT))                        \
-{                                                                    \
-  return new(x) Value(                                               \
-    BOOST_PP_ENUM(n,BOOST_MULTI_INDEX_VARTEMPL_FORWARD_ARG,~));      \
-}
-
-#define BOOST_MULTI_INDEX_VARTEMPL_TO_PLACEMENT_NEW(name)            \
-BOOST_PP_REPEAT_FROM_TO(                                             \
-  0,BOOST_PP_ADD(BOOST_MULTI_INDEX_LIMIT_VARTEMPL_ARGS,1),           \
-  BOOST_MULTI_INDEX_VARTEMPL_TO_PLACEMENT_NEW_AUX,                   \
-  name)
-
-BOOST_MULTI_INDEX_VARTEMPL_TO_PLACEMENT_NEW(vartempl_placement_new)
-
-#undef BOOST_MULTI_INDEX_VARTEMPL_TO_PLACEMENT_NEW_AUX
-#undef BOOST_MULTI_INDEX_VARTEMPL_TO_PLACEMENT_NEW
-
-} /* namespace multi_index::detail */
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#else
-
-/* native variadic templates support */
-
-#include <utility>
-
-#define BOOST_MULTI_INDEX_TEMPLATE_PARAM_PACK typename... Args
-#define BOOST_MULTI_INDEX_FUNCTION_PARAM_PACK Args&&... args
-#define BOOST_MULTI_INDEX_FORWARD_PARAM_PACK  std::forward<Args>(args)...
-#define BOOST_MULTI_INDEX_NULL_PARAM_PACK
-
-#define BOOST_MULTI_INDEX_OVERLOADS_TO_VARTEMPL(                     \
-  ret,name_from,name_to)                                             \
-template<typename... Args> ret name_from(Args&&... args)             \
-{                                                                    \
-  return name_to(std::forward<Args>(args)...);                       \
-}
-
-#define BOOST_MULTI_INDEX_OVERLOADS_TO_VARTEMPL_EXTRA_ARG(           \
-  ret,name_from,name_to,extra_arg_type,extra_arg_name)               \
-template<typename... Args> ret name_from(                            \
-  extra_arg_type extra_arg_name,Args&&... args)                      \
-{                                                                    \
-  return name_to(extra_arg_name,std::forward<Args>(args)...);        \
-}
-
-namespace boost{
-  
-namespace multi_index{
-  
-namespace detail{
-
-template<typename Value,typename... Args>
-Value* vartempl_placement_new(Value*x,Args&&... args)
-{
-  return new(x) Value(std::forward<Args>(args)...);
-}
-
-} /* namespace multi_index::detail */
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/global_fun.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/global_fun.hpp
deleted file mode 100644
index 2c13769100c..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/global_fun.hpp
+++ /dev/null
@@ -1,185 +0,0 @@
-/* Copyright 2003-2015 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_GLOBAL_FUN_HPP
-#define BOOST_MULTI_INDEX_GLOBAL_FUN_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <boost/detail/workaround.hpp>
-#include <boost/mpl/if.hpp>
-#include <boost/type_traits/is_const.hpp>
-#include <boost/type_traits/is_reference.hpp>
-#include <boost/type_traits/remove_const.hpp>
-#include <boost/type_traits/remove_reference.hpp>
-#include <boost/utility/enable_if.hpp>
-
-#if !defined(BOOST_NO_SFINAE)
-#include <boost/type_traits/is_convertible.hpp>
-#endif
-
-namespace boost{
-
-template<class T> class reference_wrapper; /* fwd decl. */
-
-namespace multi_index{
-
-namespace detail{
-
-/* global_fun is a read-only key extractor from Value based on a given global
- * (or static member) function with signature:
- *
- *   Type f([const] Value [&]);
- *
- * Additionally, global_fun  and const_global_fun are overloaded to support
- * referece_wrappers of Value and "chained pointers" to Value's. By chained
- * pointer to T we  mean a type P such that, given a p of Type P
- *   *...n...*x is convertible to T&, for some n>=1.
- * Examples of chained pointers are raw and smart pointers, iterators and
- * arbitrary combinations of these (vg. T** or unique_ptr<T*>.)
- */
-
-template<class Value,typename Type,Type (*PtrToFunction)(Value)>
-struct const_ref_global_fun_base
-{
-  typedef typename remove_reference<Type>::type result_type;
-
-  template<typename ChainedPtr>
-
-#if !defined(BOOST_NO_SFINAE)
-  typename disable_if<
-    is_convertible<const ChainedPtr&,Value>,Type>::type
-#else
-  Type
-#endif
-
-  operator()(const ChainedPtr& x)const
-  {
-    return operator()(*x);
-  }
-
-  Type operator()(Value x)const
-  {
-    return PtrToFunction(x);
-  }
-
-  Type operator()(
-    const reference_wrapper<
-      typename remove_reference<Value>::type>& x)const
-  { 
-    return operator()(x.get());
-  }
-
-  Type operator()(
-    const reference_wrapper<
-      typename remove_const<
-        typename remove_reference<Value>::type>::type>& x
-
-#if BOOST_WORKAROUND(BOOST_MSVC,==1310)
-/* http://lists.boost.org/Archives/boost/2015/10/226135.php */
-    ,int=0
-#endif
-
-  )const
-  { 
-    return operator()(x.get());
-  }
-};
-
-template<class Value,typename Type,Type (*PtrToFunction)(Value)>
-struct non_const_ref_global_fun_base
-{
-  typedef typename remove_reference<Type>::type result_type;
-
-  template<typename ChainedPtr>
-
-#if !defined(BOOST_NO_SFINAE)
-  typename disable_if<
-    is_convertible<ChainedPtr&,Value>,Type>::type
-#else
-  Type
-#endif
-
-  operator()(const ChainedPtr& x)const
-  {
-    return operator()(*x);
-  }
-
-  Type operator()(Value x)const
-  {
-    return PtrToFunction(x);
-  }
-
-  Type operator()(
-    const reference_wrapper<
-      typename remove_reference<Value>::type>& x)const
-  { 
-    return operator()(x.get());
-  }
-};
-
-template<class Value,typename Type,Type (*PtrToFunction)(Value)>
-struct non_ref_global_fun_base
-{
-  typedef typename remove_reference<Type>::type result_type;
-
-  template<typename ChainedPtr>
-
-#if !defined(BOOST_NO_SFINAE)
-  typename disable_if<
-    is_convertible<const ChainedPtr&,const Value&>,Type>::type
-#else
-  Type
-#endif
-
-  operator()(const ChainedPtr& x)const
-  {
-    return operator()(*x);
-  }
-
-  Type operator()(const Value& x)const
-  {
-    return PtrToFunction(x);
-  }
-
-  Type operator()(const reference_wrapper<const Value>& x)const
-  { 
-    return operator()(x.get());
-  }
-
-  Type operator()(
-    const reference_wrapper<typename remove_const<Value>::type>& x)const
-  { 
-    return operator()(x.get());
-  }
-};
-
-} /* namespace multi_index::detail */
-
-template<class Value,typename Type,Type (*PtrToFunction)(Value)>
-struct global_fun:
-  mpl::if_c<
-    is_reference<Value>::value,
-    typename mpl::if_c<
-      is_const<typename remove_reference<Value>::type>::value,
-      detail::const_ref_global_fun_base<Value,Type,PtrToFunction>,
-      detail::non_const_ref_global_fun_base<Value,Type,PtrToFunction>
-    >::type,
-    detail::non_ref_global_fun_base<Value,Type,PtrToFunction>
-  >::type
-{
-};
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/hashed_index.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/hashed_index.hpp
deleted file mode 100644
index 352d0c13f17..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/hashed_index.hpp
+++ /dev/null
@@ -1,1725 +0,0 @@
-/* Copyright 2003-2015 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_HASHED_INDEX_HPP
-#define BOOST_MULTI_INDEX_HASHED_INDEX_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <algorithm>
-#include <boost/call_traits.hpp>
-#include <boost/detail/allocator_utilities.hpp>
-#include <boost/detail/no_exceptions_support.hpp>
-#include <boost/detail/workaround.hpp>
-#include <boost/foreach_fwd.hpp>
-#include <boost/limits.hpp>
-#include <boost/move/core.hpp>
-#include <boost/mpl/bool.hpp>
-#include <boost/mpl/if.hpp>
-#include <boost/mpl/push_front.hpp>
-#include <boost/multi_index/detail/access_specifier.hpp>
-#include <boost/multi_index/detail/auto_space.hpp>
-#include <boost/multi_index/detail/bucket_array.hpp>
-#include <boost/multi_index/detail/do_not_copy_elements_tag.hpp>
-#include <boost/multi_index/detail/hash_index_iterator.hpp>
-#include <boost/multi_index/detail/index_node_base.hpp>
-#include <boost/multi_index/detail/modify_key_adaptor.hpp>
-#include <boost/multi_index/detail/promotes_arg.hpp>
-#include <boost/multi_index/detail/safe_mode.hpp>
-#include <boost/multi_index/detail/scope_guard.hpp>
-#include <boost/multi_index/detail/vartempl_support.hpp>
-#include <boost/multi_index/hashed_index_fwd.hpp>
-#include <boost/tuple/tuple.hpp>
-#include <boost/type_traits/is_same.hpp>
-#include <cmath>
-#include <cstddef>
-#include <functional>
-#include <iterator>
-#include <utility>
-
-#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
-#include <initializer_list>
-#endif
-
-#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
-#include <boost/serialization/nvp.hpp>
-#endif
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING)
-#define BOOST_MULTI_INDEX_HASHED_INDEX_CHECK_INVARIANT_OF(x)                 \
-  detail::scope_guard BOOST_JOIN(check_invariant_,__LINE__)=                 \
-    detail::make_obj_guard(x,&hashed_index::check_invariant_);               \
-  BOOST_JOIN(check_invariant_,__LINE__).touch();
-#define BOOST_MULTI_INDEX_HASHED_INDEX_CHECK_INVARIANT                       \
-  BOOST_MULTI_INDEX_HASHED_INDEX_CHECK_INVARIANT_OF(*this)
-#else
-#define BOOST_MULTI_INDEX_HASHED_INDEX_CHECK_INVARIANT_OF(x)
-#define BOOST_MULTI_INDEX_HASHED_INDEX_CHECK_INVARIANT
-#endif
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-/* hashed_index adds a layer of hashed indexing to a given Super */
-
-/* Most of the implementation of unique and non-unique indices is
- * shared. We tell from one another on instantiation time by using
- * Category tags defined in hash_index_node.hpp.
- */
-
-template<
-  typename KeyFromValue,typename Hash,typename Pred,
-  typename SuperMeta,typename TagList,typename Category
->
-class hashed_index:
-  BOOST_MULTI_INDEX_PROTECTED_IF_MEMBER_TEMPLATE_FRIENDS SuperMeta::type
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-  ,public safe_mode::safe_container<
-    hashed_index<KeyFromValue,Hash,Pred,SuperMeta,TagList,Category> >
-#endif
-
-{ 
-#if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING)&&\
-    BOOST_WORKAROUND(__MWERKS__,<=0x3003)
-/* The "ISO C++ Template Parser" option in CW8.3 has a problem with the
- * lifetime of const references bound to temporaries --precisely what
- * scopeguards are.
- */
-
-#pragma parse_mfunc_templ off
-#endif
-
-  typedef typename SuperMeta::type                   super;
-
-protected:
-  typedef hashed_index_node<
-    typename super::node_type,Category>              node_type;
-
-private:
-  typedef typename node_type::node_alg               node_alg;
-  typedef typename node_type::impl_type              node_impl_type;
-  typedef typename node_impl_type::pointer           node_impl_pointer;
-  typedef typename node_impl_type::base_pointer      node_impl_base_pointer;
-  typedef bucket_array<
-    typename super::final_allocator_type>            bucket_array_type;
-
-public:
-  /* types */
-
-  typedef typename KeyFromValue::result_type         key_type;
-  typedef typename node_type::value_type             value_type;
-  typedef KeyFromValue                               key_from_value;
-  typedef Hash                                       hasher;
-  typedef Pred                                       key_equal;
-  typedef tuple<std::size_t,
-    key_from_value,hasher,key_equal>                 ctor_args;
-  typedef typename super::final_allocator_type       allocator_type;
-  typedef typename allocator_type::pointer           pointer;
-  typedef typename allocator_type::const_pointer     const_pointer;
-  typedef typename allocator_type::reference         reference;
-  typedef typename allocator_type::const_reference   const_reference;
-  typedef std::size_t                                size_type;      
-  typedef std::ptrdiff_t                             difference_type;
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-  typedef safe_mode::safe_iterator<
-    hashed_index_iterator<
-      node_type,bucket_array_type,
-      hashed_index_global_iterator_tag>,
-    hashed_index>                                    iterator;
-#else
-  typedef hashed_index_iterator<
-    node_type,bucket_array_type,
-    hashed_index_global_iterator_tag>                iterator;
-#endif
-
-  typedef iterator                                   const_iterator;
-
-  typedef hashed_index_iterator<
-    node_type,bucket_array_type,
-    hashed_index_local_iterator_tag>                 local_iterator;
-  typedef local_iterator                             const_local_iterator;
-
-  typedef TagList                                    tag_list;
-
-protected:
-  typedef typename super::final_node_type     final_node_type;
-  typedef tuples::cons<
-    ctor_args, 
-    typename super::ctor_args_list>           ctor_args_list;
-  typedef typename mpl::push_front<
-    typename super::index_type_list,
-    hashed_index>::type                       index_type_list;
-  typedef typename mpl::push_front<
-    typename super::iterator_type_list,
-    iterator>::type                           iterator_type_list;
-  typedef typename mpl::push_front<
-    typename super::const_iterator_type_list,
-    const_iterator>::type                     const_iterator_type_list;
-  typedef typename super::copy_map_type       copy_map_type;
-
-#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
-  typedef typename super::index_saver_type    index_saver_type;
-  typedef typename super::index_loader_type   index_loader_type;
-#endif
-
-private:
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-  typedef safe_mode::safe_container<
-    hashed_index>                             safe_super;
-#endif
-
-  typedef typename call_traits<value_type>::param_type value_param_type;
-  typedef typename call_traits<
-    key_type>::param_type                              key_param_type;
-
-  /* Needed to avoid commas in BOOST_MULTI_INDEX_OVERLOADS_TO_VARTEMPL
-   * expansion.
-   */
-
-  typedef std::pair<iterator,bool>                     emplace_return_type;
-
-public:
-
-  /* construct/destroy/copy
-   * Default and copy ctors are in the protected section as indices are
-   * not supposed to be created on their own. No range ctor either.
-   */
-
-  hashed_index<KeyFromValue,Hash,Pred,SuperMeta,TagList,Category>& operator=(
-    const hashed_index<KeyFromValue,Hash,Pred,SuperMeta,TagList,Category>& x)
-  {
-    this->final()=x.final();
-    return *this;
-  }
-
-#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
-  hashed_index<KeyFromValue,Hash,Pred,SuperMeta,TagList,Category>& operator=(
-    std::initializer_list<value_type> list)
-  {
-    this->final()=list;
-    return *this;
-  }
-#endif
-
-  allocator_type get_allocator()const BOOST_NOEXCEPT
-  {
-    return this->final().get_allocator();
-  }
-
-  /* size and capacity */
-
-  bool      empty()const BOOST_NOEXCEPT{return this->final_empty_();}
-  size_type size()const BOOST_NOEXCEPT{return this->final_size_();}
-  size_type max_size()const BOOST_NOEXCEPT{return this->final_max_size_();}
-
-  /* iterators */
-
-  iterator begin()BOOST_NOEXCEPT
-    {return make_iterator(node_type::from_impl(header()->next()->prior()));}
-  const_iterator begin()const BOOST_NOEXCEPT
-    {return make_iterator(node_type::from_impl(header()->next()->prior()));}
-  iterator       end()BOOST_NOEXCEPT{return make_iterator(header());}
-  const_iterator end()const BOOST_NOEXCEPT{return make_iterator(header());}
-  const_iterator cbegin()const BOOST_NOEXCEPT{return begin();}
-  const_iterator cend()const BOOST_NOEXCEPT{return end();}
-
-  iterator iterator_to(const value_type& x)
-  {
-    return make_iterator(node_from_value<node_type>(&x));
-  }
-
-  const_iterator iterator_to(const value_type& x)const
-  {
-    return make_iterator(node_from_value<node_type>(&x));
-  }
-
-  /* modifiers */
-
-  BOOST_MULTI_INDEX_OVERLOADS_TO_VARTEMPL(
-    emplace_return_type,emplace,emplace_impl)
-
-  BOOST_MULTI_INDEX_OVERLOADS_TO_VARTEMPL_EXTRA_ARG(
-    iterator,emplace_hint,emplace_hint_impl,iterator,position)
-
-  std::pair<iterator,bool> insert(const value_type& x)
-  {
-    BOOST_MULTI_INDEX_HASHED_INDEX_CHECK_INVARIANT;
-    std::pair<final_node_type*,bool> p=this->final_insert_(x);
-    return std::pair<iterator,bool>(make_iterator(p.first),p.second);
-  }
-
-  std::pair<iterator,bool> insert(BOOST_RV_REF(value_type) x)
-  {
-    BOOST_MULTI_INDEX_HASHED_INDEX_CHECK_INVARIANT;
-    std::pair<final_node_type*,bool> p=this->final_insert_rv_(x);
-    return std::pair<iterator,bool>(make_iterator(p.first),p.second);
-  }
-
-  iterator insert(iterator position,const value_type& x)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
-    BOOST_MULTI_INDEX_HASHED_INDEX_CHECK_INVARIANT;
-    std::pair<final_node_type*,bool> p=this->final_insert_(
-      x,static_cast<final_node_type*>(position.get_node()));
-    return make_iterator(p.first);
-  }
-    
-  iterator insert(iterator position,BOOST_RV_REF(value_type) x)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
-    BOOST_MULTI_INDEX_HASHED_INDEX_CHECK_INVARIANT;
-    std::pair<final_node_type*,bool> p=this->final_insert_rv_(
-      x,static_cast<final_node_type*>(position.get_node()));
-    return make_iterator(p.first);
-  }
-
-  template<typename InputIterator>
-  void insert(InputIterator first,InputIterator last)
-  {
-    BOOST_MULTI_INDEX_HASHED_INDEX_CHECK_INVARIANT;
-    for(;first!=last;++first)this->final_insert_ref_(*first);
-  }
-
-#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
-  void insert(std::initializer_list<value_type> list)
-  {
-    insert(list.begin(),list.end());
-  }
-#endif
-
-  iterator erase(iterator position)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
-    BOOST_MULTI_INDEX_HASHED_INDEX_CHECK_INVARIANT;
-    this->final_erase_(static_cast<final_node_type*>(position++.get_node()));
-    return position;
-  }
-
-  size_type erase(key_param_type k)
-  {
-    BOOST_MULTI_INDEX_HASHED_INDEX_CHECK_INVARIANT;
-
-    std::size_t buc=buckets.position(hash_(k));
-    for(node_impl_pointer x=buckets.at(buc)->prior();
-        x!=node_impl_pointer(0);x=node_alg::next_to_inspect(x)){
-      if(eq_(k,key(node_type::from_impl(x)->value()))){
-        node_impl_pointer y=end_of_range(x);
-        size_type         s=0;
-        do{
-          node_impl_pointer z=node_alg::after(x);
-          this->final_erase_(
-            static_cast<final_node_type*>(node_type::from_impl(x)));
-          x=z;
-          ++s;
-        }while(x!=y);
-        return s;
-      }
-    }
-    return 0;
-  }
-
-  iterator erase(iterator first,iterator last)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(first);
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(last);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(first,*this);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(last,*this);
-    BOOST_MULTI_INDEX_CHECK_VALID_RANGE(first,last);
-    BOOST_MULTI_INDEX_HASHED_INDEX_CHECK_INVARIANT;
-    while(first!=last){
-      first=erase(first);
-    }
-    return first;
-  }
-
-  bool replace(iterator position,const value_type& x)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
-    BOOST_MULTI_INDEX_HASHED_INDEX_CHECK_INVARIANT;
-    return this->final_replace_(
-      x,static_cast<final_node_type*>(position.get_node()));
-  }
-
-  bool replace(iterator position,BOOST_RV_REF(value_type) x)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
-    BOOST_MULTI_INDEX_HASHED_INDEX_CHECK_INVARIANT;
-    return this->final_replace_rv_(
-      x,static_cast<final_node_type*>(position.get_node()));
-  }
-
-  template<typename Modifier>
-  bool modify(iterator position,Modifier mod)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
-    BOOST_MULTI_INDEX_HASHED_INDEX_CHECK_INVARIANT;
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-    /* MSVC++ 6.0 optimizer on safe mode code chokes if this
-     * this is not added. Left it for all compilers as it does no
-     * harm.
-     */
-
-    position.detach();
-#endif
-
-    return this->final_modify_(
-      mod,static_cast<final_node_type*>(position.get_node()));
-  }
-
-  template<typename Modifier,typename Rollback>
-  bool modify(iterator position,Modifier mod,Rollback back_)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
-    BOOST_MULTI_INDEX_HASHED_INDEX_CHECK_INVARIANT;
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-    /* MSVC++ 6.0 optimizer on safe mode code chokes if this
-     * this is not added. Left it for all compilers as it does no
-     * harm.
-     */
-
-    position.detach();
-#endif
-
-    return this->final_modify_(
-      mod,back_,static_cast<final_node_type*>(position.get_node()));
-  }
-
-  template<typename Modifier>
-  bool modify_key(iterator position,Modifier mod)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
-    BOOST_MULTI_INDEX_HASHED_INDEX_CHECK_INVARIANT;
-    return modify(
-      position,modify_key_adaptor<Modifier,value_type,KeyFromValue>(mod,key));
-  }
-
-  template<typename Modifier,typename Rollback>
-  bool modify_key(iterator position,Modifier mod,Rollback back_)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
-    BOOST_MULTI_INDEX_HASHED_INDEX_CHECK_INVARIANT;
-    return modify(
-      position,
-      modify_key_adaptor<Modifier,value_type,KeyFromValue>(mod,key),
-      modify_key_adaptor<Rollback,value_type,KeyFromValue>(back_,key));
-  }
-
-  void clear()BOOST_NOEXCEPT
-  {
-    BOOST_MULTI_INDEX_HASHED_INDEX_CHECK_INVARIANT;
-    this->final_clear_();
-  }
-
-  void swap(hashed_index<KeyFromValue,Hash,Pred,SuperMeta,TagList,Category>& x)
-  {
-    BOOST_MULTI_INDEX_HASHED_INDEX_CHECK_INVARIANT;
-    BOOST_MULTI_INDEX_HASHED_INDEX_CHECK_INVARIANT_OF(x);
-    this->final_swap_(x.final());
-  }
-
-  /* observers */
-
-  key_from_value key_extractor()const{return key;}
-  hasher         hash_function()const{return hash_;}
-  key_equal      key_eq()const{return eq_;}
-  
-  /* lookup */
-
-  /* Internally, these ops rely on const_iterator being the same
-   * type as iterator.
-   */
-
-  /* Implementation note: When CompatibleKey is consistently promoted to
-   * KeyFromValue::result_type for equality comparison, the promotion is made
-   * once in advance to increase efficiency.
-   */
-
-  template<typename CompatibleKey>
-  iterator find(const CompatibleKey& k)const
-  {
-    return find(k,hash_,eq_);
-  }
-
-  template<
-    typename CompatibleKey,typename CompatibleHash,typename CompatiblePred
-  >
-  iterator find(
-    const CompatibleKey& k,
-    const CompatibleHash& hash,const CompatiblePred& eq)const
-  {
-    return find(
-      k,hash,eq,promotes_1st_arg<CompatiblePred,CompatibleKey,key_type>());
-  }
-
-  template<typename CompatibleKey>
-  size_type count(const CompatibleKey& k)const
-  {
-    return count(k,hash_,eq_);
-  }
-
-  template<
-    typename CompatibleKey,typename CompatibleHash,typename CompatiblePred
-  >
-  size_type count(
-    const CompatibleKey& k,
-    const CompatibleHash& hash,const CompatiblePred& eq)const
-  {
-    return count(
-      k,hash,eq,promotes_1st_arg<CompatiblePred,CompatibleKey,key_type>());
-  }
-
-  template<typename CompatibleKey>
-  std::pair<iterator,iterator> equal_range(const CompatibleKey& k)const
-  {
-    return equal_range(k,hash_,eq_);
-  }
-
-  template<
-    typename CompatibleKey,typename CompatibleHash,typename CompatiblePred
-  >
-  std::pair<iterator,iterator> equal_range(
-    const CompatibleKey& k,
-    const CompatibleHash& hash,const CompatiblePred& eq)const
-  {
-    return equal_range(
-      k,hash,eq,promotes_1st_arg<CompatiblePred,CompatibleKey,key_type>());
-  }
-
-  /* bucket interface */
-
-  size_type bucket_count()const BOOST_NOEXCEPT{return buckets.size();}
-  size_type max_bucket_count()const BOOST_NOEXCEPT{return static_cast<size_type>(-1);}
-
-  size_type bucket_size(size_type n)const
-  {
-    size_type res=0;
-    for(node_impl_pointer x=buckets.at(n)->prior();
-        x!=node_impl_pointer(0);x=node_alg::after_local(x)){
-      ++res;
-    }
-    return res;
-  }
-
-  size_type bucket(key_param_type k)const
-  {
-    return buckets.position(hash_(k));
-  }
-
-  local_iterator begin(size_type n)
-  {
-    return const_cast<const hashed_index*>(this)->begin(n);
-  }
-
-  const_local_iterator begin(size_type n)const
-  {
-    node_impl_pointer x=buckets.at(n)->prior();
-    if(x==node_impl_pointer(0))return end(n);
-    return make_local_iterator(node_type::from_impl(x));
-  }
-
-  local_iterator end(size_type n)
-  {
-    return const_cast<const hashed_index*>(this)->end(n);
-  }
-
-  const_local_iterator end(size_type)const
-  {
-    return make_local_iterator(0);
-  }
-
-  const_local_iterator cbegin(size_type n)const{return begin(n);}
-  const_local_iterator cend(size_type n)const{return end(n);}
-
-  local_iterator local_iterator_to(const value_type& x)
-  {
-    return make_local_iterator(node_from_value<node_type>(&x));
-  }
-
-  const_local_iterator local_iterator_to(const value_type& x)const
-  {
-    return make_local_iterator(node_from_value<node_type>(&x));
-  }
-
-  /* hash policy */
-
-  float load_factor()const BOOST_NOEXCEPT
-    {return static_cast<float>(size())/bucket_count();}
-  float max_load_factor()const BOOST_NOEXCEPT{return mlf;}
-  void  max_load_factor(float z){mlf=z;calculate_max_load();}
-
-  void rehash(size_type n)
-  {
-    BOOST_MULTI_INDEX_HASHED_INDEX_CHECK_INVARIANT;
-    if(size()<=max_load&&n<=bucket_count())return;
-
-    size_type bc =(std::numeric_limits<size_type>::max)();
-    float     fbc=static_cast<float>(1+size()/mlf);
-    if(bc>fbc){
-      bc=static_cast<size_type>(fbc);
-      if(bc<n)bc=n;
-    }
-    unchecked_rehash(bc);
-  }
-
-  void reserve(size_type n)
-  {
-    rehash(static_cast<size_type>(std::ceil(static_cast<double>(n)/mlf)));
-  }
-
-BOOST_MULTI_INDEX_PROTECTED_IF_MEMBER_TEMPLATE_FRIENDS:
-  hashed_index(const ctor_args_list& args_list,const allocator_type& al):
-    super(args_list.get_tail(),al),
-    key(tuples::get<1>(args_list.get_head())),
-    hash_(tuples::get<2>(args_list.get_head())),
-    eq_(tuples::get<3>(args_list.get_head())),
-    buckets(al,header()->impl(),tuples::get<0>(args_list.get_head())),
-    mlf(1.0f)
-  {
-    calculate_max_load();
-  }
-
-  hashed_index(
-    const hashed_index<KeyFromValue,Hash,Pred,SuperMeta,TagList,Category>& x):
-    super(x),
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-    safe_super(),
-#endif
-
-    key(x.key),
-    hash_(x.hash_),
-    eq_(x.eq_),
-    buckets(x.get_allocator(),header()->impl(),x.buckets.size()),
-    mlf(x.mlf),
-    max_load(x.max_load)
-  {
-    /* Copy ctor just takes the internal configuration objects from x. The rest
-     * is done in subsequent call to copy_().
-     */
-  }
-
-  hashed_index(
-    const hashed_index<KeyFromValue,Hash,Pred,SuperMeta,TagList,Category>& x,
-    do_not_copy_elements_tag):
-    super(x,do_not_copy_elements_tag()),
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-    safe_super(),
-#endif
-
-    key(x.key),
-    hash_(x.hash_),
-    eq_(x.eq_),
-    buckets(x.get_allocator(),header()->impl(),0),
-    mlf(1.0f)
-  {
-     calculate_max_load();
-  }
-
-  ~hashed_index()
-  {
-    /* the container is guaranteed to be empty by now */
-  }
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-  iterator make_iterator(node_type* node)
-  {
-    return iterator(node,this);
-  }
-
-  const_iterator make_iterator(node_type* node)const
-  {
-    return const_iterator(node,const_cast<hashed_index*>(this));
-  }
-#else
-  iterator make_iterator(node_type* node)
-  {
-    return iterator(node);
-  }
-
-  const_iterator make_iterator(node_type* node)const
-  {
-    return const_iterator(node);
-  }
-#endif
-
-  local_iterator make_local_iterator(node_type* node)
-  {
-    return local_iterator(node);
-  }
-
-  const_local_iterator make_local_iterator(node_type* node)const
-  {
-    return const_local_iterator(node);
-  }
-
-  void copy_(
-    const hashed_index<KeyFromValue,Hash,Pred,SuperMeta,TagList,Category>& x,
-    const copy_map_type& map)
-  {
-    copy_(x,map,Category());
-  }
-
-  void copy_(
-    const hashed_index<KeyFromValue,Hash,Pred,SuperMeta,TagList,Category>& x,
-    const copy_map_type& map,hashed_unique_tag)
-  {
-    if(x.size()!=0){
-      node_impl_pointer end_org=x.header()->impl(),
-                        org=end_org,
-                        cpy=header()->impl();
-      do{
-        node_impl_pointer prev_org=org->prior(),
-                          prev_cpy=
-          static_cast<node_type*>(map.find(static_cast<final_node_type*>(
-            node_type::from_impl(prev_org))))->impl();
-        cpy->prior()=prev_cpy;
-        if(node_alg::is_first_of_bucket(org)){
-          node_impl_base_pointer buc_org=prev_org->next(),
-                                 buc_cpy=
-            buckets.begin()+(buc_org-x.buckets.begin());
-          prev_cpy->next()=buc_cpy;
-          buc_cpy->prior()=cpy;
-        }
-        else{
-          prev_cpy->next()=node_impl_type::base_pointer_from(cpy);
-        }
-        org=prev_org;
-        cpy=prev_cpy;
-      }while(org!=end_org);
-    }
-
-    super::copy_(x,map);
-  }
-  
-  void copy_(
-    const hashed_index<KeyFromValue,Hash,Pred,SuperMeta,TagList,Category>& x,
-    const copy_map_type& map,hashed_non_unique_tag)
-  {
-    if(x.size()!=0){
-      node_impl_pointer end_org=x.header()->impl(),
-                        org=end_org,
-                        cpy=header()->impl();
-      do{
-        node_impl_pointer next_org=node_alg::after(org),
-                          next_cpy=
-          static_cast<node_type*>(map.find(static_cast<final_node_type*>(
-            node_type::from_impl(next_org))))->impl();
-        if(node_alg::is_first_of_bucket(next_org)){
-          node_impl_base_pointer buc_org=org->next(),
-                                 buc_cpy=
-            buckets.begin()+(buc_org-x.buckets.begin());
-          cpy->next()=buc_cpy;
-          buc_cpy->prior()=next_cpy;
-          next_cpy->prior()=cpy;
-        }
-        else{
-          if(org->next()==node_impl_type::base_pointer_from(next_org)){
-            cpy->next()=node_impl_type::base_pointer_from(next_cpy);
-          }
-          else{
-            cpy->next()=
-              node_impl_type::base_pointer_from(
-                static_cast<node_type*>(map.find(static_cast<final_node_type*>(
-                  node_type::from_impl(
-                    node_impl_type::pointer_from(org->next())))))->impl());
-          }
-
-          if(next_org->prior()!=org){
-            next_cpy->prior()=
-              static_cast<node_type*>(map.find(static_cast<final_node_type*>(
-                node_type::from_impl(next_org->prior()))))->impl();
-          }
-          else{
-            next_cpy->prior()=cpy;
-          }
-        }
-        org=next_org;
-        cpy=next_cpy;
-      }while(org!=end_org);
-    }
-
-    super::copy_(x,map);
-  }
-
-  template<typename Variant>
-  final_node_type* insert_(
-    value_param_type v,final_node_type*& x,Variant variant)
-  {
-    reserve_for_insert(size()+1);
-
-    std::size_t buc=find_bucket(v);
-    link_info   pos(buckets.at(buc));
-    if(!link_point(v,pos)){
-      return static_cast<final_node_type*>(
-        node_type::from_impl(node_impl_type::pointer_from(pos)));
-    }
-
-    final_node_type* res=super::insert_(v,x,variant);
-    if(res==x)link(static_cast<node_type*>(x),pos);
-    return res;
-  }
-
-  template<typename Variant>
-  final_node_type* insert_(
-    value_param_type v,node_type* position,final_node_type*& x,Variant variant)
-  {
-    reserve_for_insert(size()+1);
-
-    std::size_t buc=find_bucket(v);
-    link_info   pos(buckets.at(buc));
-    if(!link_point(v,pos)){
-      return static_cast<final_node_type*>(
-        node_type::from_impl(node_impl_type::pointer_from(pos)));
-    }
-
-    final_node_type* res=super::insert_(v,position,x,variant);
-    if(res==x)link(static_cast<node_type*>(x),pos);
-    return res;
-  }
-
-  void erase_(node_type* x)
-  {
-    unlink(x);
-    super::erase_(x);
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-    detach_iterators(x);
-#endif
-  }
-
-  void delete_all_nodes_()
-  {
-    delete_all_nodes_(Category());
-  }
-
-  void delete_all_nodes_(hashed_unique_tag)
-  {
-    for(node_impl_pointer x_end=header()->impl(),x=x_end->prior();x!=x_end;){
-      node_impl_pointer y=x->prior();
-      this->final_delete_node_(
-        static_cast<final_node_type*>(node_type::from_impl(x)));
-      x=y;
-    }
-  }
-
-  void delete_all_nodes_(hashed_non_unique_tag)
-  {
-    for(node_impl_pointer x_end=header()->impl(),x=x_end->prior();x!=x_end;){
-      node_impl_pointer y=x->prior();
-      if(y->next()!=node_impl_type::base_pointer_from(x)&&
-         y->next()->prior()!=x){ /* n-1 of group */
-        /* Make the second node prior() pointer back-linked so that it won't
-         * refer to a deleted node when the time for its own destruction comes.
-         */
-
-        node_impl_pointer first=node_impl_type::pointer_from(y->next());
-        first->next()->prior()=first;
-      }
-      this->final_delete_node_(
-        static_cast<final_node_type*>(node_type::from_impl(x)));
-      x=y;
-    }
-  }
-
-  void clear_()
-  {
-    super::clear_();
-    buckets.clear(header()->impl());
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-    safe_super::detach_dereferenceable_iterators();
-#endif
-  }
-
-  void swap_(
-    hashed_index<KeyFromValue,Hash,Pred,SuperMeta,TagList,Category>& x)
-  {
-    std::swap(key,x.key);
-    std::swap(hash_,x.hash_);
-    std::swap(eq_,x.eq_);
-    buckets.swap(x.buckets);
-    std::swap(mlf,x.mlf);
-    std::swap(max_load,x.max_load);
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-    safe_super::swap(x);
-#endif
-
-    super::swap_(x);
-  }
-
-  void swap_elements_(
-    hashed_index<KeyFromValue,Hash,Pred,SuperMeta,TagList,Category>& x)
-  {
-    buckets.swap(x.buckets);
-    std::swap(mlf,x.mlf);
-    std::swap(max_load,x.max_load);
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-    safe_super::swap(x);
-#endif
-
-    super::swap_elements_(x);
-  }
-
-  template<typename Variant>
-  bool replace_(value_param_type v,node_type* x,Variant variant)
-  {
-    if(eq_(key(v),key(x->value()))){
-      return super::replace_(v,x,variant);
-    }
-      
-    unlink_undo undo;
-    unlink(x,undo);
-
-    BOOST_TRY{
-      std::size_t  buc=find_bucket(v);
-      link_info    pos(buckets.at(buc));
-      if(link_point(v,pos)&&super::replace_(v,x,variant)){
-        link(x,pos);
-        return true;
-      }
-      undo();
-      return false;
-    }
-    BOOST_CATCH(...){
-      undo();
-      BOOST_RETHROW;
-    }
-    BOOST_CATCH_END
-  }
-
-  bool modify_(node_type* x)
-  {
-    std::size_t buc;
-    bool        b; 
-    BOOST_TRY{
-      buc=find_bucket(x->value());
-      b=in_place(x->impl(),key(x->value()),buc);
-    }
-    BOOST_CATCH(...){
-      erase_(x);
-      BOOST_RETHROW;
-    }
-    BOOST_CATCH_END
-    if(!b){
-      unlink(x);
-      BOOST_TRY{
-        link_info pos(buckets.at(buc));
-        if(!link_point(x->value(),pos)){
-          super::erase_(x);
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-          detach_iterators(x);
-#endif
-          return false;
-        }
-        link(x,pos);
-      }
-      BOOST_CATCH(...){
-        super::erase_(x);
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-      detach_iterators(x);
-#endif
-
-        BOOST_RETHROW;
-      }
-      BOOST_CATCH_END
-    }
-
-    BOOST_TRY{
-      if(!super::modify_(x)){
-        unlink(x);
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-        detach_iterators(x);
-#endif
-        return false;
-      }
-      else return true;
-    }
-    BOOST_CATCH(...){
-      unlink(x);
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-      detach_iterators(x);
-#endif
-
-      BOOST_RETHROW;
-    }
-    BOOST_CATCH_END
-  }
-
-  bool modify_rollback_(node_type* x)
-  {
-    std::size_t buc=find_bucket(x->value());
-    if(in_place(x->impl(),key(x->value()),buc)){
-      return super::modify_rollback_(x);
-    }
-
-    unlink_undo undo;
-    unlink(x,undo);
-
-    BOOST_TRY{
-      link_info pos(buckets.at(buc));
-      if(link_point(x->value(),pos)&&super::modify_rollback_(x)){
-        link(x,pos);
-        return true;
-      }
-      undo();
-      return false;
-    }
-    BOOST_CATCH(...){
-      undo();
-      BOOST_RETHROW;
-    }
-    BOOST_CATCH_END
-  }
-
-  /* comparison */
-
-#if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
-  /* defect macro refers to class, not function, templates, but anyway */
-
-  template<typename K,typename H,typename P,typename S,typename T,typename C>
-  friend bool operator==(
-    const hashed_index<K,H,P,S,T,C>&,const hashed_index<K,H,P,S,T,C>& y);
-#endif
-
-  bool equals(const hashed_index& x)const{return equals(x,Category());}
-
-  bool equals(const hashed_index& x,hashed_unique_tag)const
-  {
-    if(size()!=x.size())return false;
-    for(const_iterator it=begin(),it_end=end(),it2_end=x.end();
-        it!=it_end;++it){
-      const_iterator it2=x.find(key(*it));
-      if(it2==it2_end||!(*it==*it2))return false;
-    }
-    return true;
-  }
-
-  bool equals(const hashed_index& x,hashed_non_unique_tag)const
-  {
-    if(size()!=x.size())return false;
-    for(const_iterator it=begin(),it_end=end();it!=it_end;){
-      const_iterator it2,it2_last;
-      boost::tie(it2,it2_last)=x.equal_range(key(*it));
-      if(it2==it2_last)return false;
-
-      const_iterator it_last=make_iterator(
-        node_type::from_impl(end_of_range(it.get_node()->impl())));
-      if(std::distance(it,it_last)!=std::distance(it2,it2_last))return false;
-
-      /* From is_permutation code in
-       * http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3068.pdf
-       */
-
-      for(;it!=it_last;++it,++it2){
-        if(!(*it==*it2))break;
-      }
-      if(it!=it_last){
-        for(const_iterator scan=it;scan!=it_last;++scan){
-          if(std::find(it,scan,*scan)!=scan)continue;
-          std::ptrdiff_t matches=std::count(it2,it2_last,*scan);
-          if(matches==0||matches!=std::count(scan,it_last,*scan))return false;
-        }
-        it=it_last;
-      }
-    }
-    return true;
-  }
-
-#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
-  /* serialization */
-
-  template<typename Archive>
-  void save_(
-    Archive& ar,const unsigned int version,const index_saver_type& sm)const
-  {
-    ar<<serialization::make_nvp("position",buckets);
-    super::save_(ar,version,sm);
-  }
-
-  template<typename Archive>
-  void load_(Archive& ar,const unsigned int version,const index_loader_type& lm)
-  {
-    ar>>serialization::make_nvp("position",buckets);
-    super::load_(ar,version,lm);
-  }
-#endif
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING)
-  /* invariant stuff */
-
-  bool invariant_()const
-  {
-    if(size()==0||begin()==end()){
-      if(size()!=0||begin()!=end())return false;
-    }
-    else{
-      size_type s0=0;
-      for(const_iterator it=begin(),it_end=end();it!=it_end;++it,++s0){}
-      if(s0!=size())return false;
-
-      size_type s1=0;
-      for(size_type buc=0;buc<bucket_count();++buc){
-        size_type ss1=0;
-        for(const_local_iterator it=begin(buc),it_end=end(buc);
-            it!=it_end;++it,++ss1){
-          if(find_bucket(*it)!=buc)return false;
-        }
-        if(ss1!=bucket_size(buc))return false;
-        s1+=ss1;
-      }
-      if(s1!=size())return false;
-    }
-
-    return super::invariant_();
-  }
-
-  /* This forwarding function eases things for the boost::mem_fn construct
-   * in BOOST_MULTI_INDEX_HASHED_INDEX_CHECK_INVARIANT. Actually,
-   * final_check_invariant is already an inherited member function of index.
-   */
-  void check_invariant_()const{this->final_check_invariant_();}
-#endif
-
-private:
-  node_type* header()const{return this->final_header();}
-
-  std::size_t find_bucket(value_param_type v)const
-  {
-    return bucket(key(v));
-  }
-
-  struct link_info_non_unique
-  {
-    link_info_non_unique(node_impl_base_pointer pos):
-      first(pos),last(node_impl_base_pointer(0)){}
-
-    operator const node_impl_base_pointer&()const{return this->first;}
-
-    node_impl_base_pointer first,last;
-  };
-
-  typedef typename mpl::if_<
-    is_same<Category,hashed_unique_tag>,
-    node_impl_base_pointer,
-    link_info_non_unique
-  >::type                                link_info;
-
-  bool link_point(value_param_type v,link_info& pos)
-  {
-    return link_point(v,pos,Category());
-  }
-
-  bool link_point(
-    value_param_type v,node_impl_base_pointer& pos,hashed_unique_tag)
-  {
-    for(node_impl_pointer x=pos->prior();x!=node_impl_pointer(0);
-        x=node_alg::after_local(x)){
-      if(eq_(key(v),key(node_type::from_impl(x)->value()))){
-        pos=node_impl_type::base_pointer_from(x);
-        return false;
-      }
-    }
-    return true;
-  }
-
-  bool link_point(
-    value_param_type v,link_info_non_unique& pos,hashed_non_unique_tag)
-  {
-    for(node_impl_pointer x=pos.first->prior();x!=node_impl_pointer(0);
-        x=node_alg::next_to_inspect(x)){
-      if(eq_(key(v),key(node_type::from_impl(x)->value()))){
-        pos.first=node_impl_type::base_pointer_from(x);
-        pos.last=node_impl_type::base_pointer_from(last_of_range(x));
-        return true;
-      }
-    }
-    return true;
-  }
-
-  node_impl_pointer last_of_range(node_impl_pointer x)const
-  {
-    return last_of_range(x,Category());
-  }
-
-  node_impl_pointer last_of_range(node_impl_pointer x,hashed_unique_tag)const
-  {
-    return x;
-  }
-
-  node_impl_pointer last_of_range(
-    node_impl_pointer x,hashed_non_unique_tag)const
-  {
-    node_impl_base_pointer y=x->next();
-    node_impl_pointer      z=y->prior();
-    if(z==x){                      /* range of size 1 or 2 */
-      node_impl_pointer yy=node_impl_type::pointer_from(y);
-      return
-        eq_(
-          key(node_type::from_impl(x)->value()),
-          key(node_type::from_impl(yy)->value()))?yy:x;
-    }
-    else if(z->prior()==x)               /* last of bucket */
-      return x;
-    else                                /* group of size>2 */        
-      return z;
-  }
-
-  node_impl_pointer end_of_range(node_impl_pointer x)const
-  {
-    return end_of_range(x,Category());
-  }
-
-  node_impl_pointer end_of_range(node_impl_pointer x,hashed_unique_tag)const
-  {
-    return node_alg::after(last_of_range(x));
-  }
-
-  node_impl_pointer end_of_range(
-    node_impl_pointer x,hashed_non_unique_tag)const
-  {
-    node_impl_base_pointer y=x->next();
-    node_impl_pointer      z=y->prior();
-    if(z==x){                      /* range of size 1 or 2 */
-      node_impl_pointer yy=node_impl_type::pointer_from(y);
-      if(!eq_(
-           key(node_type::from_impl(x)->value()),
-           key(node_type::from_impl(yy)->value())))yy=x;
-      return yy->next()->prior()==yy?
-               node_impl_type::pointer_from(yy->next()):
-               yy->next()->prior();
-    }
-    else if(z->prior()==x)               /* last of bucket */
-      return z;
-    else                                /* group of size>2 */        
-      return z->next()->prior()==z?
-               node_impl_type::pointer_from(z->next()):
-               z->next()->prior();
-  }
-
-  void link(node_type* x,const link_info& pos)
-  {
-    link(x,pos,Category());
-  }
-
-  void link(node_type* x,node_impl_base_pointer pos,hashed_unique_tag)
-  {
-    node_alg::link(x->impl(),pos,header()->impl());
-  }
-
-  void link(node_type* x,const link_info_non_unique& pos,hashed_non_unique_tag)
-  {
-    if(pos.last==node_impl_base_pointer(0)){
-      node_alg::link(x->impl(),pos.first,header()->impl());
-    }
-    else{
-      node_alg::link(
-        x->impl(),
-        node_impl_type::pointer_from(pos.first),
-        node_impl_type::pointer_from(pos.last));
-    }
-  }
-
-  void unlink(node_type* x)
-  {
-    node_alg::unlink(x->impl());
-  }
-
-  typedef typename node_alg::unlink_undo unlink_undo;
-
-  void unlink(node_type* x,unlink_undo& undo)
-  {
-    node_alg::unlink(x->impl(),undo);
-  }
-
-  void calculate_max_load()
-  {
-    float fml=static_cast<float>(mlf*static_cast<float>(bucket_count()));
-    max_load=(std::numeric_limits<size_type>::max)();
-    if(max_load>fml)max_load=static_cast<size_type>(fml);
-  }
-
-  void reserve_for_insert(size_type n)
-  {
-    if(n>max_load){
-      size_type bc =(std::numeric_limits<size_type>::max)();
-      float     fbc=static_cast<float>(1+static_cast<double>(n)/mlf);
-      if(bc>fbc)bc =static_cast<size_type>(fbc);
-      unchecked_rehash(bc);
-    }
-  }
-
-  void unchecked_rehash(size_type n){unchecked_rehash(n,Category());}
-
-  void unchecked_rehash(size_type n,hashed_unique_tag)
-  {
-    node_impl_type    cpy_end_node;
-    node_impl_pointer cpy_end=node_impl_pointer(&cpy_end_node),
-                      end_=header()->impl();
-    bucket_array_type buckets_cpy(get_allocator(),cpy_end,n);
-
-    if(size()!=0){
-      auto_space<
-        std::size_t,allocator_type>       hashes(get_allocator(),size());
-      auto_space<
-        node_impl_pointer,allocator_type> node_ptrs(get_allocator(),size());
-      std::size_t                         i=0,size_=size();
-      bool                                within_bucket=false;
-      BOOST_TRY{
-        for(;i!=size_;++i){
-          node_impl_pointer x=end_->prior();
-
-          /* only this can possibly throw */
-          std::size_t h=hash_(key(node_type::from_impl(x)->value()));
-
-          hashes.data()[i]=h;
-          node_ptrs.data()[i]=x;
-          within_bucket=!node_alg::unlink_last(end_);
-          node_alg::link(x,buckets_cpy.at(buckets_cpy.position(h)),cpy_end);
-        }
-      }
-      BOOST_CATCH(...){
-        if(i!=0){
-          std::size_t prev_buc=buckets.position(hashes.data()[i-1]);
-          if(!within_bucket)prev_buc=~prev_buc;
-
-          for(std::size_t j=i;j--;){
-            std::size_t       buc=buckets.position(hashes.data()[j]);
-            node_impl_pointer x=node_ptrs.data()[j];
-            if(buc==prev_buc)node_alg::append(x,end_);
-            else node_alg::link(x,buckets.at(buc),end_);
-            prev_buc=buc;
-          }
-        }
-        BOOST_RETHROW;
-      }
-      BOOST_CATCH_END
-    }
-
-    end_->prior()=cpy_end->prior()!=cpy_end?cpy_end->prior():end_;
-    end_->next()=cpy_end->next();
-    end_->prior()->next()->prior()=end_->next()->prior()->prior()=end_;
-    buckets.swap(buckets_cpy);
-    calculate_max_load();
-  }
-
-  void unchecked_rehash(size_type n,hashed_non_unique_tag)
-  {
-    node_impl_type    cpy_end_node;
-    node_impl_pointer cpy_end=node_impl_pointer(&cpy_end_node),
-                      end_=header()->impl();
-    bucket_array_type buckets_cpy(get_allocator(),cpy_end,n);
-
-    if(size()!=0){
-      auto_space<
-        std::size_t,allocator_type>       hashes(get_allocator(),size());
-      auto_space<
-        node_impl_pointer,allocator_type> node_ptrs(get_allocator(),size());
-      std::size_t                         i=0;
-      bool                                within_bucket=false;
-      BOOST_TRY{
-        for(;;++i){
-          node_impl_pointer x=end_->prior();
-          if(x==end_)break;
-
-          /* only this can possibly throw */
-          std::size_t h=hash_(key(node_type::from_impl(x)->value()));
-
-          hashes.data()[i]=h;
-          node_ptrs.data()[i]=x;
-          std::pair<node_impl_pointer,bool> p=
-            node_alg::unlink_last_group(end_);
-          node_alg::link_range(
-            p.first,x,buckets_cpy.at(buckets_cpy.position(h)),cpy_end);
-          within_bucket=!(p.second);
-        }
-      }
-      BOOST_CATCH(...){
-        if(i!=0){
-          std::size_t prev_buc=buckets.position(hashes.data()[i-1]);
-          if(!within_bucket)prev_buc=~prev_buc;
-
-          for(std::size_t j=i;j--;){
-            std::size_t       buc=buckets.position(hashes.data()[j]);
-            node_impl_pointer x=node_ptrs.data()[j],
-                              y=
-              x->prior()->next()!=node_impl_type::base_pointer_from(x)&&
-              x->prior()->next()->prior()!=x?
-                node_impl_type::pointer_from(x->prior()->next()):x;
-            node_alg::unlink_range(y,x);
-            if(buc==prev_buc)node_alg::append_range(y,x,end_);
-            else node_alg::link_range(y,x,buckets.at(buc),end_);
-            prev_buc=buc;
-          }
-        }
-        BOOST_RETHROW;
-      }
-      BOOST_CATCH_END
-    }
-
-    end_->prior()=cpy_end->prior()!=cpy_end?cpy_end->prior():end_;
-    end_->next()=cpy_end->next();
-    end_->prior()->next()->prior()=end_->next()->prior()->prior()=end_;
-    buckets.swap(buckets_cpy);
-    calculate_max_load();
-  }
-
-  bool in_place(node_impl_pointer x,key_param_type k,std::size_t buc)const
-  {
-    return in_place(x,k,buc,Category());
-  }
-
-  bool in_place(
-    node_impl_pointer x,key_param_type k,std::size_t buc,
-    hashed_unique_tag)const
-  {
-    bool found=false;
-    for(node_impl_pointer y=buckets.at(buc)->prior();
-        y!=node_impl_pointer(0);y=node_alg::after_local(y)){
-      if(y==x)found=true;
-      else if(eq_(k,key(node_type::from_impl(y)->value())))return false;
-    }
-    return found;
-  }
-
-  bool in_place(
-    node_impl_pointer x,key_param_type k,std::size_t buc,
-    hashed_non_unique_tag)const
-  {
-    bool found=false;
-    int  range_size=0;
-    for(node_impl_pointer y=buckets.at(buc)->prior();y!=node_impl_pointer(0);){
-      if(node_alg::is_first_of_group(y)){ /* group of 3 or more */
-        if(y==x){
-          /* in place <-> equal to some other member of the group */
-          return eq_(
-            k,
-            key(node_type::from_impl(
-              node_impl_type::pointer_from(y->next()))->value()));
-        }
-        else{
-          node_impl_pointer z=
-            node_alg::after_local(y->next()->prior()); /* end of range */
-          if(eq_(k,key(node_type::from_impl(y)->value()))){
-            if(found)return false; /* x lies outside */
-            do{
-              if(y==x)return true;
-              y=node_alg::after_local(y);
-            }while(y!=z);
-            return false; /* x not found */
-          }
-          else{
-            if(range_size==1&&!found)return false;
-            if(range_size==2)return found;
-            range_size=0;
-            y=z; /* skip range (and potentially x, too, which is fine) */
-          }
-        }
-      }
-      else{ /* group of 1 or 2 */
-        if(y==x){
-          if(range_size==1)return true;
-          range_size=1;
-          found=true;
-        }
-        else if(eq_(k,key(node_type::from_impl(y)->value()))){
-          if(range_size==0&&found)return false;
-          if(range_size==1&&!found)return false;
-          if(range_size==2)return false;
-          ++range_size;
-        }
-        else{
-          if(range_size==1&&!found)return false;
-          if(range_size==2)return found;
-          range_size=0;
-        }
-        y=node_alg::after_local(y);
-      }
-    }
-    return found;
-  }
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-  void detach_iterators(node_type* x)
-  {
-    iterator it=make_iterator(x);
-    safe_mode::detach_equivalent_iterators(it);
-  }
-#endif
-
-  template<BOOST_MULTI_INDEX_TEMPLATE_PARAM_PACK>
-  std::pair<iterator,bool> emplace_impl(BOOST_MULTI_INDEX_FUNCTION_PARAM_PACK)
-  {
-    BOOST_MULTI_INDEX_HASHED_INDEX_CHECK_INVARIANT;
-    std::pair<final_node_type*,bool>p=
-      this->final_emplace_(BOOST_MULTI_INDEX_FORWARD_PARAM_PACK);
-    return std::pair<iterator,bool>(make_iterator(p.first),p.second);
-  }
-
-  template<BOOST_MULTI_INDEX_TEMPLATE_PARAM_PACK>
-  iterator emplace_hint_impl(
-    iterator position,BOOST_MULTI_INDEX_FUNCTION_PARAM_PACK)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
-    BOOST_MULTI_INDEX_HASHED_INDEX_CHECK_INVARIANT;
-    std::pair<final_node_type*,bool>p=
-      this->final_emplace_hint_(
-        static_cast<final_node_type*>(position.get_node()),
-        BOOST_MULTI_INDEX_FORWARD_PARAM_PACK);
-    return make_iterator(p.first);
-  }
-
-  template<
-    typename CompatibleHash,typename CompatiblePred
-  >
-  iterator find(
-    const key_type& k,
-    const CompatibleHash& hash,const CompatiblePred& eq,mpl::true_)const
-  {
-    return find(k,hash,eq,mpl::false_());
-  }
-
-  template<
-    typename CompatibleKey,typename CompatibleHash,typename CompatiblePred
-  >
-  iterator find(
-    const CompatibleKey& k,
-    const CompatibleHash& hash,const CompatiblePred& eq,mpl::false_)const
-  {
-    std::size_t buc=buckets.position(hash(k));
-    for(node_impl_pointer x=buckets.at(buc)->prior();
-        x!=node_impl_pointer(0);x=node_alg::next_to_inspect(x)){
-      if(eq(k,key(node_type::from_impl(x)->value()))){
-        return make_iterator(node_type::from_impl(x));
-      }
-    }
-    return end();
-  }
-
-  template<
-    typename CompatibleHash,typename CompatiblePred
-  >
-  size_type count(
-    const key_type& k,
-    const CompatibleHash& hash,const CompatiblePred& eq,mpl::true_)const
-  {
-    return count(k,hash,eq,mpl::false_());
-  }
-
-  template<
-    typename CompatibleKey,typename CompatibleHash,typename CompatiblePred
-  >
-  size_type count(
-    const CompatibleKey& k,
-    const CompatibleHash& hash,const CompatiblePred& eq,mpl::false_)const
-  {
-    std::size_t buc=buckets.position(hash(k));
-    for(node_impl_pointer x=buckets.at(buc)->prior();
-        x!=node_impl_pointer(0);x=node_alg::next_to_inspect(x)){
-      if(eq(k,key(node_type::from_impl(x)->value()))){
-        size_type         res=0;
-        node_impl_pointer y=end_of_range(x);
-        do{
-          ++res;
-          x=node_alg::after(x);
-        }while(x!=y);
-        return res;
-      }
-    }
-    return 0;
-  }
-
-  template<
-    typename CompatibleHash,typename CompatiblePred
-  >
-  std::pair<iterator,iterator> equal_range(
-    const key_type& k,
-    const CompatibleHash& hash,const CompatiblePred& eq,mpl::true_)const
-  {
-    return equal_range(k,hash,eq,mpl::false_());
-  }
-
-  template<
-    typename CompatibleKey,typename CompatibleHash,typename CompatiblePred
-  >
-  std::pair<iterator,iterator> equal_range(
-    const CompatibleKey& k,
-    const CompatibleHash& hash,const CompatiblePred& eq,mpl::false_)const
-  {
-    std::size_t buc=buckets.position(hash(k));
-    for(node_impl_pointer x=buckets.at(buc)->prior();
-        x!=node_impl_pointer(0);x=node_alg::next_to_inspect(x)){
-      if(eq(k,key(node_type::from_impl(x)->value()))){
-        return std::pair<iterator,iterator>(
-          make_iterator(node_type::from_impl(x)),
-          make_iterator(node_type::from_impl(end_of_range(x))));
-      }
-    }
-    return std::pair<iterator,iterator>(end(),end());
-  }
-
-  key_from_value               key;
-  hasher                       hash_;
-  key_equal                    eq_;
-  bucket_array_type            buckets;
-  float                        mlf;
-  size_type                    max_load;
-      
-#if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING)&&\
-    BOOST_WORKAROUND(__MWERKS__,<=0x3003)
-#pragma parse_mfunc_templ reset
-#endif
-};
-
-/* comparison */
-
-template<
-  typename KeyFromValue,typename Hash,typename Pred,
-  typename SuperMeta,typename TagList,typename Category
->
-bool operator==(
-  const hashed_index<KeyFromValue,Hash,Pred,SuperMeta,TagList,Category>& x,
-  const hashed_index<KeyFromValue,Hash,Pred,SuperMeta,TagList,Category>& y)
-{
-  return x.equals(y);
-}
-
-template<
-  typename KeyFromValue,typename Hash,typename Pred,
-  typename SuperMeta,typename TagList,typename Category
->
-bool operator!=(
-  const hashed_index<KeyFromValue,Hash,Pred,SuperMeta,TagList,Category>& x,
-  const hashed_index<KeyFromValue,Hash,Pred,SuperMeta,TagList,Category>& y)
-{
-  return !(x==y);
-}
-
-/*  specialized algorithms */
-
-template<
-  typename KeyFromValue,typename Hash,typename Pred,
-  typename SuperMeta,typename TagList,typename Category
->
-void swap(
-  hashed_index<KeyFromValue,Hash,Pred,SuperMeta,TagList,Category>& x,
-  hashed_index<KeyFromValue,Hash,Pred,SuperMeta,TagList,Category>& y)
-{
-  x.swap(y);
-}
-
-} /* namespace multi_index::detail */
-
-/* hashed index specifiers */
-
-template<typename Arg1,typename Arg2,typename Arg3,typename Arg4>
-struct hashed_unique
-{
-  typedef typename detail::hashed_index_args<
-    Arg1,Arg2,Arg3,Arg4>                           index_args;
-  typedef typename index_args::tag_list_type::type tag_list_type;
-  typedef typename index_args::key_from_value_type key_from_value_type;
-  typedef typename index_args::hash_type           hash_type;
-  typedef typename index_args::pred_type           pred_type;
-
-  template<typename Super>
-  struct node_class
-  {
-    typedef detail::hashed_index_node<Super,detail::hashed_unique_tag> type;
-  };
-
-  template<typename SuperMeta>
-  struct index_class
-  {
-    typedef detail::hashed_index<
-      key_from_value_type,hash_type,pred_type,
-      SuperMeta,tag_list_type,detail::hashed_unique_tag> type;
-  };
-};
-
-template<typename Arg1,typename Arg2,typename Arg3,typename Arg4>
-struct hashed_non_unique
-{
-  typedef typename detail::hashed_index_args<
-    Arg1,Arg2,Arg3,Arg4>                           index_args;
-  typedef typename index_args::tag_list_type::type tag_list_type;
-  typedef typename index_args::key_from_value_type key_from_value_type;
-  typedef typename index_args::hash_type           hash_type;
-  typedef typename index_args::pred_type           pred_type;
-
-  template<typename Super>
-  struct node_class
-  {
-    typedef detail::hashed_index_node<
-      Super,detail::hashed_non_unique_tag> type;
-  };
-
-  template<typename SuperMeta>
-  struct index_class
-  {
-    typedef detail::hashed_index<
-      key_from_value_type,hash_type,pred_type,
-      SuperMeta,tag_list_type,detail::hashed_non_unique_tag> type;
-  };
-};
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-/* Boost.Foreach compatibility */
-
-template<
-  typename KeyFromValue,typename Hash,typename Pred,
-  typename SuperMeta,typename TagList,typename Category
->
-inline boost::mpl::true_* boost_foreach_is_noncopyable(
-  boost::multi_index::detail::hashed_index<
-    KeyFromValue,Hash,Pred,SuperMeta,TagList,Category>*&,
-  boost_foreach_argument_dependent_lookup_hack)
-{
-  return 0;
-}
-
-#undef BOOST_MULTI_INDEX_HASHED_INDEX_CHECK_INVARIANT
-#undef BOOST_MULTI_INDEX_HASHED_INDEX_CHECK_INVARIANT_OF
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/hashed_index_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/hashed_index_fwd.hpp
deleted file mode 100644
index d77e36c321b..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/hashed_index_fwd.hpp
+++ /dev/null
@@ -1,74 +0,0 @@
-/* Copyright 2003-2013 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_HASHED_INDEX_FWD_HPP
-#define BOOST_MULTI_INDEX_HASHED_INDEX_FWD_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/multi_index/detail/hash_index_args.hpp>
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-template<
-  typename KeyFromValue,typename Hash,typename Pred,
-  typename SuperMeta,typename TagList,typename Category
->
-class hashed_index;
-
-template<
-  typename KeyFromValue,typename Hash,typename Pred,
-  typename SuperMeta,typename TagList,typename Category
->
-bool operator==(
-  const hashed_index<KeyFromValue,Hash,Pred,SuperMeta,TagList,Category>& x,
-  const hashed_index<KeyFromValue,Hash,Pred,SuperMeta,TagList,Category>& y);
-
-template<
-  typename KeyFromValue,typename Hash,typename Pred,
-  typename SuperMeta,typename TagList,typename Category
->
-bool operator!=(
-  const hashed_index<KeyFromValue,Hash,Pred,SuperMeta,TagList,Category>& x,
-  const hashed_index<KeyFromValue,Hash,Pred,SuperMeta,TagList,Category>& y);
-
-template<
-  typename KeyFromValue,typename Hash,typename Pred,
-  typename SuperMeta,typename TagList,typename Category
->
-void swap(
-  hashed_index<KeyFromValue,Hash,Pred,SuperMeta,TagList,Category>& x,
-  hashed_index<KeyFromValue,Hash,Pred,SuperMeta,TagList,Category>& y);
-
-} /* namespace multi_index::detail */
-
-/* hashed_index specifiers */
-
-template<
-  typename Arg1,typename Arg2=mpl::na,
-  typename Arg3=mpl::na,typename Arg4=mpl::na
->
-struct hashed_unique;
-
-template<
-  typename Arg1,typename Arg2=mpl::na,
-  typename Arg3=mpl::na,typename Arg4=mpl::na
->
-struct hashed_non_unique;
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/identity.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/identity.hpp
deleted file mode 100644
index 6c832ce1562..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/identity.hpp
+++ /dev/null
@@ -1,145 +0,0 @@
-/* Copyright 2003-2015 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_IDENTITY_HPP
-#define BOOST_MULTI_INDEX_IDENTITY_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp>
-#include <boost/detail/workaround.hpp>
-#include <boost/mpl/if.hpp>
-#include <boost/multi_index/identity_fwd.hpp>
-#include <boost/type_traits/is_const.hpp>
-#include <boost/type_traits/remove_const.hpp>
-#include <boost/utility/enable_if.hpp>
-
-#if !defined(BOOST_NO_SFINAE)
-#include <boost/type_traits/is_convertible.hpp>
-#endif
-
-namespace boost{
-
-template<class Type> class reference_wrapper; /* fwd decl. */
-
-namespace multi_index{
-
-namespace detail{
-
-/* identity is a do-nothing key extractor that returns the [const] Type&
- * object passed.
- * Additionally, identity is overloaded to support referece_wrappers
- * of Type and "chained pointers" to Type's. By chained pointer to Type we
- * mean a  type  P such that, given a p of type P
- *   *...n...*x is convertible to Type&, for some n>=1.
- * Examples of chained pointers are raw and smart pointers, iterators and
- * arbitrary combinations of these (vg. Type** or unique_ptr<Type*>.)
- */
-
-template<typename Type>
-struct const_identity_base
-{
-  typedef Type result_type;
-
-  template<typename ChainedPtr>
-
-#if !defined(BOOST_NO_SFINAE)
-  typename disable_if<is_convertible<const ChainedPtr&,Type&>,Type&>::type
-#else
-  Type&
-#endif 
-  
-  operator()(const ChainedPtr& x)const
-  {
-    return operator()(*x);
-  }
-
-  Type& operator()(Type& x)const
-  {
-    return x;
-  }
-
-  Type& operator()(const reference_wrapper<Type>& x)const
-  { 
-    return x.get();
-  }
-
-  Type& operator()(
-    const reference_wrapper<typename remove_const<Type>::type>& x
-
-#if BOOST_WORKAROUND(BOOST_MSVC,==1310)
-/* http://lists.boost.org/Archives/boost/2015/10/226135.php */
-    ,int=0
-#endif
-
-  )const
-  { 
-    return x.get();
-  }
-};
-
-template<typename Type>
-struct non_const_identity_base
-{
-  typedef Type result_type;
-
-  /* templatized for pointer-like types */
-  
-  template<typename ChainedPtr>
-
-#if !defined(BOOST_NO_SFINAE)
-  typename disable_if<
-    is_convertible<const ChainedPtr&,const Type&>,Type&>::type
-#else
-  Type&
-#endif 
-    
-  operator()(const ChainedPtr& x)const
-  {
-    return operator()(*x);
-  }
-
-  const Type& operator()(const Type& x)const
-  {
-    return x;
-  }
-
-  Type& operator()(Type& x)const
-  {
-    return x;
-  }
-
-  const Type& operator()(const reference_wrapper<const Type>& x)const
-  { 
-    return x.get();
-  }
-
-  Type& operator()(const reference_wrapper<Type>& x)const
-  { 
-    return x.get();
-  }
-};
-
-} /* namespace multi_index::detail */
-
-template<class Type>
-struct identity:
-  mpl::if_c<
-    is_const<Type>::value,
-    detail::const_identity_base<Type>,detail::non_const_identity_base<Type>
-  >::type
-{
-};
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/identity_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/identity_fwd.hpp
deleted file mode 100644
index af6bd55ef5f..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/identity_fwd.hpp
+++ /dev/null
@@ -1,26 +0,0 @@
-/* Copyright 2003-2013 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_IDENTITY_FWD_HPP
-#define BOOST_MULTI_INDEX_IDENTITY_FWD_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-namespace boost{
-
-namespace multi_index{
-
-template<class Type> struct identity;
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/indexed_by.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/indexed_by.hpp
deleted file mode 100644
index d2217e39166..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/indexed_by.hpp
+++ /dev/null
@@ -1,68 +0,0 @@
-/* Copyright 2003-2013 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_INDEXED_BY_HPP
-#define BOOST_MULTI_INDEX_INDEXED_BY_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <boost/mpl/vector.hpp>
-#include <boost/preprocessor/cat.hpp>
-#include <boost/preprocessor/control/expr_if.hpp>
-#include <boost/preprocessor/repetition/enum.hpp>
-#include <boost/preprocessor/repetition/enum_params.hpp> 
-
-/* An alias to mpl::vector used to hide MPL from the user.
- * indexed_by contains the index specifiers for instantiation
- * of a multi_index_container.
- */
-
-/* This user_definable macro limits the number of elements of an index list;
- * useful for shortening resulting symbol names (MSVC++ 6.0, for instance,
- * has problems coping with very long symbol names.)
- */
-
-#if !defined(BOOST_MULTI_INDEX_LIMIT_INDEXED_BY_SIZE)
-#define BOOST_MULTI_INDEX_LIMIT_INDEXED_BY_SIZE BOOST_MPL_LIMIT_VECTOR_SIZE
-#endif
-
-#if BOOST_MULTI_INDEX_LIMIT_INDEXED_BY_SIZE<BOOST_MPL_LIMIT_VECTOR_SIZE
-#define BOOST_MULTI_INDEX_INDEXED_BY_SIZE \
-  BOOST_MULTI_INDEX_LIMIT_INDEXED_BY_SIZE
-#else
-#define BOOST_MULTI_INDEX_INDEXED_BY_SIZE BOOST_MPL_LIMIT_VECTOR_SIZE
-#endif
-
-#define BOOST_MULTI_INDEX_INDEXED_BY_TEMPLATE_PARM(z,n,var) \
-  typename BOOST_PP_CAT(var,n) BOOST_PP_EXPR_IF(n,=mpl::na)
-
-namespace boost{
-
-namespace multi_index{
-
-template<
-  BOOST_PP_ENUM(
-    BOOST_MULTI_INDEX_INDEXED_BY_SIZE,
-    BOOST_MULTI_INDEX_INDEXED_BY_TEMPLATE_PARM,T)
->
-struct indexed_by:
-  mpl::vector<BOOST_PP_ENUM_PARAMS(BOOST_MULTI_INDEX_INDEXED_BY_SIZE,T)>
-{
-};
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#undef BOOST_MULTI_INDEX_INDEXED_BY_TEMPLATE_PARM
-#undef BOOST_MULTI_INDEX_INDEXED_BY_SIZE
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/key_extractors.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/key_extractors.hpp
deleted file mode 100644
index 60179ba2339..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/key_extractors.hpp
+++ /dev/null
@@ -1,22 +0,0 @@
-/* Copyright 2003-2013 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_KEY_EXTRACTORS_HPP
-#define BOOST_MULTI_INDEX_KEY_EXTRACTORS_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/multi_index/composite_key.hpp>
-#include <boost/multi_index/identity.hpp>
-#include <boost/multi_index/global_fun.hpp>
-#include <boost/multi_index/member.hpp>
-#include <boost/multi_index/mem_fun.hpp>
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/mem_fun.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/mem_fun.hpp
deleted file mode 100644
index 111c386c5f5..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/mem_fun.hpp
+++ /dev/null
@@ -1,205 +0,0 @@
-/* Copyright 2003-2015 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_MEM_FUN_HPP
-#define BOOST_MULTI_INDEX_MEM_FUN_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <boost/mpl/if.hpp>
-#include <boost/type_traits/remove_reference.hpp>
-#include <boost/utility/enable_if.hpp>
-
-#if !defined(BOOST_NO_SFINAE)
-#include <boost/type_traits/is_convertible.hpp>
-#endif
-
-namespace boost{
-
-template<class T> class reference_wrapper; /* fwd decl. */
-
-namespace multi_index{
-
-/* mem_fun implements a read-only key extractor based on a given non-const
- * member function of a class.
- * const_mem_fun does the same for const member functions.
- * Additionally, mem_fun  and const_mem_fun are overloaded to support
- * referece_wrappers of T and "chained pointers" to T's. By chained pointer
- * to T we  mean a type P such that, given a p of Type P
- *   *...n...*x is convertible to T&, for some n>=1.
- * Examples of chained pointers are raw and smart pointers, iterators and
- * arbitrary combinations of these (vg. T** or unique_ptr<T*>.)
- */
-
-template<class Class,typename Type,Type (Class::*PtrToMemberFunction)()const>
-struct const_mem_fun
-{
-  typedef typename remove_reference<Type>::type result_type;
-
-  template<typename ChainedPtr>
-
-#if !defined(BOOST_NO_SFINAE)
-  typename disable_if<
-    is_convertible<const ChainedPtr&,const Class&>,Type>::type
-#else
-  Type
-#endif
-
-  operator()(const ChainedPtr& x)const
-  {
-    return operator()(*x);
-  }
-
-  Type operator()(const Class& x)const
-  {
-    return (x.*PtrToMemberFunction)();
-  }
-
-  Type operator()(const reference_wrapper<const Class>& x)const
-  { 
-    return operator()(x.get());
-  }
-
-  Type operator()(const reference_wrapper<Class>& x)const
-  { 
-    return operator()(x.get());
-  }
-};
-
-template<class Class,typename Type,Type (Class::*PtrToMemberFunction)()>
-struct mem_fun
-{
-  typedef typename remove_reference<Type>::type result_type;
-
-  template<typename ChainedPtr>
-
-#if !defined(BOOST_NO_SFINAE)
-  typename disable_if<
-    is_convertible<ChainedPtr&,Class&>,Type>::type
-#else
-  Type
-#endif
-
-  operator()(const ChainedPtr& x)const
-  {
-    return operator()(*x);
-  }
-
-  Type operator()(Class& x)const
-  {
-    return (x.*PtrToMemberFunction)();
-  }
-
-  Type operator()(const reference_wrapper<Class>& x)const
-  { 
-    return operator()(x.get());
-  }
-};
-
-/* MSVC++ 6.0 has problems with const member functions as non-type template
- * parameters, somehow it takes them as non-const. const_mem_fun_explicit
- * workarounds this deficiency by accepting an extra type parameter that
- * specifies the signature of the member function. The workaround was found at:
- *   Daniel, C.:"Re: weird typedef problem in VC",
- *   news:microsoft.public.vc.language, 21st nov 2002, 
- *   http://groups.google.com/groups?
- *     hl=en&lr=&ie=UTF-8&selm=ukwvg3O0BHA.1512%40tkmsftngp05
- *
- * MSVC++ 6.0 support has been dropped and [const_]mem_fun_explicit is
- * deprecated.
- */
-
-template<
-  class Class,typename Type,
-  typename PtrToMemberFunctionType,PtrToMemberFunctionType PtrToMemberFunction>
-struct const_mem_fun_explicit
-{
-  typedef typename remove_reference<Type>::type result_type;
-
-  template<typename ChainedPtr>
-
-#if !defined(BOOST_NO_SFINAE)
-  typename disable_if<
-    is_convertible<const ChainedPtr&,const Class&>,Type>::type
-#else
-  Type
-#endif
-
-  operator()(const ChainedPtr& x)const
-  {
-    return operator()(*x);
-  }
-
-  Type operator()(const Class& x)const
-  {
-    return (x.*PtrToMemberFunction)();
-  }
-
-  Type operator()(const reference_wrapper<const Class>& x)const
-  { 
-    return operator()(x.get());
-  }
-
-  Type operator()(const reference_wrapper<Class>& x)const
-  { 
-    return operator()(x.get());
-  }
-};
-
-template<
-  class Class,typename Type,
-  typename PtrToMemberFunctionType,PtrToMemberFunctionType PtrToMemberFunction>
-struct mem_fun_explicit
-{
-  typedef typename remove_reference<Type>::type result_type;
-
-  template<typename ChainedPtr>
-
-#if !defined(BOOST_NO_SFINAE)
-  typename disable_if<
-    is_convertible<ChainedPtr&,Class&>,Type>::type
-#else
-  Type
-#endif
-
-  operator()(const ChainedPtr& x)const
-  {
-    return operator()(*x);
-  }
-
-  Type operator()(Class& x)const
-  {
-    return (x.*PtrToMemberFunction)();
-  }
-
-  Type operator()(const reference_wrapper<Class>& x)const
-  { 
-    return operator()(x.get());
-  }
-};
-
-/* BOOST_MULTI_INDEX_CONST_MEM_FUN and BOOST_MULTI_INDEX_MEM_FUN used to
- * resolve to [const_]mem_fun_explicit for MSVC++ 6.0 and to
- * [const_]mem_fun otherwise. Support for this compiler having been dropped,
- * they are now just wrappers over [const_]mem_fun kept for backwards-
- * compatibility reasons.
- */
-
-#define BOOST_MULTI_INDEX_CONST_MEM_FUN(Class,Type,MemberFunName) \
-::boost::multi_index::const_mem_fun< Class,Type,&Class::MemberFunName >
-#define BOOST_MULTI_INDEX_MEM_FUN(Class,Type,MemberFunName) \
-::boost::multi_index::mem_fun< Class,Type,&Class::MemberFunName >
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/member.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/member.hpp
deleted file mode 100644
index a8e645074a2..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/member.hpp
+++ /dev/null
@@ -1,262 +0,0 @@
-/* Copyright 2003-2015 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_MEMBER_HPP
-#define BOOST_MULTI_INDEX_MEMBER_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <boost/mpl/if.hpp>
-#include <boost/type_traits/is_const.hpp>
-#include <boost/utility/enable_if.hpp>
-#include <cstddef>
-
-#if !defined(BOOST_NO_SFINAE)
-#include <boost/type_traits/is_convertible.hpp>
-#endif
-
-namespace boost{
-
-template<class T> class reference_wrapper; /* fwd decl. */
-
-namespace multi_index{
-
-namespace detail{
-
-/* member is a read/write key extractor for accessing a given
- * member of a class.
- * Additionally, member is overloaded to support referece_wrappers
- * of T and "chained pointers" to T's. By chained pointer to T we mean
- * a type P  such that, given a p of Type P
- *   *...n...*x is convertible to T&, for some n>=1.
- * Examples of chained pointers are raw and smart pointers, iterators and
- * arbitrary combinations of these (vg. T** or unique_ptr<T*>.)
- */
-
-template<class Class,typename Type,Type Class::*PtrToMember>
-struct const_member_base
-{
-  typedef Type result_type;
-
-  template<typename ChainedPtr>
-
-#if !defined(BOOST_NO_SFINAE)
-  typename disable_if<
-    is_convertible<const ChainedPtr&,const Class&>,Type&>::type
-#else
-  Type&
-#endif
-  
-  operator()(const ChainedPtr& x)const
-  {
-    return operator()(*x);
-  }
-
-  Type& operator()(const Class& x)const
-  {
-    return x.*PtrToMember;
-  }
-
-  Type& operator()(const reference_wrapper<const Class>& x)const
-  {
-    return operator()(x.get());
-  }
-
-  Type& operator()(const reference_wrapper<Class>& x)const
-  { 
-    return operator()(x.get());
-  }
-};
-
-template<class Class,typename Type,Type Class::*PtrToMember>
-struct non_const_member_base
-{
-  typedef Type result_type;
-
-  template<typename ChainedPtr>
-
-#if !defined(BOOST_NO_SFINAE)
-  typename disable_if<
-    is_convertible<const ChainedPtr&,const Class&>,Type&>::type
-#else
-  Type&
-#endif
-
-  operator()(const ChainedPtr& x)const
-  {
-    return operator()(*x);
-  }
-
-  const Type& operator()(const Class& x)const
-  {
-    return x.*PtrToMember;
-  }
-
-  Type& operator()(Class& x)const
-  { 
-    return x.*PtrToMember;
-  }
-
-  const Type& operator()(const reference_wrapper<const Class>& x)const
-  {
-    return operator()(x.get());
-  }
-
-  Type& operator()(const reference_wrapper<Class>& x)const
-  { 
-    return operator()(x.get());
-  }
-};
-
-} /* namespace multi_index::detail */
-
-template<class Class,typename Type,Type Class::*PtrToMember>
-struct member:
-  mpl::if_c<
-    is_const<Type>::value,
-    detail::const_member_base<Class,Type,PtrToMember>,
-    detail::non_const_member_base<Class,Type,PtrToMember>
-  >::type
-{
-};
-
-namespace detail{
-
-/* MSVC++ 6.0 does not support properly pointers to members as
- * non-type template arguments, as reported in
- *   http://support.microsoft.com/default.aspx?scid=kb;EN-US;249045
- * A similar problem (though not identical) is shown by MSVC++ 7.0.
- * We provide an alternative to member<> accepting offsets instead
- * of pointers to members. This happens to work even for non-POD
- * types (although the standard forbids use of offsetof on these),
- * so it serves as a workaround in this compiler for all practical
- * purposes.
- * Surprisingly enough, other compilers, like Intel C++ 7.0/7.1 and
- * Visual Age 6.0, have similar bugs. This replacement of member<>
- * can be used for them too.
- *
- * Support for such old compilers is dropped and
- * [non_]const_member_offset_base is deprecated.
- */
-
-template<class Class,typename Type,std::size_t OffsetOfMember>
-struct const_member_offset_base
-{
-  typedef Type result_type;
-
-  template<typename ChainedPtr>
-
-#if !defined(BOOST_NO_SFINAE)
-  typename disable_if<
-    is_convertible<const ChainedPtr&,const Class&>,Type&>::type
-#else
-  Type&
-#endif 
-    
-  operator()(const ChainedPtr& x)const
-  {
-    return operator()(*x);
-  }
-
-  Type& operator()(const Class& x)const
-  {
-    return *static_cast<const Type*>(
-      static_cast<const void*>(
-        static_cast<const char*>(
-          static_cast<const void *>(&x))+OffsetOfMember));
-  }
-
-  Type& operator()(const reference_wrapper<const Class>& x)const
-  {
-    return operator()(x.get());
-  }
-
-  Type& operator()(const reference_wrapper<Class>& x)const
-  {
-    return operator()(x.get());
-  }
-};
-
-template<class Class,typename Type,std::size_t OffsetOfMember>
-struct non_const_member_offset_base
-{
-  typedef Type result_type;
-
-  template<typename ChainedPtr>
-
-#if !defined(BOOST_NO_SFINAE)
-  typename disable_if<
-    is_convertible<const ChainedPtr&,const Class&>,Type&>::type
-#else
-  Type&
-#endif 
-  
-  operator()(const ChainedPtr& x)const
-  {
-    return operator()(*x);
-  }
-
-  const Type& operator()(const Class& x)const
-  {
-    return *static_cast<const Type*>(
-      static_cast<const void*>(
-        static_cast<const char*>(
-          static_cast<const void *>(&x))+OffsetOfMember));
-  }
-
-  Type& operator()(Class& x)const
-  { 
-    return *static_cast<Type*>(
-      static_cast<void*>(
-        static_cast<char*>(static_cast<void *>(&x))+OffsetOfMember));
-  }
-
-  const Type& operator()(const reference_wrapper<const Class>& x)const
-  {
-    return operator()(x.get());
-  }
-
-  Type& operator()(const reference_wrapper<Class>& x)const
-  {
-    return operator()(x.get());
-  }
-};
-
-} /* namespace multi_index::detail */
-
-template<class Class,typename Type,std::size_t OffsetOfMember>
-struct member_offset:
-  mpl::if_c<
-    is_const<Type>::value,
-    detail::const_member_offset_base<Class,Type,OffsetOfMember>,
-    detail::non_const_member_offset_base<Class,Type,OffsetOfMember>
-  >::type
-{
-};
-
-/* BOOST_MULTI_INDEX_MEMBER resolves to member in the normal cases,
- * and to member_offset as a workaround in those defective compilers for
- * which BOOST_NO_POINTER_TO_MEMBER_TEMPLATE_PARAMETERS is defined.
- */
-
-#if defined(BOOST_NO_POINTER_TO_MEMBER_TEMPLATE_PARAMETERS)
-#define BOOST_MULTI_INDEX_MEMBER(Class,Type,MemberName) \
-::boost::multi_index::member_offset< Class,Type,offsetof(Class,MemberName) >
-#else
-#define BOOST_MULTI_INDEX_MEMBER(Class,Type,MemberName) \
-::boost::multi_index::member< Class,Type,&Class::MemberName >
-#endif
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/ordered_index.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/ordered_index.hpp
deleted file mode 100644
index 5bcd69de8c9..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/ordered_index.hpp
+++ /dev/null
@@ -1,114 +0,0 @@
-/* Copyright 2003-2015 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_ORDERED_INDEX_HPP
-#define BOOST_MULTI_INDEX_ORDERED_INDEX_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <boost/multi_index/detail/ord_index_impl.hpp>
-#include <boost/multi_index/ordered_index_fwd.hpp>
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-/* no augment policy for plain ordered indices */
-
-struct null_augment_policy
-{
-  template<typename OrderedIndexImpl>
-  struct augmented_interface
-  {
-    typedef OrderedIndexImpl type;
-  };
-
-  template<typename OrderedIndexNodeImpl>
-  struct augmented_node
-  {
-    typedef OrderedIndexNodeImpl type;
-  };
-
-  template<typename Pointer> static void add(Pointer,Pointer){}
-  template<typename Pointer> static void remove(Pointer,Pointer){}
-  template<typename Pointer> static void copy(Pointer,Pointer){}
-  template<typename Pointer> static void rotate_left(Pointer,Pointer){}
-  template<typename Pointer> static void rotate_right(Pointer,Pointer){}
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING)
-  /* invariant stuff */
-
-  template<typename Pointer> static bool invariant(Pointer){return true;}
-
-#endif
-};
-
-} /* namespace multi_index::detail */
-
-/* ordered_index specifiers */
-
-template<typename Arg1,typename Arg2,typename Arg3>
-struct ordered_unique
-{
-  typedef typename detail::ordered_index_args<
-    Arg1,Arg2,Arg3>                                index_args;
-  typedef typename index_args::tag_list_type::type tag_list_type;
-  typedef typename index_args::key_from_value_type key_from_value_type;
-  typedef typename index_args::compare_type        compare_type;
-
-  template<typename Super>
-  struct node_class
-  {
-    typedef detail::ordered_index_node<detail::null_augment_policy,Super> type;
-  };
-
-  template<typename SuperMeta>
-  struct index_class
-  {
-    typedef detail::ordered_index<
-      key_from_value_type,compare_type,
-      SuperMeta,tag_list_type,detail::ordered_unique_tag,
-      detail::null_augment_policy>                        type;
-  };
-};
-
-template<typename Arg1,typename Arg2,typename Arg3>
-struct ordered_non_unique
-{
-  typedef detail::ordered_index_args<
-    Arg1,Arg2,Arg3>                                index_args;
-  typedef typename index_args::tag_list_type::type tag_list_type;
-  typedef typename index_args::key_from_value_type key_from_value_type;
-  typedef typename index_args::compare_type        compare_type;
-
-  template<typename Super>
-  struct node_class
-  {
-    typedef detail::ordered_index_node<detail::null_augment_policy,Super> type;
-  };
-
-  template<typename SuperMeta>
-  struct index_class
-  {
-    typedef detail::ordered_index<
-      key_from_value_type,compare_type,
-      SuperMeta,tag_list_type,detail::ordered_non_unique_tag,
-      detail::null_augment_policy>                            type;
-  };
-};
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/ordered_index_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/ordered_index_fwd.hpp
deleted file mode 100644
index fe44aaf860d..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/ordered_index_fwd.hpp
+++ /dev/null
@@ -1,35 +0,0 @@
-/* Copyright 2003-2015 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_ORDERED_INDEX_FWD_HPP
-#define BOOST_MULTI_INDEX_ORDERED_INDEX_FWD_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/multi_index/detail/ord_index_args.hpp>
-#include <boost/multi_index/detail/ord_index_impl_fwd.hpp>
-
-namespace boost{
-
-namespace multi_index{
-
-/* ordered_index specifiers */
-
-template<typename Arg1,typename Arg2=mpl::na,typename Arg3=mpl::na>
-struct ordered_unique;
-
-template<typename Arg1,typename Arg2=mpl::na,typename Arg3=mpl::na>
-struct ordered_non_unique;
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/random_access_index.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/random_access_index.hpp
deleted file mode 100644
index fe1884ddd38..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/random_access_index.hpp
+++ /dev/null
@@ -1,1167 +0,0 @@
-/* Copyright 2003-2015 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_RANDOM_ACCESS_INDEX_HPP
-#define BOOST_MULTI_INDEX_RANDOM_ACCESS_INDEX_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <algorithm>
-#include <boost/bind.hpp>
-#include <boost/call_traits.hpp>
-#include <boost/detail/no_exceptions_support.hpp>
-#include <boost/detail/workaround.hpp>
-#include <boost/foreach_fwd.hpp>
-#include <boost/iterator/reverse_iterator.hpp>
-#include <boost/move/core.hpp>
-#include <boost/move/utility.hpp>
-#include <boost/mpl/bool.hpp>
-#include <boost/mpl/not.hpp>
-#include <boost/mpl/push_front.hpp>
-#include <boost/multi_index/detail/access_specifier.hpp>
-#include <boost/multi_index/detail/do_not_copy_elements_tag.hpp>
-#include <boost/multi_index/detail/index_node_base.hpp>
-#include <boost/multi_index/detail/rnd_node_iterator.hpp>
-#include <boost/multi_index/detail/rnd_index_node.hpp>
-#include <boost/multi_index/detail/rnd_index_ops.hpp>
-#include <boost/multi_index/detail/rnd_index_ptr_array.hpp>
-#include <boost/multi_index/detail/safe_mode.hpp>
-#include <boost/multi_index/detail/scope_guard.hpp>
-#include <boost/multi_index/detail/vartempl_support.hpp>
-#include <boost/multi_index/random_access_index_fwd.hpp>
-#include <boost/throw_exception.hpp> 
-#include <boost/tuple/tuple.hpp>
-#include <boost/type_traits/is_integral.hpp>
-#include <cstddef>
-#include <functional>
-#include <stdexcept> 
-#include <utility>
-
-#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
-#include<initializer_list>
-#endif
-
-#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
-#include <boost/multi_index/detail/rnd_index_loader.hpp>
-#endif
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING)
-#define BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT_OF(x)                    \
-  detail::scope_guard BOOST_JOIN(check_invariant_,__LINE__)=                 \
-    detail::make_obj_guard(x,&random_access_index::check_invariant_);        \
-  BOOST_JOIN(check_invariant_,__LINE__).touch();
-#define BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT                          \
-  BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT_OF(*this)
-#else
-#define BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT_OF(x)
-#define BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT
-#endif
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-/* random_access_index adds a layer of random access indexing
- * to a given Super
- */
-
-template<typename SuperMeta,typename TagList>
-class random_access_index:
-  BOOST_MULTI_INDEX_PROTECTED_IF_MEMBER_TEMPLATE_FRIENDS SuperMeta::type
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-  ,public safe_mode::safe_container<
-    random_access_index<SuperMeta,TagList> >
-#endif
-
-{ 
-#if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING)&&\
-    BOOST_WORKAROUND(__MWERKS__,<=0x3003)
-/* The "ISO C++ Template Parser" option in CW8.3 has a problem with the
- * lifetime of const references bound to temporaries --precisely what
- * scopeguards are.
- */
-
-#pragma parse_mfunc_templ off
-#endif
-
-  typedef typename SuperMeta::type                 super;
-
-protected:
-  typedef random_access_index_node<
-    typename super::node_type>                     node_type;
-
-private:
-  typedef typename node_type::impl_type            node_impl_type;
-  typedef random_access_index_ptr_array<
-    typename super::final_allocator_type>          ptr_array;
-  typedef typename ptr_array::pointer              node_impl_ptr_pointer;
-
-public:
-  /* types */
-
-  typedef typename node_type::value_type           value_type;
-  typedef tuples::null_type                        ctor_args;
-  typedef typename super::final_allocator_type     allocator_type;
-  typedef typename allocator_type::reference       reference;
-  typedef typename allocator_type::const_reference const_reference;
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-  typedef safe_mode::safe_iterator<
-    rnd_node_iterator<node_type>,
-    random_access_index>                           iterator;
-#else
-  typedef rnd_node_iterator<node_type>             iterator;
-#endif
-
-  typedef iterator                                 const_iterator;
-
-  typedef std::size_t                              size_type;      
-  typedef std::ptrdiff_t                           difference_type;
-  typedef typename allocator_type::pointer         pointer;
-  typedef typename allocator_type::const_pointer   const_pointer;
-  typedef typename
-    boost::reverse_iterator<iterator>              reverse_iterator;
-  typedef typename
-    boost::reverse_iterator<const_iterator>        const_reverse_iterator;
-  typedef TagList                                  tag_list;
-
-protected:
-  typedef typename super::final_node_type     final_node_type;
-  typedef tuples::cons<
-    ctor_args, 
-    typename super::ctor_args_list>           ctor_args_list;
-  typedef typename mpl::push_front<
-    typename super::index_type_list,
-    random_access_index>::type                index_type_list;
-  typedef typename mpl::push_front<
-    typename super::iterator_type_list,
-    iterator>::type                           iterator_type_list;
-  typedef typename mpl::push_front<
-    typename super::const_iterator_type_list,
-    const_iterator>::type                     const_iterator_type_list;
-  typedef typename super::copy_map_type       copy_map_type;
-
-#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
-  typedef typename super::index_saver_type    index_saver_type;
-  typedef typename super::index_loader_type   index_loader_type;
-#endif
-
-private:
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-  typedef safe_mode::safe_container<
-    random_access_index>                      safe_super;
-#endif
-
-  typedef typename call_traits<
-    value_type>::param_type                   value_param_type;
-
-  /* Needed to avoid commas in BOOST_MULTI_INDEX_OVERLOADS_TO_VARTEMPL
-   * expansion.
-   */
-
-  typedef std::pair<iterator,bool>            emplace_return_type;
-
-public:
-
-  /* construct/copy/destroy
-   * Default and copy ctors are in the protected section as indices are
-   * not supposed to be created on their own. No range ctor either.
-   */
-
-  random_access_index<SuperMeta,TagList>& operator=(
-    const random_access_index<SuperMeta,TagList>& x)
-  {
-    this->final()=x.final();
-    return *this;
-  }
-
-#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
-  random_access_index<SuperMeta,TagList>& operator=(
-    std::initializer_list<value_type> list)
-  {
-    this->final()=list;
-    return *this;
-  }
-#endif
-
-  template <class InputIterator>
-  void assign(InputIterator first,InputIterator last)
-  {
-    assign_iter(first,last,mpl::not_<is_integral<InputIterator> >());
-  }
-
-#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
-  void assign(std::initializer_list<value_type> list)
-  {
-    assign(list.begin(),list.end());
-  }
-#endif
-
-  void assign(size_type n,value_param_type value)
-  {
-    BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
-    clear();
-    for(size_type i=0;i<n;++i)push_back(value);
-  }
-    
-  allocator_type get_allocator()const BOOST_NOEXCEPT
-  {
-    return this->final().get_allocator();
-  }
-
-  /* iterators */
-
-  iterator begin()BOOST_NOEXCEPT
-    {return make_iterator(node_type::from_impl(*ptrs.begin()));}
-  const_iterator begin()const BOOST_NOEXCEPT
-    {return make_iterator(node_type::from_impl(*ptrs.begin()));}
-  iterator
-    end()BOOST_NOEXCEPT{return make_iterator(header());}
-  const_iterator
-    end()const BOOST_NOEXCEPT{return make_iterator(header());}
-  reverse_iterator
-    rbegin()BOOST_NOEXCEPT{return boost::make_reverse_iterator(end());}
-  const_reverse_iterator
-    rbegin()const BOOST_NOEXCEPT{return boost::make_reverse_iterator(end());}
-  reverse_iterator
-    rend()BOOST_NOEXCEPT{return boost::make_reverse_iterator(begin());}
-  const_reverse_iterator
-    rend()const BOOST_NOEXCEPT{return boost::make_reverse_iterator(begin());}
-  const_iterator
-    cbegin()const BOOST_NOEXCEPT{return begin();}
-  const_iterator
-    cend()const BOOST_NOEXCEPT{return end();}
-  const_reverse_iterator
-    crbegin()const BOOST_NOEXCEPT{return rbegin();}
-  const_reverse_iterator
-    crend()const BOOST_NOEXCEPT{return rend();}
-
-  iterator iterator_to(const value_type& x)
-  {
-    return make_iterator(node_from_value<node_type>(&x));
-  }
-
-  const_iterator iterator_to(const value_type& x)const
-  {
-    return make_iterator(node_from_value<node_type>(&x));
-  }
-
-  /* capacity */
-
-  bool      empty()const BOOST_NOEXCEPT{return this->final_empty_();}
-  size_type size()const BOOST_NOEXCEPT{return this->final_size_();}
-  size_type max_size()const BOOST_NOEXCEPT{return this->final_max_size_();}
-  size_type capacity()const BOOST_NOEXCEPT{return ptrs.capacity();}
-
-  void reserve(size_type n)
-  {
-    BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
-    ptrs.reserve(n);
-  }
-  
-  void shrink_to_fit()
-  {
-    BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
-    ptrs.shrink_to_fit();
-  }
-
-  void resize(size_type n)
-  {
-    BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
-    if(n>size())
-      for(size_type m=n-size();m--;)
-        this->final_emplace_(BOOST_MULTI_INDEX_NULL_PARAM_PACK);
-    else if(n<size())erase(begin()+n,end());
-  }
-
-  void resize(size_type n,value_param_type x)
-  {
-    BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
-    if(n>size())for(size_type m=n-size();m--;)this->final_insert_(x); 
-    else if(n<size())erase(begin()+n,end());
-  }
-
-  /* access: no non-const versions provided as random_access_index
-   * handles const elements.
-   */
-
-  const_reference operator[](size_type n)const
-  {
-    BOOST_MULTI_INDEX_SAFE_MODE_ASSERT(n<size(),safe_mode::out_of_bounds);
-    return node_type::from_impl(*ptrs.at(n))->value();
-  }
-
-  const_reference at(size_type n)const
-  {
-    if(n>=size())throw_exception(std::out_of_range("random access index"));
-    return node_type::from_impl(*ptrs.at(n))->value();
-  }
-
-  const_reference front()const{return operator[](0);}
-  const_reference back()const{return operator[](size()-1);}
-
-  /* modifiers */
-
-  BOOST_MULTI_INDEX_OVERLOADS_TO_VARTEMPL(
-    emplace_return_type,emplace_front,emplace_front_impl)
-    
-  std::pair<iterator,bool> push_front(const value_type& x)
-                             {return insert(begin(),x);}
-  std::pair<iterator,bool> push_front(BOOST_RV_REF(value_type) x)
-                             {return insert(begin(),boost::move(x));}
-  void                     pop_front(){erase(begin());}
-
-  BOOST_MULTI_INDEX_OVERLOADS_TO_VARTEMPL(
-    emplace_return_type,emplace_back,emplace_back_impl)
-
-  std::pair<iterator,bool> push_back(const value_type& x)
-                             {return insert(end(),x);}
-  std::pair<iterator,bool> push_back(BOOST_RV_REF(value_type) x)
-                             {return insert(end(),boost::move(x));}
-  void                     pop_back(){erase(--end());}
-
-  BOOST_MULTI_INDEX_OVERLOADS_TO_VARTEMPL_EXTRA_ARG(
-    emplace_return_type,emplace,emplace_impl,iterator,position)
-    
-  std::pair<iterator,bool> insert(iterator position,const value_type& x)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
-    BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
-    std::pair<final_node_type*,bool> p=this->final_insert_(x);
-    if(p.second&&position.get_node()!=header()){
-      relocate(position.get_node(),p.first);
-    }
-    return std::pair<iterator,bool>(make_iterator(p.first),p.second);
-  }
-
-  std::pair<iterator,bool> insert(iterator position,BOOST_RV_REF(value_type) x)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
-    BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
-    std::pair<final_node_type*,bool> p=this->final_insert_rv_(x);
-    if(p.second&&position.get_node()!=header()){
-      relocate(position.get_node(),p.first);
-    }
-    return std::pair<iterator,bool>(make_iterator(p.first),p.second);
-  }
-
-  void insert(iterator position,size_type n,value_param_type x)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
-    BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
-    size_type s=0;
-    BOOST_TRY{
-      while(n--){
-        if(push_back(x).second)++s;
-      }
-    }
-    BOOST_CATCH(...){
-      relocate(position,end()-s,end());
-      BOOST_RETHROW;
-    }
-    BOOST_CATCH_END
-    relocate(position,end()-s,end());
-  }
- 
-  template<typename InputIterator>
-  void insert(iterator position,InputIterator first,InputIterator last)
-  {
-    insert_iter(position,first,last,mpl::not_<is_integral<InputIterator> >());
-  }
-
-#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
-  void insert(iterator position,std::initializer_list<value_type> list)
-  {
-    insert(position,list.begin(),list.end());
-  }
-#endif
-
-  iterator erase(iterator position)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
-    BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
-    this->final_erase_(static_cast<final_node_type*>(position++.get_node()));
-    return position;
-  }
-  
-  iterator erase(iterator first,iterator last)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(first);
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(last);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(first,*this);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(last,*this);
-    BOOST_MULTI_INDEX_CHECK_VALID_RANGE(first,last);
-    BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
-    difference_type n=last-first;
-    relocate(end(),first,last);
-    while(n--)pop_back();
-    return last;
-  }
-
-  bool replace(iterator position,const value_type& x)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
-    BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
-    return this->final_replace_(
-      x,static_cast<final_node_type*>(position.get_node()));
-  }
-
-  bool replace(iterator position,BOOST_RV_REF(value_type) x)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
-    BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
-    return this->final_replace_rv_(
-      x,static_cast<final_node_type*>(position.get_node()));
-  }
-
-  template<typename Modifier>
-  bool modify(iterator position,Modifier mod)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
-    BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-    /* MSVC++ 6.0 optimizer on safe mode code chokes if this
-     * this is not added. Left it for all compilers as it does no
-     * harm.
-     */
-
-    position.detach();
-#endif
-
-    return this->final_modify_(
-      mod,static_cast<final_node_type*>(position.get_node()));
-  }
-
-  template<typename Modifier,typename Rollback>
-  bool modify(iterator position,Modifier mod,Rollback back_)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
-    BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-    /* MSVC++ 6.0 optimizer on safe mode code chokes if this
-     * this is not added. Left it for all compilers as it does no
-     * harm.
-     */
-
-    position.detach();
-#endif
-
-    return this->final_modify_(
-      mod,back_,static_cast<final_node_type*>(position.get_node()));
-  }
-
-  void swap(random_access_index<SuperMeta,TagList>& x)
-  {
-    BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
-    BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT_OF(x);
-    this->final_swap_(x.final());
-  }
-
-  void clear()BOOST_NOEXCEPT
-  {
-    BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
-    this->final_clear_();
-  }
-
-  /* list operations */
-
-  void splice(iterator position,random_access_index<SuperMeta,TagList>& x)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
-    BOOST_MULTI_INDEX_CHECK_DIFFERENT_CONTAINER(*this,x);
-    BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
-    iterator  first=x.begin(),last=x.end();
-    size_type n=0;
-    BOOST_TRY{
-      while(first!=last){
-        if(push_back(*first).second){
-          first=x.erase(first);
-          ++n;
-        }
-        else ++first;
-      }
-    }
-    BOOST_CATCH(...){
-      relocate(position,end()-n,end());
-      BOOST_RETHROW;
-    }
-    BOOST_CATCH_END
-    relocate(position,end()-n,end());
-  }
-
-  void splice(
-    iterator position,random_access_index<SuperMeta,TagList>& x,iterator i)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(i);
-    BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(i);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(i,x);
-    BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
-    if(&x==this)relocate(position,i);
-    else{
-      if(insert(position,*i).second){
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-    /* MSVC++ 6.0 optimizer has a hard time with safe mode, and the following
-     * workaround is needed. Left it for all compilers as it does no
-     * harm.
-     */
-        i.detach();
-        x.erase(x.make_iterator(i.get_node()));
-#else
-        x.erase(i);
-#endif
-
-      }
-    }
-  }
-
-  void splice(
-    iterator position,random_access_index<SuperMeta,TagList>& x,
-    iterator first,iterator last)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(first);
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(last);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(first,x);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(last,x);
-    BOOST_MULTI_INDEX_CHECK_VALID_RANGE(first,last);
-    BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
-    if(&x==this)relocate(position,first,last);
-    else{
-      size_type n=0;
-      BOOST_TRY{
-        while(first!=last){
-          if(push_back(*first).second){
-            first=x.erase(first);
-            ++n;
-          }
-          else ++first;
-        }
-      }
-      BOOST_CATCH(...){
-        relocate(position,end()-n,end());
-        BOOST_RETHROW;
-      }
-      BOOST_CATCH_END
-      relocate(position,end()-n,end());
-    }
-  }
-
-  void remove(value_param_type value)
-  {
-    BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
-    difference_type n=
-      end()-make_iterator(
-        random_access_index_remove<node_type>(
-          ptrs,
-          ::boost::bind(std::equal_to<value_type>(),::boost::arg<1>(),value)));
-    while(n--)pop_back();
-  }
-
-  template<typename Predicate>
-  void remove_if(Predicate pred)
-  {
-    BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
-    difference_type n=
-      end()-make_iterator(random_access_index_remove<node_type>(ptrs,pred));
-    while(n--)pop_back();
-  }
-
-  void unique()
-  {
-    BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
-    difference_type n=
-      end()-make_iterator(
-        random_access_index_unique<node_type>(
-          ptrs,std::equal_to<value_type>()));
-    while(n--)pop_back();
-  }
-
-  template <class BinaryPredicate>
-  void unique(BinaryPredicate binary_pred)
-  {
-    BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
-    difference_type n=
-      end()-make_iterator(
-        random_access_index_unique<node_type>(ptrs,binary_pred));
-    while(n--)pop_back();
-  }
-
-  void merge(random_access_index<SuperMeta,TagList>& x)
-  {
-    if(this!=&x){
-      BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
-      size_type s=size();
-      splice(end(),x);
-      random_access_index_inplace_merge<node_type>(
-        get_allocator(),ptrs,ptrs.at(s),std::less<value_type>());
-    }
-  }
-
-  template <typename Compare>
-  void merge(random_access_index<SuperMeta,TagList>& x,Compare comp)
-  {
-    if(this!=&x){
-      BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
-      size_type s=size();
-      splice(end(),x);
-      random_access_index_inplace_merge<node_type>(
-        get_allocator(),ptrs,ptrs.at(s),comp);
-    }
-  }
-
-  void sort()
-  {
-    BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
-    random_access_index_sort<node_type>(
-      get_allocator(),ptrs,std::less<value_type>());
-  }
-
-  template <typename Compare>
-  void sort(Compare comp)
-  {
-    BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
-    random_access_index_sort<node_type>(
-      get_allocator(),ptrs,comp);
-  }
-
-  void reverse()BOOST_NOEXCEPT
-  {
-    BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
-    node_impl_type::reverse(ptrs.begin(),ptrs.end());
-  }
-
-  /* rearrange operations */
-
-  void relocate(iterator position,iterator i)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(i);
-    BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(i);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(i,*this);
-    BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
-    if(position!=i)relocate(position.get_node(),i.get_node());
-  }
-
-  void relocate(iterator position,iterator first,iterator last)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(first);
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(last);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(first,*this);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(last,*this);
-    BOOST_MULTI_INDEX_CHECK_VALID_RANGE(first,last);
-    BOOST_MULTI_INDEX_CHECK_OUTSIDE_RANGE(position,first,last);
-    BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
-    if(position!=last)relocate(
-      position.get_node(),first.get_node(),last.get_node());
-  }
-
-  template<typename InputIterator>
-  void rearrange(InputIterator first)
-  {
-    BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
-    for(node_impl_ptr_pointer p0=ptrs.begin(),p0_end=ptrs.end();
-        p0!=p0_end;++first,++p0){
-      const value_type& v1=*first;
-      node_impl_ptr_pointer p1=node_from_value<node_type>(&v1)->up();
-
-      std::swap(*p0,*p1);
-      (*p0)->up()=p0;
-      (*p1)->up()=p1;
-    }
-  }
-    
-BOOST_MULTI_INDEX_PROTECTED_IF_MEMBER_TEMPLATE_FRIENDS:
-  random_access_index(
-    const ctor_args_list& args_list,const allocator_type& al):
-    super(args_list.get_tail(),al),
-    ptrs(al,header()->impl(),0)
-  {
-  }
-
-  random_access_index(const random_access_index<SuperMeta,TagList>& x):
-    super(x),
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-    safe_super(),
-#endif
-
-    ptrs(x.get_allocator(),header()->impl(),x.size())
-  {
-    /* The actual copying takes place in subsequent call to copy_().
-     */
-  }
-
-  random_access_index(
-    const random_access_index<SuperMeta,TagList>& x,do_not_copy_elements_tag):
-    super(x,do_not_copy_elements_tag()),
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-    safe_super(),
-#endif
-
-    ptrs(x.get_allocator(),header()->impl(),0)
-  {
-  }
-
-  ~random_access_index()
-  {
-    /* the container is guaranteed to be empty by now */
-  }
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-  iterator       make_iterator(node_type* node){return iterator(node,this);}
-  const_iterator make_iterator(node_type* node)const
-    {return const_iterator(node,const_cast<random_access_index*>(this));}
-#else
-  iterator       make_iterator(node_type* node){return iterator(node);}
-  const_iterator make_iterator(node_type* node)const
-                   {return const_iterator(node);}
-#endif
-
-  void copy_(
-    const random_access_index<SuperMeta,TagList>& x,const copy_map_type& map)
-  {
-    for(node_impl_ptr_pointer begin_org=x.ptrs.begin(),
-                              begin_cpy=ptrs.begin(),
-                              end_org=x.ptrs.end();
-        begin_org!=end_org;++begin_org,++begin_cpy){
-      *begin_cpy=
-         static_cast<node_type*>(
-           map.find(
-             static_cast<final_node_type*>(
-               node_type::from_impl(*begin_org))))->impl();
-      (*begin_cpy)->up()=begin_cpy;
-    }
-
-    super::copy_(x,map);
-  }
-
-  template<typename Variant>
-  final_node_type* insert_(
-    value_param_type v,final_node_type*& x,Variant variant)
-  {
-    ptrs.room_for_one();
-    final_node_type* res=super::insert_(v,x,variant);
-    if(res==x)ptrs.push_back(static_cast<node_type*>(x)->impl());
-    return res;
-  }
-
-  template<typename Variant>
-  final_node_type* insert_(
-    value_param_type v,node_type* position,final_node_type*& x,Variant variant)
-  {
-    ptrs.room_for_one();
-    final_node_type* res=super::insert_(v,position,x,variant);
-    if(res==x)ptrs.push_back(static_cast<node_type*>(x)->impl());
-    return res;
-  }
-
-  void erase_(node_type* x)
-  {
-    ptrs.erase(x->impl());
-    super::erase_(x);
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-    detach_iterators(x);
-#endif
-  }
-
-  void delete_all_nodes_()
-  {
-    for(node_impl_ptr_pointer x=ptrs.begin(),x_end=ptrs.end();x!=x_end;++x){
-      this->final_delete_node_(
-        static_cast<final_node_type*>(node_type::from_impl(*x)));
-    }
-  }
-
-  void clear_()
-  {
-    super::clear_();
-    ptrs.clear();
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-    safe_super::detach_dereferenceable_iterators();
-#endif
-  }
-
-  void swap_(random_access_index<SuperMeta,TagList>& x)
-  {
-    ptrs.swap(x.ptrs);
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-    safe_super::swap(x);
-#endif
-
-    super::swap_(x);
-  }
-
-  void swap_elements_(random_access_index<SuperMeta,TagList>& x)
-  {
-    ptrs.swap(x.ptrs);
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-    safe_super::swap(x);
-#endif
-
-    super::swap_elements_(x);
-  }
-
-  template<typename Variant>
-  bool replace_(value_param_type v,node_type* x,Variant variant)
-  {
-    return super::replace_(v,x,variant);
-  }
-
-  bool modify_(node_type* x)
-  {
-    BOOST_TRY{
-      if(!super::modify_(x)){
-        ptrs.erase(x->impl());
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-        detach_iterators(x);
-#endif
-
-        return false;
-      }
-      else return true;
-    }
-    BOOST_CATCH(...){
-      ptrs.erase(x->impl());
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-      detach_iterators(x);
-#endif
-
-      BOOST_RETHROW;
-    }
-    BOOST_CATCH_END
-  }
-
-  bool modify_rollback_(node_type* x)
-  {
-    return super::modify_rollback_(x);
-  }
-
-#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
-  /* serialization */
-
-  template<typename Archive>
-  void save_(
-    Archive& ar,const unsigned int version,const index_saver_type& sm)const
-  {
-    sm.save(begin(),end(),ar,version);
-    super::save_(ar,version,sm);
-  }
-
-  template<typename Archive>
-  void load_(
-    Archive& ar,const unsigned int version,const index_loader_type& lm)
-  {
-    {
-      typedef random_access_index_loader<node_type,allocator_type> loader;
-
-      loader ld(get_allocator(),ptrs);
-      lm.load(
-        ::boost::bind(
-          &loader::rearrange,&ld,::boost::arg<1>(),::boost::arg<2>()),
-        ar,version);
-    } /* exit scope so that ld frees its resources */
-    super::load_(ar,version,lm);
-  }
-#endif
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING)
-  /* invariant stuff */
-
-  bool invariant_()const
-  {
-    if(size()>capacity())return false;
-    if(size()==0||begin()==end()){
-      if(size()!=0||begin()!=end())return false;
-    }
-    else{
-      size_type s=0;
-      for(const_iterator it=begin(),it_end=end();;++it,++s){
-        if(*(it.get_node()->up())!=it.get_node()->impl())return false;
-        if(it==it_end)break;
-      }
-      if(s!=size())return false;
-    }
-
-    return super::invariant_();
-  }
-
-  /* This forwarding function eases things for the boost::mem_fn construct
-   * in BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT. Actually,
-   * final_check_invariant is already an inherited member function of index.
-   */
-  void check_invariant_()const{this->final_check_invariant_();}
-#endif
-
-private:
-  node_type* header()const{return this->final_header();}
-
-  static void relocate(node_type* position,node_type* x)
-  {
-    node_impl_type::relocate(position->up(),x->up());
-  }
-
-  static void relocate(node_type* position,node_type* first,node_type* last)
-  {
-    node_impl_type::relocate(
-      position->up(),first->up(),last->up());
-  }
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-  void detach_iterators(node_type* x)
-  {
-    iterator it=make_iterator(x);
-    safe_mode::detach_equivalent_iterators(it);
-  }
-#endif
-
-  template <class InputIterator>
-  void assign_iter(InputIterator first,InputIterator last,mpl::true_)
-  {
-    BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
-    clear();
-    for(;first!=last;++first)this->final_insert_ref_(*first);
-  }
-
-  void assign_iter(size_type n,value_param_type value,mpl::false_)
-  {
-    BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
-    clear();
-    for(size_type i=0;i<n;++i)push_back(value);
-  }
-
-  template<typename InputIterator>
-  void insert_iter(
-    iterator position,InputIterator first,InputIterator last,mpl::true_)
-  {
-    BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
-    size_type s=0;
-    BOOST_TRY{
-      for(;first!=last;++first){
-        if(this->final_insert_ref_(*first).second)++s;
-      }
-    }
-    BOOST_CATCH(...){
-      relocate(position,end()-s,end());
-      BOOST_RETHROW;
-    }
-    BOOST_CATCH_END
-    relocate(position,end()-s,end());
-  }
-
-  void insert_iter(
-    iterator position,size_type n,value_param_type x,mpl::false_)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
-    BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
-    size_type  s=0;
-    BOOST_TRY{
-      while(n--){
-        if(push_back(x).second)++s;
-      }
-    }
-    BOOST_CATCH(...){
-      relocate(position,end()-s,end());
-      BOOST_RETHROW;
-    }
-    BOOST_CATCH_END
-    relocate(position,end()-s,end());
-  }
- 
-  template<BOOST_MULTI_INDEX_TEMPLATE_PARAM_PACK>
-  std::pair<iterator,bool> emplace_front_impl(
-    BOOST_MULTI_INDEX_FUNCTION_PARAM_PACK)
-  {
-    return emplace_impl(begin(),BOOST_MULTI_INDEX_FORWARD_PARAM_PACK);
-  }
-
-  template<BOOST_MULTI_INDEX_TEMPLATE_PARAM_PACK>
-  std::pair<iterator,bool> emplace_back_impl(
-    BOOST_MULTI_INDEX_FUNCTION_PARAM_PACK)
-  {
-    return emplace_impl(end(),BOOST_MULTI_INDEX_FORWARD_PARAM_PACK);
-  }
-
-  template<BOOST_MULTI_INDEX_TEMPLATE_PARAM_PACK>
-  std::pair<iterator,bool> emplace_impl(
-    iterator position,BOOST_MULTI_INDEX_FUNCTION_PARAM_PACK)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
-    BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
-    std::pair<final_node_type*,bool> p=
-      this->final_emplace_(BOOST_MULTI_INDEX_FORWARD_PARAM_PACK);
-    if(p.second&&position.get_node()!=header()){
-      relocate(position.get_node(),p.first);
-    }
-    return std::pair<iterator,bool>(make_iterator(p.first),p.second);
-  }
-
-  ptr_array ptrs;
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING)&&\
-    BOOST_WORKAROUND(__MWERKS__,<=0x3003)
-#pragma parse_mfunc_templ reset
-#endif
-};
-
-/* comparison */
-
-template<
-  typename SuperMeta1,typename TagList1,
-  typename SuperMeta2,typename TagList2
->
-bool operator==(
-  const random_access_index<SuperMeta1,TagList1>& x,
-  const random_access_index<SuperMeta2,TagList2>& y)
-{
-  return x.size()==y.size()&&std::equal(x.begin(),x.end(),y.begin());
-}
-
-template<
-  typename SuperMeta1,typename TagList1,
-  typename SuperMeta2,typename TagList2
->
-bool operator<(
-  const random_access_index<SuperMeta1,TagList1>& x,
-  const random_access_index<SuperMeta2,TagList2>& y)
-{
-  return std::lexicographical_compare(x.begin(),x.end(),y.begin(),y.end());
-}
-
-template<
-  typename SuperMeta1,typename TagList1,
-  typename SuperMeta2,typename TagList2
->
-bool operator!=(
-  const random_access_index<SuperMeta1,TagList1>& x,
-  const random_access_index<SuperMeta2,TagList2>& y)
-{
-  return !(x==y);
-}
-
-template<
-  typename SuperMeta1,typename TagList1,
-  typename SuperMeta2,typename TagList2
->
-bool operator>(
-  const random_access_index<SuperMeta1,TagList1>& x,
-  const random_access_index<SuperMeta2,TagList2>& y)
-{
-  return y<x;
-}
-
-template<
-  typename SuperMeta1,typename TagList1,
-  typename SuperMeta2,typename TagList2
->
-bool operator>=(
-  const random_access_index<SuperMeta1,TagList1>& x,
-  const random_access_index<SuperMeta2,TagList2>& y)
-{
-  return !(x<y);
-}
-
-template<
-  typename SuperMeta1,typename TagList1,
-  typename SuperMeta2,typename TagList2
->
-bool operator<=(
-  const random_access_index<SuperMeta1,TagList1>& x,
-  const random_access_index<SuperMeta2,TagList2>& y)
-{
-  return !(x>y);
-}
-
-/*  specialized algorithms */
-
-template<typename SuperMeta,typename TagList>
-void swap(
-  random_access_index<SuperMeta,TagList>& x,
-  random_access_index<SuperMeta,TagList>& y)
-{
-  x.swap(y);
-}
-
-} /* namespace multi_index::detail */
-
-/* random access index specifier */
-
-template <typename TagList>
-struct random_access
-{
-  BOOST_STATIC_ASSERT(detail::is_tag<TagList>::value);
-
-  template<typename Super>
-  struct node_class
-  {
-    typedef detail::random_access_index_node<Super> type;
-  };
-
-  template<typename SuperMeta>
-  struct index_class
-  {
-    typedef detail::random_access_index<
-      SuperMeta,typename TagList::type>  type;
-  };
-};
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-/* Boost.Foreach compatibility */
-
-template<typename SuperMeta,typename TagList>
-inline boost::mpl::true_* boost_foreach_is_noncopyable(
-  boost::multi_index::detail::random_access_index<SuperMeta,TagList>*&,
-  boost_foreach_argument_dependent_lookup_hack)
-{
-  return 0;
-}
-
-#undef BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT
-#undef BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT_OF
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/random_access_index_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/random_access_index_fwd.hpp
deleted file mode 100644
index 2ea19295426..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/random_access_index_fwd.hpp
+++ /dev/null
@@ -1,91 +0,0 @@
-/* Copyright 2003-2013 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_RANDOM_ACCESS_INDEX_FWD_HPP
-#define BOOST_MULTI_INDEX_RANDOM_ACCESS_INDEX_FWD_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/multi_index/tag.hpp>
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-template<typename SuperMeta,typename TagList>
-class random_access_index;
-
-template<
-  typename SuperMeta1,typename TagList1,
-  typename SuperMeta2,typename TagList2
->
-bool operator==(
-  const random_access_index<SuperMeta1,TagList1>& x,
-  const random_access_index<SuperMeta2,TagList2>& y);
-
-template<
-  typename SuperMeta1,typename TagList1,
-  typename SuperMeta2,typename TagList2
->
-bool operator<(
-  const random_access_index<SuperMeta1,TagList1>& x,
-  const random_access_index<SuperMeta2,TagList2>& y);
-
-template<
-  typename SuperMeta1,typename TagList1,
-  typename SuperMeta2,typename TagList2
->
-bool operator!=(
-  const random_access_index<SuperMeta1,TagList1>& x,
-  const random_access_index<SuperMeta2,TagList2>& y);
-
-template<
-  typename SuperMeta1,typename TagList1,
-  typename SuperMeta2,typename TagList2
->
-bool operator>(
-  const random_access_index<SuperMeta1,TagList1>& x,
-  const random_access_index<SuperMeta2,TagList2>& y);
-
-template<
-  typename SuperMeta1,typename TagList1,
-  typename SuperMeta2,typename TagList2
->
-bool operator>=(
-  const random_access_index<SuperMeta1,TagList1>& x,
-  const random_access_index<SuperMeta2,TagList2>& y);
-
-template<
-  typename SuperMeta1,typename TagList1,
-  typename SuperMeta2,typename TagList2
->
-bool operator<=(
-  const random_access_index<SuperMeta1,TagList1>& x,
-  const random_access_index<SuperMeta2,TagList2>& y);
-
-template<typename SuperMeta,typename TagList>
-void swap(
-  random_access_index<SuperMeta,TagList>& x,
-  random_access_index<SuperMeta,TagList>& y);
-
-} /* namespace multi_index::detail */
-
-/* index specifiers */
-
-template <typename TagList=tag<> >
-struct random_access;
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/ranked_index.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/ranked_index.hpp
deleted file mode 100644
index 4b24c4f5937..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/ranked_index.hpp
+++ /dev/null
@@ -1,382 +0,0 @@
-/* Copyright 2003-2017 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_RANKED_INDEX_HPP
-#define BOOST_MULTI_INDEX_RANKED_INDEX_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <boost/multi_index/detail/ord_index_impl.hpp>
-#include <boost/multi_index/detail/rnk_index_ops.hpp>
-#include <boost/multi_index/ranked_index_fwd.hpp>
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-/* ranked_index augments a given ordered index to provide rank operations */
-
-template<typename OrderedIndexNodeImpl>
-struct ranked_node:OrderedIndexNodeImpl
-{
-  std::size_t size;
-};
-
-template<typename OrderedIndexImpl>
-class ranked_index:public OrderedIndexImpl
-{
-  typedef          OrderedIndexImpl         super;
-
-protected:
-  typedef typename super::node_type         node_type;
-  typedef typename super::node_impl_pointer node_impl_pointer;
-
-public:
-  typedef typename super::ctor_args_list ctor_args_list;
-  typedef typename super::allocator_type allocator_type;
-  typedef typename super::iterator       iterator;
-
-  /* rank operations */
-
-  iterator nth(std::size_t n)const
-  {
-    return this->make_iterator(node_type::from_impl(
-      ranked_index_nth(n,this->header()->impl())));
-  }
-
-  std::size_t rank(iterator position)const
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
-
-    return ranked_index_rank(
-      position.get_node()->impl(),this->header()->impl());
-  }
-
-  template<typename CompatibleKey>
-  std::size_t find_rank(const CompatibleKey& x)const
-  {
-    return ranked_index_find_rank(
-      this->root(),this->header(),this->key,x,this->comp_);
-  }
-
-  template<typename CompatibleKey,typename CompatibleCompare>
-  std::size_t find_rank(
-    const CompatibleKey& x,const CompatibleCompare& comp)const
-  {
-    return ranked_index_find_rank(
-      this->root(),this->header(),this->key,x,comp);
-  }
-
-  template<typename CompatibleKey>
-  std::size_t lower_bound_rank(const CompatibleKey& x)const
-  {
-    return ranked_index_lower_bound_rank(
-      this->root(),this->header(),this->key,x,this->comp_);
-  }
-
-  template<typename CompatibleKey,typename CompatibleCompare>
-  std::size_t lower_bound_rank(
-    const CompatibleKey& x,const CompatibleCompare& comp)const
-  {
-    return ranked_index_lower_bound_rank(
-      this->root(),this->header(),this->key,x,comp);
-  }
-
-  template<typename CompatibleKey>
-  std::size_t upper_bound_rank(const CompatibleKey& x)const
-  {
-    return ranked_index_upper_bound_rank(
-      this->root(),this->header(),this->key,x,this->comp_);
-  }
-
-  template<typename CompatibleKey,typename CompatibleCompare>
-  std::size_t upper_bound_rank(
-    const CompatibleKey& x,const CompatibleCompare& comp)const
-  {
-    return ranked_index_upper_bound_rank(
-      this->root(),this->header(),this->key,x,comp);
-  }
-
-  template<typename CompatibleKey>
-  std::pair<std::size_t,std::size_t> equal_range_rank(
-    const CompatibleKey& x)const
-  {
-    return ranked_index_equal_range_rank(
-      this->root(),this->header(),this->key,x,this->comp_);
-  }
-
-  template<typename CompatibleKey,typename CompatibleCompare>
-  std::pair<std::size_t,std::size_t> equal_range_rank(
-    const CompatibleKey& x,const CompatibleCompare& comp)const
-  {
-    return ranked_index_equal_range_rank(
-      this->root(),this->header(),this->key,x,comp);
-  }
-
-  template<typename LowerBounder,typename UpperBounder>
-  std::pair<std::size_t,std::size_t>
-  range_rank(LowerBounder lower,UpperBounder upper)const
-  {
-    typedef typename mpl::if_<
-      is_same<LowerBounder,unbounded_type>,
-      BOOST_DEDUCED_TYPENAME mpl::if_<
-        is_same<UpperBounder,unbounded_type>,
-        both_unbounded_tag,
-        lower_unbounded_tag
-      >::type,
-      BOOST_DEDUCED_TYPENAME mpl::if_<
-        is_same<UpperBounder,unbounded_type>,
-        upper_unbounded_tag,
-        none_unbounded_tag
-      >::type
-    >::type dispatch;
-
-    return range_rank(lower,upper,dispatch());
-  }
-
-protected:
-  ranked_index(const ranked_index& x):super(x){};
-
-  ranked_index(const ranked_index& x,do_not_copy_elements_tag):
-    super(x,do_not_copy_elements_tag()){};
-
-  ranked_index(
-    const ctor_args_list& args_list,const allocator_type& al):
-    super(args_list,al){}
-
-private:
-  template<typename LowerBounder,typename UpperBounder>
-  std::pair<std::size_t,std::size_t>
-  range_rank(LowerBounder lower,UpperBounder upper,none_unbounded_tag)const
-  {
-    node_type* y=this->header();
-    node_type* z=this->root();
-
-    if(!z)return std::pair<std::size_t,std::size_t>(0,0);
-
-    std::size_t s=z->impl()->size;
-
-    do{
-      if(!lower(this->key(z->value()))){
-        z=node_type::from_impl(z->right());
-      }
-      else if(!upper(this->key(z->value()))){
-        y=z;
-        s-=ranked_node_size(y->right())+1;
-        z=node_type::from_impl(z->left());
-      }
-      else{
-        return std::pair<std::size_t,std::size_t>(
-          s-z->impl()->size+
-            lower_range_rank(node_type::from_impl(z->left()),z,lower),
-          s-ranked_node_size(z->right())+
-            upper_range_rank(node_type::from_impl(z->right()),y,upper));
-      }
-    }while(z);
-
-    return std::pair<std::size_t,std::size_t>(s,s);
-  }
-
-  template<typename LowerBounder,typename UpperBounder>
-  std::pair<std::size_t,std::size_t>
-  range_rank(LowerBounder,UpperBounder upper,lower_unbounded_tag)const
-  {
-    return std::pair<std::size_t,std::size_t>(
-      0,
-      upper_range_rank(this->root(),this->header(),upper));
-  }
-
-  template<typename LowerBounder,typename UpperBounder>
-  std::pair<std::size_t,std::size_t>
-  range_rank(LowerBounder lower,UpperBounder,upper_unbounded_tag)const
-  {
-    return std::pair<std::size_t,std::size_t>(
-      lower_range_rank(this->root(),this->header(),lower),
-      this->size());
-  }
-
-  template<typename LowerBounder,typename UpperBounder>
-  std::pair<std::size_t,std::size_t>
-  range_rank(LowerBounder,UpperBounder,both_unbounded_tag)const
-  {
-    return std::pair<std::size_t,std::size_t>(0,this->size());
-  }
-
-  template<typename LowerBounder>
-  std::size_t
-  lower_range_rank(node_type* top,node_type* y,LowerBounder lower)const
-  {
-    if(!top)return 0;
-
-    std::size_t s=top->impl()->size;
-
-    do{
-      if(lower(this->key(top->value()))){
-        y=top;
-        s-=ranked_node_size(y->right())+1;
-        top=node_type::from_impl(top->left());
-      }
-      else top=node_type::from_impl(top->right());
-    }while(top);
-
-    return s;
-  }
-
-  template<typename UpperBounder>
-  std::size_t
-  upper_range_rank(node_type* top,node_type* y,UpperBounder upper)const
-  {
-    if(!top)return 0;
-
-    std::size_t s=top->impl()->size;
-
-    do{
-      if(!upper(this->key(top->value()))){
-        y=top;
-        s-=ranked_node_size(y->right())+1;
-        top=node_type::from_impl(top->left());
-      }
-      else top=node_type::from_impl(top->right());
-    }while(top);
-
-    return s;
-  }
-};
-
-/* augmenting policy for ordered_index */
-
-struct rank_policy
-{
-  template<typename OrderedIndexNodeImpl>
-  struct augmented_node
-  {
-    typedef ranked_node<OrderedIndexNodeImpl> type;
-  };
-
-  template<typename OrderedIndexImpl>
-  struct augmented_interface
-  {
-    typedef ranked_index<OrderedIndexImpl> type;
-  };
-
-  /* algorithmic stuff */
-
-  template<typename Pointer>
-  static void add(Pointer x,Pointer root)
-  {
-    x->size=1;
-    while(x!=root){
-      x=x->parent();
-      ++(x->size);
-    }
-  }
-
-  template<typename Pointer>
-  static void remove(Pointer x,Pointer root)
-  {
-    while(x!=root){
-      x=x->parent();
-      --(x->size);
-    }
-  }
-
-  template<typename Pointer>
-  static void copy(Pointer x,Pointer y)
-  {
-    y->size=x->size;
-  }
-
-  template<typename Pointer>
-  static void rotate_left(Pointer x,Pointer y) /* in: x==y->left() */
-  {
-    y->size=x->size;
-    x->size=ranked_node_size(x->left())+ranked_node_size(x->right())+1;
-  }
-
-  template<typename Pointer>
-  static void rotate_right(Pointer x,Pointer y) /* in: x==y->right() */
-  {
-    rotate_left(x,y);
-  }
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING)
-  /* invariant stuff */
-
-  template<typename Pointer>
-  static bool invariant(Pointer x)
-  {
-    return x->size==ranked_node_size(x->left())+ranked_node_size(x->right())+1;
-  }
-#endif
-};
-
-} /* namespace multi_index::detail */
-
-/* ranked_index specifiers */
-
-template<typename Arg1,typename Arg2,typename Arg3>
-struct ranked_unique
-{
-  typedef typename detail::ordered_index_args<
-    Arg1,Arg2,Arg3>                                index_args;
-  typedef typename index_args::tag_list_type::type tag_list_type;
-  typedef typename index_args::key_from_value_type key_from_value_type;
-  typedef typename index_args::compare_type        compare_type;
-
-  template<typename Super>
-  struct node_class
-  {
-    typedef detail::ordered_index_node<detail::rank_policy,Super> type;
-  };
-
-  template<typename SuperMeta>
-  struct index_class
-  {
-    typedef detail::ordered_index<
-      key_from_value_type,compare_type,
-      SuperMeta,tag_list_type,detail::ordered_unique_tag,
-      detail::rank_policy>                                type;
-  };
-};
-
-template<typename Arg1,typename Arg2,typename Arg3>
-struct ranked_non_unique
-{
-  typedef detail::ordered_index_args<
-    Arg1,Arg2,Arg3>                                index_args;
-  typedef typename index_args::tag_list_type::type tag_list_type;
-  typedef typename index_args::key_from_value_type key_from_value_type;
-  typedef typename index_args::compare_type        compare_type;
-
-  template<typename Super>
-  struct node_class
-  {
-    typedef detail::ordered_index_node<detail::rank_policy,Super> type;
-  };
-
-  template<typename SuperMeta>
-  struct index_class
-  {
-    typedef detail::ordered_index<
-      key_from_value_type,compare_type,
-      SuperMeta,tag_list_type,detail::ordered_non_unique_tag,
-      detail::rank_policy>                                    type;
-  };
-};
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/ranked_index_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/ranked_index_fwd.hpp
deleted file mode 100644
index 380d3480736..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/ranked_index_fwd.hpp
+++ /dev/null
@@ -1,35 +0,0 @@
-/* Copyright 2003-2015 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_RANKED_INDEX_FWD_HPP
-#define BOOST_MULTI_INDEX_RANKED_INDEX_FWD_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/multi_index/detail/ord_index_args.hpp>
-#include <boost/multi_index/detail/ord_index_impl_fwd.hpp>
-
-namespace boost{
-
-namespace multi_index{
-
-/* ranked_index specifiers */
-
-template<typename Arg1,typename Arg2=mpl::na,typename Arg3=mpl::na>
-struct ranked_unique;
-
-template<typename Arg1,typename Arg2=mpl::na,typename Arg3=mpl::na>
-struct ranked_non_unique;
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/safe_mode_errors.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/safe_mode_errors.hpp
deleted file mode 100644
index 1904706edec..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/safe_mode_errors.hpp
+++ /dev/null
@@ -1,48 +0,0 @@
-/* Copyright 2003-2013 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_SAFE_MODE_ERRORS_HPP
-#define BOOST_MULTI_INDEX_SAFE_MODE_ERRORS_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-namespace boost{
-
-namespace multi_index{
-
-namespace safe_mode{
-
-/* Error codes for Boost.MultiIndex safe mode. These go in a separate
- * header so that the user can include it when redefining
- * BOOST_MULTI_INDEX_SAFE_MODE_ASSERT prior to the inclusion of
- * any other header of Boost.MultiIndex.
- */
-
-enum error_code
-{
-  invalid_iterator=0,
-  not_dereferenceable_iterator,
-  not_incrementable_iterator,
-  not_decrementable_iterator,
-  not_owner,
-  not_same_owner,
-  invalid_range,
-  inside_range,
-  out_of_bounds,
-  same_container
-};
-
-} /* namespace multi_index::safe_mode */
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/sequenced_index.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/sequenced_index.hpp
deleted file mode 100644
index 424eebc376d..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/sequenced_index.hpp
+++ /dev/null
@@ -1,1062 +0,0 @@
-/* Copyright 2003-2015 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_SEQUENCED_INDEX_HPP
-#define BOOST_MULTI_INDEX_SEQUENCED_INDEX_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <boost/bind.hpp>
-#include <boost/call_traits.hpp>
-#include <boost/detail/allocator_utilities.hpp>
-#include <boost/detail/no_exceptions_support.hpp>
-#include <boost/detail/workaround.hpp>
-#include <boost/foreach_fwd.hpp>
-#include <boost/iterator/reverse_iterator.hpp>
-#include <boost/move/core.hpp>
-#include <boost/move/utility.hpp>
-#include <boost/mpl/bool.hpp>
-#include <boost/mpl/not.hpp>
-#include <boost/mpl/push_front.hpp>
-#include <boost/multi_index/detail/access_specifier.hpp>
-#include <boost/multi_index/detail/bidir_node_iterator.hpp>
-#include <boost/multi_index/detail/do_not_copy_elements_tag.hpp>
-#include <boost/multi_index/detail/index_node_base.hpp>
-#include <boost/multi_index/detail/safe_mode.hpp>
-#include <boost/multi_index/detail/scope_guard.hpp>
-#include <boost/multi_index/detail/seq_index_node.hpp>
-#include <boost/multi_index/detail/seq_index_ops.hpp>
-#include <boost/multi_index/detail/vartempl_support.hpp>
-#include <boost/multi_index/sequenced_index_fwd.hpp>
-#include <boost/tuple/tuple.hpp>
-#include <boost/type_traits/is_integral.hpp>
-#include <cstddef>
-#include <functional>
-#include <utility>
-
-#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
-#include<initializer_list>
-#endif
-
-#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
-#include <boost/bind.hpp>
-#endif
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING)
-#define BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT_OF(x)                    \
-  detail::scope_guard BOOST_JOIN(check_invariant_,__LINE__)=                 \
-    detail::make_obj_guard(x,&sequenced_index::check_invariant_);            \
-  BOOST_JOIN(check_invariant_,__LINE__).touch();
-#define BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT                          \
-  BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT_OF(*this)
-#else
-#define BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT_OF(x)
-#define BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT
-#endif
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-/* sequenced_index adds a layer of sequenced indexing to a given Super */
-
-template<typename SuperMeta,typename TagList>
-class sequenced_index:
-  BOOST_MULTI_INDEX_PROTECTED_IF_MEMBER_TEMPLATE_FRIENDS SuperMeta::type
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-  ,public safe_mode::safe_container<
-    sequenced_index<SuperMeta,TagList> >
-#endif
-
-{ 
-#if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING)&&\
-    BOOST_WORKAROUND(__MWERKS__,<=0x3003)
-/* The "ISO C++ Template Parser" option in CW8.3 has a problem with the
- * lifetime of const references bound to temporaries --precisely what
- * scopeguards are.
- */
-
-#pragma parse_mfunc_templ off
-#endif
-
-  typedef typename SuperMeta::type                    super;
-
-protected:
-  typedef sequenced_index_node<
-    typename super::node_type>                        node_type;
-
-private:
-  typedef typename node_type::impl_type               node_impl_type;
- 
-public:
-  /* types */
-
-  typedef typename node_type::value_type              value_type;
-  typedef tuples::null_type                           ctor_args;
-  typedef typename super::final_allocator_type        allocator_type;
-  typedef typename allocator_type::reference          reference;
-  typedef typename allocator_type::const_reference    const_reference;
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-  typedef safe_mode::safe_iterator<
-    bidir_node_iterator<node_type>,
-    sequenced_index>                                  iterator;
-#else
-  typedef bidir_node_iterator<node_type>              iterator;
-#endif
-
-  typedef iterator                                    const_iterator;
-
-  typedef std::size_t                                 size_type;      
-  typedef std::ptrdiff_t                              difference_type;
-  typedef typename allocator_type::pointer            pointer;
-  typedef typename allocator_type::const_pointer      const_pointer;
-  typedef typename
-    boost::reverse_iterator<iterator>                 reverse_iterator;
-  typedef typename
-    boost::reverse_iterator<const_iterator>           const_reverse_iterator;
-  typedef TagList                                     tag_list;
-
-protected:
-  typedef typename super::final_node_type     final_node_type;
-  typedef tuples::cons<
-    ctor_args, 
-    typename super::ctor_args_list>           ctor_args_list;
-  typedef typename mpl::push_front<
-    typename super::index_type_list,
-    sequenced_index>::type                    index_type_list;
-  typedef typename mpl::push_front<
-    typename super::iterator_type_list,
-    iterator>::type                           iterator_type_list;
-  typedef typename mpl::push_front<
-    typename super::const_iterator_type_list,
-    const_iterator>::type                     const_iterator_type_list;
-  typedef typename super::copy_map_type       copy_map_type;
-
-#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
-  typedef typename super::index_saver_type    index_saver_type;
-  typedef typename super::index_loader_type   index_loader_type;
-#endif
-
-private:
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-  typedef safe_mode::safe_container<
-    sequenced_index>                          safe_super;
-#endif
-
-  typedef typename call_traits<value_type>::param_type value_param_type;
-
-  /* Needed to avoid commas in BOOST_MULTI_INDEX_OVERLOADS_TO_VARTEMPL
-   * expansion.
-   */
-
-  typedef std::pair<iterator,bool>                     emplace_return_type;
-
-public:
-
-  /* construct/copy/destroy
-   * Default and copy ctors are in the protected section as indices are
-   * not supposed to be created on their own. No range ctor either.
-   */
-
-  sequenced_index<SuperMeta,TagList>& operator=(
-    const sequenced_index<SuperMeta,TagList>& x)
-  {
-    this->final()=x.final();
-    return *this;
-  }
-
-#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
-  sequenced_index<SuperMeta,TagList>& operator=(
-    std::initializer_list<value_type> list)
-  {
-    this->final()=list;
-    return *this;
-  }
-#endif
-
-  template <class InputIterator>
-  void assign(InputIterator first,InputIterator last)
-  {
-    assign_iter(first,last,mpl::not_<is_integral<InputIterator> >());
-  }
-
-#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
-  void assign(std::initializer_list<value_type> list)
-  {
-    assign(list.begin(),list.end());
-  }
-#endif
-
-  void assign(size_type n,value_param_type value)
-  {
-    BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT;
-    clear();
-    for(size_type i=0;i<n;++i)push_back(value);
-  }
-    
-  allocator_type get_allocator()const BOOST_NOEXCEPT
-  {
-    return this->final().get_allocator();
-  }
-
-  /* iterators */
-
-  iterator  begin()BOOST_NOEXCEPT
-    {return make_iterator(node_type::from_impl(header()->next()));}
-  const_iterator begin()const BOOST_NOEXCEPT
-    {return make_iterator(node_type::from_impl(header()->next()));}
-  iterator
-    end()BOOST_NOEXCEPT{return make_iterator(header());}
-  const_iterator
-    end()const BOOST_NOEXCEPT{return make_iterator(header());}
-  reverse_iterator
-    rbegin()BOOST_NOEXCEPT{return boost::make_reverse_iterator(end());}
-  const_reverse_iterator
-    rbegin()const BOOST_NOEXCEPT{return boost::make_reverse_iterator(end());}
-  reverse_iterator
-    rend()BOOST_NOEXCEPT{return boost::make_reverse_iterator(begin());}
-  const_reverse_iterator
-    rend()const BOOST_NOEXCEPT{return boost::make_reverse_iterator(begin());}
-  const_iterator
-    cbegin()const BOOST_NOEXCEPT{return begin();}
-  const_iterator
-    cend()const BOOST_NOEXCEPT{return end();}
-  const_reverse_iterator
-    crbegin()const BOOST_NOEXCEPT{return rbegin();}
-  const_reverse_iterator
-    crend()const BOOST_NOEXCEPT{return rend();}
-
-  iterator iterator_to(const value_type& x)
-  {
-    return make_iterator(node_from_value<node_type>(&x));
-  }
-
-  const_iterator iterator_to(const value_type& x)const
-  {
-    return make_iterator(node_from_value<node_type>(&x));
-  }
-
-  /* capacity */
-
-  bool      empty()const BOOST_NOEXCEPT{return this->final_empty_();}
-  size_type size()const BOOST_NOEXCEPT{return this->final_size_();}
-  size_type max_size()const BOOST_NOEXCEPT{return this->final_max_size_();}
-
-  void resize(size_type n)
-  {
-    BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT;
-    if(n>size()){
-      for(size_type m=n-size();m--;)
-        this->final_emplace_(BOOST_MULTI_INDEX_NULL_PARAM_PACK);
-    }
-    else if(n<size()){for(size_type m=size()-n;m--;)pop_back();}
-  }
-
-  void resize(size_type n,value_param_type x)
-  {
-    BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT;
-    if(n>size())insert(end(),n-size(),x);
-    else if(n<size())for(size_type m=size()-n;m--;)pop_back();
-  }
-
-  /* access: no non-const versions provided as sequenced_index
-   * handles const elements.
-   */
-
-  const_reference front()const{return *begin();}
-  const_reference back()const{return *--end();}
-
-  /* modifiers */
-
-  BOOST_MULTI_INDEX_OVERLOADS_TO_VARTEMPL(
-    emplace_return_type,emplace_front,emplace_front_impl)
-
-  std::pair<iterator,bool> push_front(const value_type& x)
-                             {return insert(begin(),x);}
-  std::pair<iterator,bool> push_front(BOOST_RV_REF(value_type) x)
-                             {return insert(begin(),boost::move(x));}
-  void                     pop_front(){erase(begin());}
-
-  BOOST_MULTI_INDEX_OVERLOADS_TO_VARTEMPL(
-    emplace_return_type,emplace_back,emplace_back_impl)
-
-  std::pair<iterator,bool> push_back(const value_type& x)
-                             {return insert(end(),x);}
-  std::pair<iterator,bool> push_back(BOOST_RV_REF(value_type) x)
-                             {return insert(end(),boost::move(x));}
-  void                     pop_back(){erase(--end());}
-
-  BOOST_MULTI_INDEX_OVERLOADS_TO_VARTEMPL_EXTRA_ARG(
-    emplace_return_type,emplace,emplace_impl,iterator,position)
-
-  std::pair<iterator,bool> insert(iterator position,const value_type& x)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
-    BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT;
-    std::pair<final_node_type*,bool> p=this->final_insert_(x);
-    if(p.second&&position.get_node()!=header()){
-      relink(position.get_node(),p.first);
-    }
-    return std::pair<iterator,bool>(make_iterator(p.first),p.second);
-  }
-
-  std::pair<iterator,bool> insert(iterator position,BOOST_RV_REF(value_type) x)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
-    BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT;
-    std::pair<final_node_type*,bool> p=this->final_insert_rv_(x);
-    if(p.second&&position.get_node()!=header()){
-      relink(position.get_node(),p.first);
-    }
-    return std::pair<iterator,bool>(make_iterator(p.first),p.second);
-  }
-
-  void insert(iterator position,size_type n,value_param_type x)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
-    BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT;
-    for(size_type i=0;i<n;++i)insert(position,x);
-  }
- 
-  template<typename InputIterator>
-  void insert(iterator position,InputIterator first,InputIterator last)
-  {
-    insert_iter(position,first,last,mpl::not_<is_integral<InputIterator> >());
-  }
-
-#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
-  void insert(iterator position,std::initializer_list<value_type> list)
-  {
-    insert(position,list.begin(),list.end());
-  }
-#endif
-
-  iterator erase(iterator position)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
-    BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT;
-    this->final_erase_(static_cast<final_node_type*>(position++.get_node()));
-    return position;
-  }
-  
-  iterator erase(iterator first,iterator last)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(first);
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(last);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(first,*this);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(last,*this);
-    BOOST_MULTI_INDEX_CHECK_VALID_RANGE(first,last);
-    BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT;
-    while(first!=last){
-      first=erase(first);
-    }
-    return first;
-  }
-
-  bool replace(iterator position,const value_type& x)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
-    BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT;
-    return this->final_replace_(
-      x,static_cast<final_node_type*>(position.get_node()));
-  }
-
-  bool replace(iterator position,BOOST_RV_REF(value_type) x)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
-    BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT;
-    return this->final_replace_rv_(
-      x,static_cast<final_node_type*>(position.get_node()));
-  }
-
-  template<typename Modifier>
-  bool modify(iterator position,Modifier mod)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
-    BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT;
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-    /* MSVC++ 6.0 optimizer on safe mode code chokes if this
-     * this is not added. Left it for all compilers as it does no
-     * harm.
-     */
-
-    position.detach();
-#endif
-
-    return this->final_modify_(
-      mod,static_cast<final_node_type*>(position.get_node()));
-  }
-
-  template<typename Modifier,typename Rollback>
-  bool modify(iterator position,Modifier mod,Rollback back_)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
-    BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT;
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-    /* MSVC++ 6.0 optimizer on safe mode code chokes if this
-     * this is not added. Left it for all compilers as it does no
-     * harm.
-     */
-
-    position.detach();
-#endif
-
-    return this->final_modify_(
-      mod,back_,static_cast<final_node_type*>(position.get_node()));
-  }
-
-  void swap(sequenced_index<SuperMeta,TagList>& x)
-  {
-    BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT;
-    BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT_OF(x);
-    this->final_swap_(x.final());
-  }
-
-  void clear()BOOST_NOEXCEPT
-  {
-    BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT;
-    this->final_clear_();
-  }
-
-  /* list operations */
-
-  void splice(iterator position,sequenced_index<SuperMeta,TagList>& x)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
-    BOOST_MULTI_INDEX_CHECK_DIFFERENT_CONTAINER(*this,x);
-    BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT;
-    iterator first=x.begin(),last=x.end();
-    while(first!=last){
-      if(insert(position,*first).second)first=x.erase(first);
-      else ++first;
-    }
-  }
-
-  void splice(iterator position,sequenced_index<SuperMeta,TagList>& x,iterator i)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(i);
-    BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(i);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(i,x);
-    BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT;
-    if(&x==this){
-      if(position!=i)relink(position.get_node(),i.get_node());
-    }
-    else{
-      if(insert(position,*i).second){
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-    /* MSVC++ 6.0 optimizer has a hard time with safe mode, and the following
-     * workaround is needed. Left it for all compilers as it does no
-     * harm.
-     */
-        i.detach();
-        x.erase(x.make_iterator(i.get_node()));
-#else
-        x.erase(i);
-#endif
-
-      }
-    }
-  }
-
-  void splice(
-    iterator position,sequenced_index<SuperMeta,TagList>& x,
-    iterator first,iterator last)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(first);
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(last);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(first,x);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(last,x);
-    BOOST_MULTI_INDEX_CHECK_VALID_RANGE(first,last);
-    BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT;
-    if(&x==this){
-      BOOST_MULTI_INDEX_CHECK_OUTSIDE_RANGE(position,first,last);
-      if(position!=last)relink(
-        position.get_node(),first.get_node(),last.get_node());
-    }
-    else{
-      while(first!=last){
-        if(insert(position,*first).second)first=x.erase(first);
-        else ++first;
-      }
-    }
-  }
-
-  void remove(value_param_type value)
-  {
-    sequenced_index_remove(
-      *this,
-      ::boost::bind(std::equal_to<value_type>(),::boost::arg<1>(),value));
-  }
-
-  template<typename Predicate>
-  void remove_if(Predicate pred)
-  {
-    sequenced_index_remove(*this,pred);
-  }
-
-  void unique()
-  {
-    sequenced_index_unique(*this,std::equal_to<value_type>());
-  }
-
-  template <class BinaryPredicate>
-  void unique(BinaryPredicate binary_pred)
-  {
-    sequenced_index_unique(*this,binary_pred);
-  }
-
-  void merge(sequenced_index<SuperMeta,TagList>& x)
-  {
-    sequenced_index_merge(*this,x,std::less<value_type>());
-  }
-
-  template <typename Compare>
-  void merge(sequenced_index<SuperMeta,TagList>& x,Compare comp)
-  {
-    sequenced_index_merge(*this,x,comp);
-  }
-
-  void sort()
-  {
-    BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT;
-    sequenced_index_sort(header(),std::less<value_type>());
-  }
-
-  template <typename Compare>
-  void sort(Compare comp)
-  {
-    BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT;
-    sequenced_index_sort(header(),comp);
-  }
-
-  void reverse()BOOST_NOEXCEPT
-  {
-    BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT;
-    node_impl_type::reverse(header()->impl());
-  }
-
-  /* rearrange operations */
-
-  void relocate(iterator position,iterator i)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(i);
-    BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(i);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(i,*this);
-    BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT;
-    if(position!=i)relink(position.get_node(),i.get_node());
-  }
-
-  void relocate(iterator position,iterator first,iterator last)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(first);
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(last);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(first,*this);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(last,*this);
-    BOOST_MULTI_INDEX_CHECK_VALID_RANGE(first,last);
-    BOOST_MULTI_INDEX_CHECK_OUTSIDE_RANGE(position,first,last);
-    BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT;
-    if(position!=last)relink(
-      position.get_node(),first.get_node(),last.get_node());
-  }
-    
-  template<typename InputIterator>
-  void rearrange(InputIterator first)
-  {
-    BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT;
-    node_type* pos=header();
-    for(size_type s=size();s--;){
-      const value_type& v=*first++;
-      relink(pos,node_from_value<node_type>(&v));
-    }
-  }
-
-BOOST_MULTI_INDEX_PROTECTED_IF_MEMBER_TEMPLATE_FRIENDS:
-  sequenced_index(const ctor_args_list& args_list,const allocator_type& al):
-    super(args_list.get_tail(),al)
-  {
-    empty_initialize();
-  }
-
-  sequenced_index(const sequenced_index<SuperMeta,TagList>& x):
-    super(x)
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-    ,safe_super()
-#endif
-
-  {
-    /* the actual copying takes place in subsequent call to copy_() */
-  }
-
-  sequenced_index(
-    const sequenced_index<SuperMeta,TagList>& x,do_not_copy_elements_tag):
-    super(x,do_not_copy_elements_tag())
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-    ,safe_super()
-#endif
-
-  {
-    empty_initialize();
-  }
-
-  ~sequenced_index()
-  {
-    /* the container is guaranteed to be empty by now */
-  }
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-  iterator       make_iterator(node_type* node){return iterator(node,this);}
-  const_iterator make_iterator(node_type* node)const
-    {return const_iterator(node,const_cast<sequenced_index*>(this));}
-#else
-  iterator       make_iterator(node_type* node){return iterator(node);}
-  const_iterator make_iterator(node_type* node)const
-                   {return const_iterator(node);}
-#endif
-
-  void copy_(
-    const sequenced_index<SuperMeta,TagList>& x,const copy_map_type& map)
-  {
-    node_type* org=x.header();
-    node_type* cpy=header();
-    do{
-      node_type* next_org=node_type::from_impl(org->next());
-      node_type* next_cpy=map.find(static_cast<final_node_type*>(next_org));
-      cpy->next()=next_cpy->impl();
-      next_cpy->prior()=cpy->impl();
-      org=next_org;
-      cpy=next_cpy;
-    }while(org!=x.header());
-
-    super::copy_(x,map);
-  }
-
-  template<typename Variant>
-  final_node_type* insert_(
-    value_param_type v,final_node_type*& x,Variant variant)
-  {
-    final_node_type* res=super::insert_(v,x,variant);
-    if(res==x)link(static_cast<node_type*>(x));
-    return res;
-  }
-
-  template<typename Variant>
-  final_node_type* insert_(
-    value_param_type v,node_type* position,final_node_type*& x,Variant variant)
-  {
-    final_node_type* res=super::insert_(v,position,x,variant);
-    if(res==x)link(static_cast<node_type*>(x));
-    return res;
-  }
-
-  void erase_(node_type* x)
-  {
-    unlink(x);
-    super::erase_(x);
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-    detach_iterators(x);
-#endif
-  }
-
-  void delete_all_nodes_()
-  {
-    for(node_type* x=node_type::from_impl(header()->next());x!=header();){
-      node_type* y=node_type::from_impl(x->next());
-      this->final_delete_node_(static_cast<final_node_type*>(x));
-      x=y;
-    }
-  }
-
-  void clear_()
-  {
-    super::clear_();
-    empty_initialize();
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-    safe_super::detach_dereferenceable_iterators();
-#endif
-  }
-
-  void swap_(sequenced_index<SuperMeta,TagList>& x)
-  {
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-    safe_super::swap(x);
-#endif
-
-    super::swap_(x);
-  }
-
-  void swap_elements_(sequenced_index<SuperMeta,TagList>& x)
-  {
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-    safe_super::swap(x);
-#endif
-
-    super::swap_elements_(x);
-  }
-
-  template<typename Variant>
-  bool replace_(value_param_type v,node_type* x,Variant variant)
-  {
-    return super::replace_(v,x,variant);
-  }
-
-  bool modify_(node_type* x)
-  {
-    BOOST_TRY{
-      if(!super::modify_(x)){
-        unlink(x);
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-        detach_iterators(x);
-#endif
-
-        return false;
-      }
-      else return true;
-    }
-    BOOST_CATCH(...){
-      unlink(x);
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-      detach_iterators(x);
-#endif
-
-      BOOST_RETHROW;
-    }
-    BOOST_CATCH_END
-  }
-
-  bool modify_rollback_(node_type* x)
-  {
-    return super::modify_rollback_(x);
-  }
-
-#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
-  /* serialization */
-
-  template<typename Archive>
-  void save_(
-    Archive& ar,const unsigned int version,const index_saver_type& sm)const
-  {
-    sm.save(begin(),end(),ar,version);
-    super::save_(ar,version,sm);
-  }
-
-  template<typename Archive>
-  void load_(
-    Archive& ar,const unsigned int version,const index_loader_type& lm)
-  {
-    lm.load(
-      ::boost::bind(
-        &sequenced_index::rearranger,this,::boost::arg<1>(),::boost::arg<2>()),
-      ar,version);
-    super::load_(ar,version,lm);
-  }
-#endif
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING)
-  /* invariant stuff */
-
-  bool invariant_()const
-  {
-    if(size()==0||begin()==end()){
-      if(size()!=0||begin()!=end()||
-         header()->next()!=header()->impl()||
-         header()->prior()!=header()->impl())return false;
-    }
-    else{
-      size_type s=0;
-      for(const_iterator it=begin(),it_end=end();it!=it_end;++it,++s){
-        if(it.get_node()->next()->prior()!=it.get_node()->impl())return false;
-        if(it.get_node()->prior()->next()!=it.get_node()->impl())return false;
-      }
-      if(s!=size())return false;
-    }
-
-    return super::invariant_();
-  }
-
-  /* This forwarding function eases things for the boost::mem_fn construct
-   * in BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT. Actually,
-   * final_check_invariant is already an inherited member function of index.
-   */
-  void check_invariant_()const{this->final_check_invariant_();}
-#endif
-
-private:
-  node_type* header()const{return this->final_header();}
-
-  void empty_initialize()
-  {
-    header()->prior()=header()->next()=header()->impl();
-  }
-
-  void link(node_type* x)
-  {
-    node_impl_type::link(x->impl(),header()->impl());
-  };
-
-  static void unlink(node_type* x)
-  {
-    node_impl_type::unlink(x->impl());
-  }
-
-  static void relink(node_type* position,node_type* x)
-  {
-    node_impl_type::relink(position->impl(),x->impl());
-  }
-
-  static void relink(node_type* position,node_type* first,node_type* last)
-  {
-    node_impl_type::relink(
-      position->impl(),first->impl(),last->impl());
-  }
-
-#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
-  void rearranger(node_type* position,node_type *x)
-  {
-    if(!position)position=header();
-    node_type::increment(position);
-    if(position!=x)relink(position,x);
-  }
-#endif
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-  void detach_iterators(node_type* x)
-  {
-    iterator it=make_iterator(x);
-    safe_mode::detach_equivalent_iterators(it);
-  }
-#endif
-
-  template <class InputIterator>
-  void assign_iter(InputIterator first,InputIterator last,mpl::true_)
-  {
-    BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT;
-    clear();
-    for(;first!=last;++first)this->final_insert_ref_(*first);
-  }
-
-  void assign_iter(size_type n,value_param_type value,mpl::false_)
-  {
-    BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT;
-    clear();
-    for(size_type i=0;i<n;++i)push_back(value);
-  }
-
-  template<typename InputIterator>
-  void insert_iter(
-    iterator position,InputIterator first,InputIterator last,mpl::true_)
-  {
-    BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT;
-    for(;first!=last;++first){
-      std::pair<final_node_type*,bool> p=
-        this->final_insert_ref_(*first);
-      if(p.second&&position.get_node()!=header()){
-        relink(position.get_node(),p.first);
-      }
-    }
-  }
-
-  void insert_iter(
-    iterator position,size_type n,value_param_type x,mpl::false_)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
-    BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT;
-    for(size_type i=0;i<n;++i)insert(position,x);
-  }
-
-  template<BOOST_MULTI_INDEX_TEMPLATE_PARAM_PACK>
-  std::pair<iterator,bool> emplace_front_impl(
-    BOOST_MULTI_INDEX_FUNCTION_PARAM_PACK)
-  {
-    return emplace_impl(begin(),BOOST_MULTI_INDEX_FORWARD_PARAM_PACK);
-  }
-
-  template<BOOST_MULTI_INDEX_TEMPLATE_PARAM_PACK>
-  std::pair<iterator,bool> emplace_back_impl(
-    BOOST_MULTI_INDEX_FUNCTION_PARAM_PACK)
-  {
-    return emplace_impl(end(),BOOST_MULTI_INDEX_FORWARD_PARAM_PACK);
-  }
-
-  template<BOOST_MULTI_INDEX_TEMPLATE_PARAM_PACK>
-  std::pair<iterator,bool> emplace_impl(
-    iterator position,BOOST_MULTI_INDEX_FUNCTION_PARAM_PACK)
-  {
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
-    BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT;
-    std::pair<final_node_type*,bool> p=
-      this->final_emplace_(BOOST_MULTI_INDEX_FORWARD_PARAM_PACK);
-    if(p.second&&position.get_node()!=header()){
-      relink(position.get_node(),p.first);
-    }
-    return std::pair<iterator,bool>(make_iterator(p.first),p.second);
-  }
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING)&&\
-    BOOST_WORKAROUND(__MWERKS__,<=0x3003)
-#pragma parse_mfunc_templ reset
-#endif
-};
-
-/* comparison */
-
-template<
-  typename SuperMeta1,typename TagList1,
-  typename SuperMeta2,typename TagList2
->
-bool operator==(
-  const sequenced_index<SuperMeta1,TagList1>& x,
-  const sequenced_index<SuperMeta2,TagList2>& y)
-{
-  return x.size()==y.size()&&std::equal(x.begin(),x.end(),y.begin());
-}
-
-template<
-  typename SuperMeta1,typename TagList1,
-  typename SuperMeta2,typename TagList2
->
-bool operator<(
-  const sequenced_index<SuperMeta1,TagList1>& x,
-  const sequenced_index<SuperMeta2,TagList2>& y)
-{
-  return std::lexicographical_compare(x.begin(),x.end(),y.begin(),y.end());
-}
-
-template<
-  typename SuperMeta1,typename TagList1,
-  typename SuperMeta2,typename TagList2
->
-bool operator!=(
-  const sequenced_index<SuperMeta1,TagList1>& x,
-  const sequenced_index<SuperMeta2,TagList2>& y)
-{
-  return !(x==y);
-}
-
-template<
-  typename SuperMeta1,typename TagList1,
-  typename SuperMeta2,typename TagList2
->
-bool operator>(
-  const sequenced_index<SuperMeta1,TagList1>& x,
-  const sequenced_index<SuperMeta2,TagList2>& y)
-{
-  return y<x;
-}
-
-template<
-  typename SuperMeta1,typename TagList1,
-  typename SuperMeta2,typename TagList2
->
-bool operator>=(
-  const sequenced_index<SuperMeta1,TagList1>& x,
-  const sequenced_index<SuperMeta2,TagList2>& y)
-{
-  return !(x<y);
-}
-
-template<
-  typename SuperMeta1,typename TagList1,
-  typename SuperMeta2,typename TagList2
->
-bool operator<=(
-  const sequenced_index<SuperMeta1,TagList1>& x,
-  const sequenced_index<SuperMeta2,TagList2>& y)
-{
-  return !(x>y);
-}
-
-/*  specialized algorithms */
-
-template<typename SuperMeta,typename TagList>
-void swap(
-  sequenced_index<SuperMeta,TagList>& x,
-  sequenced_index<SuperMeta,TagList>& y)
-{
-  x.swap(y);
-}
-
-} /* namespace multi_index::detail */
-
-/* sequenced index specifier */
-
-template <typename TagList>
-struct sequenced
-{
-  BOOST_STATIC_ASSERT(detail::is_tag<TagList>::value);
-
-  template<typename Super>
-  struct node_class
-  {
-    typedef detail::sequenced_index_node<Super> type;
-  };
-
-  template<typename SuperMeta>
-  struct index_class
-  {
-    typedef detail::sequenced_index<SuperMeta,typename TagList::type> type;
-  };
-};
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-/* Boost.Foreach compatibility */
-
-template<typename SuperMeta,typename TagList>
-inline boost::mpl::true_* boost_foreach_is_noncopyable(
-  boost::multi_index::detail::sequenced_index<SuperMeta,TagList>*&,
-  boost_foreach_argument_dependent_lookup_hack)
-{
-  return 0;
-}
-
-#undef BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT
-#undef BOOST_MULTI_INDEX_SEQ_INDEX_CHECK_INVARIANT_OF
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/sequenced_index_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/sequenced_index_fwd.hpp
deleted file mode 100644
index a019f2a6d2f..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/sequenced_index_fwd.hpp
+++ /dev/null
@@ -1,91 +0,0 @@
-/* Copyright 2003-2013 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_SEQUENCED_INDEX_FWD_HPP
-#define BOOST_MULTI_INDEX_SEQUENCED_INDEX_FWD_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/multi_index/tag.hpp>
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-template<typename SuperMeta,typename TagList>
-class sequenced_index;
-
-template<
-  typename SuperMeta1,typename TagList1,
-  typename SuperMeta2,typename TagList2
->
-bool operator==(
-  const sequenced_index<SuperMeta1,TagList1>& x,
-  const sequenced_index<SuperMeta2,TagList2>& y);
-
-template<
-  typename SuperMeta1,typename TagList1,
-  typename SuperMeta2,typename TagList2
->
-bool operator<(
-  const sequenced_index<SuperMeta1,TagList1>& x,
-  const sequenced_index<SuperMeta2,TagList2>& y);
-
-template<
-  typename SuperMeta1,typename TagList1,
-  typename SuperMeta2,typename TagList2
->
-bool operator!=(
-  const sequenced_index<SuperMeta1,TagList1>& x,
-  const sequenced_index<SuperMeta2,TagList2>& y);
-
-template<
-  typename SuperMeta1,typename TagList1,
-  typename SuperMeta2,typename TagList2
->
-bool operator>(
-  const sequenced_index<SuperMeta1,TagList1>& x,
-  const sequenced_index<SuperMeta2,TagList2>& y);
-
-template<
-  typename SuperMeta1,typename TagList1,
-  typename SuperMeta2,typename TagList2
->
-bool operator>=(
-  const sequenced_index<SuperMeta1,TagList1>& x,
-  const sequenced_index<SuperMeta2,TagList2>& y);
-
-template<
-  typename SuperMeta1,typename TagList1,
-  typename SuperMeta2,typename TagList2
->
-bool operator<=(
-  const sequenced_index<SuperMeta1,TagList1>& x,
-  const sequenced_index<SuperMeta2,TagList2>& y);
-
-template<typename SuperMeta,typename TagList>
-void swap(
-  sequenced_index<SuperMeta,TagList>& x,
-  sequenced_index<SuperMeta,TagList>& y);
-
-} /* namespace multi_index::detail */
-
-/* index specifiers */
-
-template <typename TagList=tag<> >
-struct sequenced;
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index/tag.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index/tag.hpp
deleted file mode 100644
index ce51f8241ee..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index/tag.hpp
+++ /dev/null
@@ -1,88 +0,0 @@
-/* Copyright 2003-2013 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_TAG_HPP
-#define BOOST_MULTI_INDEX_TAG_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <boost/multi_index/detail/no_duplicate_tags.hpp>
-#include <boost/mpl/identity.hpp>
-#include <boost/mpl/transform.hpp>
-#include <boost/mpl/vector.hpp>
-#include <boost/preprocessor/facilities/intercept.hpp> 
-#include <boost/preprocessor/repetition/enum_binary_params.hpp> 
-#include <boost/preprocessor/repetition/enum_params.hpp> 
-#include <boost/static_assert.hpp>
-#include <boost/type_traits/is_base_and_derived.hpp>
-
-/* A wrapper of mpl::vector used to hide MPL from the user.
- * tag contains types used as tag names for indices in get() functions.
- */
-
-/* This user_definable macro limits the number of elements of a tag;
- * useful for shortening resulting symbol names (MSVC++ 6.0, for instance,
- * has problems coping with very long symbol names.)
- */
-
-#if !defined(BOOST_MULTI_INDEX_LIMIT_TAG_SIZE)
-#define BOOST_MULTI_INDEX_LIMIT_TAG_SIZE BOOST_MPL_LIMIT_VECTOR_SIZE
-#endif
-
-#if BOOST_MULTI_INDEX_LIMIT_TAG_SIZE<BOOST_MPL_LIMIT_VECTOR_SIZE
-#define BOOST_MULTI_INDEX_TAG_SIZE BOOST_MULTI_INDEX_LIMIT_TAG_SIZE
-#else
-#define BOOST_MULTI_INDEX_TAG_SIZE BOOST_MPL_LIMIT_VECTOR_SIZE
-#endif
-
-namespace boost{
-
-namespace multi_index{
-
-namespace detail{
-
-struct tag_marker{};
-
-template<typename T>
-struct is_tag
-{
-  BOOST_STATIC_CONSTANT(bool,value=(is_base_and_derived<tag_marker,T>::value));
-};
-
-} /* namespace multi_index::detail */
-
-template<
-  BOOST_PP_ENUM_BINARY_PARAMS(
-    BOOST_MULTI_INDEX_TAG_SIZE,
-    typename T,
-    =mpl::na BOOST_PP_INTERCEPT) 
->
-struct tag:private detail::tag_marker
-{
-  /* The mpl::transform pass produces shorter symbols (without
-   * trailing mpl::na's.)
-   */
-
-  typedef typename mpl::transform<
-    mpl::vector<BOOST_PP_ENUM_PARAMS(BOOST_MULTI_INDEX_TAG_SIZE,T)>,
-    mpl::identity<mpl::_1>
-  >::type type;
-
-  BOOST_STATIC_ASSERT(detail::no_duplicate_tags<type>::value);
-};
-
-} /* namespace multi_index */
-
-} /* namespace boost */
-
-#undef BOOST_MULTI_INDEX_TAG_SIZE
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index_container.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index_container.hpp
deleted file mode 100644
index 9993a8dfa10..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index_container.hpp
+++ /dev/null
@@ -1,1362 +0,0 @@
-/* Multiply indexed container.
- *
- * Copyright 2003-2014 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_HPP
-#define BOOST_MULTI_INDEX_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <algorithm>
-#include <boost/detail/allocator_utilities.hpp>
-#include <boost/detail/no_exceptions_support.hpp>
-#include <boost/detail/workaround.hpp>
-#include <boost/move/core.hpp>
-#include <boost/mpl/at.hpp>
-#include <boost/mpl/contains.hpp>
-#include <boost/mpl/find_if.hpp>
-#include <boost/mpl/identity.hpp>
-#include <boost/mpl/int.hpp>
-#include <boost/mpl/size.hpp>
-#include <boost/mpl/deref.hpp>
-#include <boost/multi_index_container_fwd.hpp>
-#include <boost/multi_index/detail/access_specifier.hpp>
-#include <boost/multi_index/detail/adl_swap.hpp>
-#include <boost/multi_index/detail/base_type.hpp>
-#include <boost/multi_index/detail/do_not_copy_elements_tag.hpp>
-#include <boost/multi_index/detail/converter.hpp>
-#include <boost/multi_index/detail/header_holder.hpp>
-#include <boost/multi_index/detail/has_tag.hpp>
-#include <boost/multi_index/detail/no_duplicate_tags.hpp>
-#include <boost/multi_index/detail/safe_mode.hpp>
-#include <boost/multi_index/detail/scope_guard.hpp>
-#include <boost/multi_index/detail/vartempl_support.hpp>
-#include <boost/static_assert.hpp>
-#include <boost/type_traits/is_same.hpp>
-#include <boost/utility/base_from_member.hpp>
-
-#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
-#include <initializer_list>
-#endif
-
-#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
-#include <boost/multi_index/detail/archive_constructed.hpp>
-#include <boost/multi_index/detail/serialization_version.hpp>
-#include <boost/serialization/collection_size_type.hpp>
-#include <boost/serialization/nvp.hpp>
-#include <boost/serialization/split_member.hpp>
-#include <boost/serialization/version.hpp>
-#include <boost/throw_exception.hpp> 
-#endif
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING)
-#include <boost/multi_index/detail/invariant_assert.hpp>
-#define BOOST_MULTI_INDEX_CHECK_INVARIANT_OF(x)                              \
-  detail::scope_guard BOOST_JOIN(check_invariant_,__LINE__)=                 \
-    detail::make_obj_guard(x,&multi_index_container::check_invariant_);      \
-  BOOST_JOIN(check_invariant_,__LINE__).touch();
-#define BOOST_MULTI_INDEX_CHECK_INVARIANT                                    \
-  BOOST_MULTI_INDEX_CHECK_INVARIANT_OF(*this)
-#else
-#define BOOST_MULTI_INDEX_CHECK_INVARIANT_OF(x)
-#define BOOST_MULTI_INDEX_CHECK_INVARIANT
-#endif
-
-namespace boost{
-
-namespace multi_index{
-
-#if BOOST_WORKAROUND(BOOST_MSVC,BOOST_TESTED_AT(1500))
-#pragma warning(push)
-#pragma warning(disable:4522) /* spurious warning on multiple operator=()'s */
-#endif
-
-template<typename Value,typename IndexSpecifierList,typename Allocator>
-class multi_index_container:
-  private ::boost::base_from_member<
-    typename boost::detail::allocator::rebind_to<
-      Allocator,
-      typename detail::multi_index_node_type<
-        Value,IndexSpecifierList,Allocator>::type
-    >::type>,
-  BOOST_MULTI_INDEX_PRIVATE_IF_MEMBER_TEMPLATE_FRIENDS detail::header_holder<
-    typename boost::detail::allocator::rebind_to<
-      Allocator,
-      typename detail::multi_index_node_type<
-        Value,IndexSpecifierList,Allocator>::type
-    >::type::pointer,
-    multi_index_container<Value,IndexSpecifierList,Allocator> >,
-  public detail::multi_index_base_type<
-    Value,IndexSpecifierList,Allocator>::type
-{
-#if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING)&&\
-    BOOST_WORKAROUND(__MWERKS__,<=0x3003)
-/* The "ISO C++ Template Parser" option in CW8.3 has a problem with the
- * lifetime of const references bound to temporaries --precisely what
- * scopeguards are.
- */
-
-#pragma parse_mfunc_templ off
-#endif
-
-private:
-  BOOST_COPYABLE_AND_MOVABLE(multi_index_container)
-
-#if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
-  template <typename,typename,typename> friend class  detail::index_base;
-  template <typename,typename>          friend struct detail::header_holder;
-  template <typename,typename>          friend struct detail::converter;
-#endif
-
-  typedef typename detail::multi_index_base_type<
-      Value,IndexSpecifierList,Allocator>::type   super;
-  typedef typename
-  boost::detail::allocator::rebind_to<
-    Allocator,
-    typename super::node_type
-  >::type                                         node_allocator;
-  typedef ::boost::base_from_member<
-    node_allocator>                               bfm_allocator;
-  typedef detail::header_holder<
-    typename node_allocator::pointer,
-    multi_index_container>                        bfm_header;
-
-
-public:
-  /* All types are inherited from super, a few are explicitly
-   * brought forward here to save us some typename's.
-   */
-
-  typedef typename super::ctor_args_list           ctor_args_list;
-  typedef IndexSpecifierList                       index_specifier_type_list;
- 
-  typedef typename super::index_type_list          index_type_list;
-
-  typedef typename super::iterator_type_list       iterator_type_list;
-  typedef typename super::const_iterator_type_list const_iterator_type_list;
-  typedef typename super::value_type               value_type;
-  typedef typename super::final_allocator_type     allocator_type;
-  typedef typename super::iterator                 iterator;
-  typedef typename super::const_iterator           const_iterator;
-
-  BOOST_STATIC_ASSERT(
-    detail::no_duplicate_tags_in_index_list<index_type_list>::value);
-
-  /* global project() needs to see this publicly */
-
-  typedef typename super::node_type node_type;
-
-  /* construct/copy/destroy */
-
-  explicit multi_index_container(
-
-#if BOOST_WORKAROUND(__IBMCPP__,<=600)
-    /* VisualAge seems to have an ETI issue with the default values
-     * for arguments args_list and al.
-     */
-
-    const ctor_args_list& args_list=
-      typename mpl::identity<multi_index_container>::type::
-        ctor_args_list(),
-    const allocator_type& al=
-      typename mpl::identity<multi_index_container>::type::
-        allocator_type()):
-#else
-    const ctor_args_list& args_list=ctor_args_list(),
-    const allocator_type& al=allocator_type()):
-#endif
-
-    bfm_allocator(al),
-    super(args_list,bfm_allocator::member),
-    node_count(0)
-  {
-    BOOST_MULTI_INDEX_CHECK_INVARIANT;
-  }
-
-  explicit multi_index_container(const allocator_type& al):
-    bfm_allocator(al),
-    super(ctor_args_list(),bfm_allocator::member),
-    node_count(0)
-  {
-    BOOST_MULTI_INDEX_CHECK_INVARIANT;
-  }
-  
-  template<typename InputIterator>
-  multi_index_container(
-    InputIterator first,InputIterator last,
-
-#if BOOST_WORKAROUND(__IBMCPP__,<=600)
-    /* VisualAge seems to have an ETI issue with the default values
-     * for arguments args_list and al.
-     */
-
-    const ctor_args_list& args_list=
-      typename mpl::identity<multi_index_container>::type::
-        ctor_args_list(),
-    const allocator_type& al=
-      typename mpl::identity<multi_index_container>::type::
-        allocator_type()):
-#else
-    const ctor_args_list& args_list=ctor_args_list(),
-    const allocator_type& al=allocator_type()):
-#endif
-
-    bfm_allocator(al),
-    super(args_list,bfm_allocator::member),
-    node_count(0)
-  {
-    BOOST_MULTI_INDEX_CHECK_INVARIANT;
-    BOOST_TRY{
-      iterator hint=super::end();
-      for(;first!=last;++first){
-        hint=super::make_iterator(
-          insert_ref_(*first,hint.get_node()).first);
-        ++hint;
-      }
-    }
-    BOOST_CATCH(...){
-      clear_();
-      BOOST_RETHROW;
-    }
-    BOOST_CATCH_END
-  }
-
-#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
-  multi_index_container(
-    std::initializer_list<Value> list,
-    const ctor_args_list& args_list=ctor_args_list(),
-    const allocator_type& al=allocator_type()):
-    bfm_allocator(al),
-    super(args_list,bfm_allocator::member),
-    node_count(0)
-  {
-    BOOST_MULTI_INDEX_CHECK_INVARIANT;
-    BOOST_TRY{
-      typedef const Value* init_iterator;
-
-      iterator hint=super::end();
-      for(init_iterator first=list.begin(),last=list.end();
-          first!=last;++first){
-        hint=super::make_iterator(insert_(*first,hint.get_node()).first);
-        ++hint;
-      }
-    }
-    BOOST_CATCH(...){
-      clear_();
-      BOOST_RETHROW;
-    }
-    BOOST_CATCH_END
-  }
-#endif
-
-  multi_index_container(
-    const multi_index_container<Value,IndexSpecifierList,Allocator>& x):
-    bfm_allocator(x.bfm_allocator::member),
-    bfm_header(),
-    super(x),
-    node_count(0)
-  {
-    copy_map_type map(bfm_allocator::member,x.size(),x.header(),header());
-    for(const_iterator it=x.begin(),it_end=x.end();it!=it_end;++it){
-      map.clone(it.get_node());
-    }
-    super::copy_(x,map);
-    map.release();
-    node_count=x.size();
-
-    /* Not until this point are the indices required to be consistent,
-     * hence the position of the invariant checker.
-     */
-
-    BOOST_MULTI_INDEX_CHECK_INVARIANT;
-  }
-
-  multi_index_container(BOOST_RV_REF(multi_index_container) x):
-    bfm_allocator(x.bfm_allocator::member),
-    bfm_header(),
-    super(x,detail::do_not_copy_elements_tag()),
-    node_count(0)
-  {
-    BOOST_MULTI_INDEX_CHECK_INVARIANT;
-    BOOST_MULTI_INDEX_CHECK_INVARIANT_OF(x);
-    swap_elements_(x);
-  }
-
-  ~multi_index_container()
-  {
-    delete_all_nodes_();
-  }
-
-#if defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-  /* As per http://www.boost.org/doc/html/move/emulation_limitations.html
-   * #move.emulation_limitations.assignment_operator
-   */
-
-  multi_index_container<Value,IndexSpecifierList,Allocator>& operator=(
-    const multi_index_container<Value,IndexSpecifierList,Allocator>& x)
-  {
-    multi_index_container y(x);
-    this->swap(y);
-    return *this;
-  }
-#endif
-
-  multi_index_container<Value,IndexSpecifierList,Allocator>& operator=(
-    BOOST_COPY_ASSIGN_REF(multi_index_container) x)
-  {
-    multi_index_container y(x);
-    this->swap(y);
-    return *this;
-  }
-
-  multi_index_container<Value,IndexSpecifierList,Allocator>& operator=(
-    BOOST_RV_REF(multi_index_container) x)
-  {
-    this->swap(x);
-    return *this;
-  }
-
-#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
-  multi_index_container<Value,IndexSpecifierList,Allocator>& operator=(
-    std::initializer_list<Value> list)
-  {
-    BOOST_MULTI_INDEX_CHECK_INVARIANT;
-    typedef const Value* init_iterator;
-
-    multi_index_container x(*this,detail::do_not_copy_elements_tag());    
-    iterator hint=x.end();
-    for(init_iterator first=list.begin(),last=list.end();
-        first!=last;++first){
-      hint=x.make_iterator(x.insert_(*first,hint.get_node()).first);
-      ++hint;
-    }
-    x.swap_elements_(*this);
-    return*this;
-  }
-#endif
-
-  allocator_type get_allocator()const BOOST_NOEXCEPT
-  {
-    return allocator_type(bfm_allocator::member);
-  }
-
-  /* retrieval of indices by number */
-
-#if !defined(BOOST_NO_MEMBER_TEMPLATES)
-  template<int N>
-  struct nth_index
-  {
-    BOOST_STATIC_ASSERT(N>=0&&N<mpl::size<index_type_list>::type::value);
-    typedef typename mpl::at_c<index_type_list,N>::type type;
-  };
-
-  template<int N>
-  typename nth_index<N>::type& get()BOOST_NOEXCEPT
-  {
-    BOOST_STATIC_ASSERT(N>=0&&N<mpl::size<index_type_list>::type::value);
-    return *this;
-  }
-
-  template<int N>
-  const typename nth_index<N>::type& get()const BOOST_NOEXCEPT
-  {
-    BOOST_STATIC_ASSERT(N>=0&&N<mpl::size<index_type_list>::type::value);
-    return *this;
-  }
-#endif
-
-  /* retrieval of indices by tag */
-
-#if !defined(BOOST_NO_MEMBER_TEMPLATES)
-  template<typename Tag>
-  struct index
-  {
-    typedef typename mpl::find_if<
-      index_type_list,
-      detail::has_tag<Tag>
-    >::type                                    iter;
-
-    BOOST_STATIC_CONSTANT(
-      bool,index_found=!(is_same<iter,typename mpl::end<index_type_list>::type >::value));
-    BOOST_STATIC_ASSERT(index_found);
-
-    typedef typename mpl::deref<iter>::type    type;
-  };
-
-  template<typename Tag>
-  typename index<Tag>::type& get()BOOST_NOEXCEPT
-  {
-    return *this;
-  }
-
-  template<typename Tag>
-  const typename index<Tag>::type& get()const BOOST_NOEXCEPT
-  {
-    return *this;
-  }
-#endif
-
-  /* projection of iterators by number */
-
-#if !defined(BOOST_NO_MEMBER_TEMPLATES)
-  template<int N>
-  struct nth_index_iterator
-  {
-    typedef typename nth_index<N>::type::iterator type;
-  };
-
-  template<int N>
-  struct nth_index_const_iterator
-  {
-    typedef typename nth_index<N>::type::const_iterator type;
-  };
-
-  template<int N,typename IteratorType>
-  typename nth_index_iterator<N>::type project(IteratorType it)
-  {
-    typedef typename nth_index<N>::type index_type;
-
-#if !defined(__SUNPRO_CC)||!(__SUNPRO_CC<0x580) /* fails in Sun C++ 5.7 */
-    BOOST_STATIC_ASSERT(
-      (mpl::contains<iterator_type_list,IteratorType>::value));
-#endif
-
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(it);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(
-      it,static_cast<typename IteratorType::container_type&>(*this));
-
-    return index_type::make_iterator(static_cast<node_type*>(it.get_node()));
-  }
-
-  template<int N,typename IteratorType>
-  typename nth_index_const_iterator<N>::type project(IteratorType it)const
-  {
-    typedef typename nth_index<N>::type index_type;
-
-#if !defined(__SUNPRO_CC)||!(__SUNPRO_CC<0x580) /* fails in Sun C++ 5.7 */
-    BOOST_STATIC_ASSERT((
-      mpl::contains<iterator_type_list,IteratorType>::value||
-      mpl::contains<const_iterator_type_list,IteratorType>::value));
-#endif
-
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(it);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(
-      it,static_cast<const typename IteratorType::container_type&>(*this));
-    return index_type::make_iterator(static_cast<node_type*>(it.get_node()));
-  }
-#endif
-
-  /* projection of iterators by tag */
-
-#if !defined(BOOST_NO_MEMBER_TEMPLATES)
-  template<typename Tag>
-  struct index_iterator
-  {
-    typedef typename index<Tag>::type::iterator type;
-  };
-
-  template<typename Tag>
-  struct index_const_iterator
-  {
-    typedef typename index<Tag>::type::const_iterator type;
-  };
-
-  template<typename Tag,typename IteratorType>
-  typename index_iterator<Tag>::type project(IteratorType it)
-  {
-    typedef typename index<Tag>::type index_type;
-
-#if !defined(__SUNPRO_CC)||!(__SUNPRO_CC<0x580) /* fails in Sun C++ 5.7 */
-    BOOST_STATIC_ASSERT(
-      (mpl::contains<iterator_type_list,IteratorType>::value));
-#endif
-
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(it);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(
-      it,static_cast<typename IteratorType::container_type&>(*this));
-    return index_type::make_iterator(static_cast<node_type*>(it.get_node()));
-  }
-
-  template<typename Tag,typename IteratorType>
-  typename index_const_iterator<Tag>::type project(IteratorType it)const
-  {
-    typedef typename index<Tag>::type index_type;
-
-#if !defined(__SUNPRO_CC)||!(__SUNPRO_CC<0x580) /* fails in Sun C++ 5.7 */
-    BOOST_STATIC_ASSERT((
-      mpl::contains<iterator_type_list,IteratorType>::value||
-      mpl::contains<const_iterator_type_list,IteratorType>::value));
-#endif
-
-    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(it);
-    BOOST_MULTI_INDEX_CHECK_IS_OWNER(
-      it,static_cast<const typename IteratorType::container_type&>(*this));
-    return index_type::make_iterator(static_cast<node_type*>(it.get_node()));
-  }
-#endif
-
-BOOST_MULTI_INDEX_PROTECTED_IF_MEMBER_TEMPLATE_FRIENDS:
-  typedef typename super::copy_map_type copy_map_type;
-
-#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
-  multi_index_container(
-    const multi_index_container<Value,IndexSpecifierList,Allocator>& x,
-    detail::do_not_copy_elements_tag):
-    bfm_allocator(x.bfm_allocator::member),
-    bfm_header(),
-    super(x,detail::do_not_copy_elements_tag()),
-    node_count(0)
-  {
-    BOOST_MULTI_INDEX_CHECK_INVARIANT;
-  }
-#endif
-
-  node_type* header()const
-  {
-    return &*bfm_header::member;
-  }
-
-  node_type* allocate_node()
-  {
-    return &*bfm_allocator::member.allocate(1);
-  }
-
-  void deallocate_node(node_type* x)
-  {
-    typedef typename node_allocator::pointer node_pointer;
-    bfm_allocator::member.deallocate(static_cast<node_pointer>(x),1);
-  }
-
-  bool empty_()const
-  {
-    return node_count==0;
-  }
-
-  std::size_t size_()const
-  {
-    return node_count;
-  }
-
-  std::size_t max_size_()const
-  {
-    return static_cast<std::size_t >(-1);
-  }
-
-  template<typename Variant>
-  std::pair<node_type*,bool> insert_(const Value& v,Variant variant)
-  {
-    node_type* x=0;
-    node_type* res=super::insert_(v,x,variant);
-    if(res==x){
-      ++node_count;
-      return std::pair<node_type*,bool>(res,true);
-    }
-    else{
-      return std::pair<node_type*,bool>(res,false);
-    }
-  }
-
-  std::pair<node_type*,bool> insert_(const Value& v)
-  {
-    return insert_(v,detail::lvalue_tag());
-  }
-
-  std::pair<node_type*,bool> insert_rv_(const Value& v)
-  {
-    return insert_(v,detail::rvalue_tag());
-  }
-
-  template<typename T>
-  std::pair<node_type*,bool> insert_ref_(T& t)
-  {
-    node_type* x=allocate_node();
-    BOOST_TRY{
-      new(&x->value()) value_type(t);
-      BOOST_TRY{
-        node_type* res=super::insert_(x->value(),x,detail::emplaced_tag());
-        if(res==x){
-          ++node_count;
-          return std::pair<node_type*,bool>(res,true);
-        }
-        else{
-          boost::detail::allocator::destroy(&x->value());
-          deallocate_node(x);
-          return std::pair<node_type*,bool>(res,false);
-        }
-      }
-      BOOST_CATCH(...){
-        boost::detail::allocator::destroy(&x->value());
-        BOOST_RETHROW;
-      }
-      BOOST_CATCH_END
-    }
-    BOOST_CATCH(...){
-      deallocate_node(x);
-      BOOST_RETHROW;
-    }
-    BOOST_CATCH_END
-  }
-
-  std::pair<node_type*,bool> insert_ref_(const value_type& x)
-  {
-    return insert_(x);
-  }
-
-  std::pair<node_type*,bool> insert_ref_(value_type& x)
-  {
-    return insert_(x);
-  }
-
-  template<BOOST_MULTI_INDEX_TEMPLATE_PARAM_PACK>
-  std::pair<node_type*,bool> emplace_(
-    BOOST_MULTI_INDEX_FUNCTION_PARAM_PACK)
-  {
-    node_type* x=allocate_node();
-    BOOST_TRY{
-      detail::vartempl_placement_new(
-        &x->value(),BOOST_MULTI_INDEX_FORWARD_PARAM_PACK);
-      BOOST_TRY{
-        node_type* res=super::insert_(x->value(),x,detail::emplaced_tag());
-        if(res==x){
-          ++node_count;
-          return std::pair<node_type*,bool>(res,true);
-        }
-        else{
-          boost::detail::allocator::destroy(&x->value());
-          deallocate_node(x);
-          return std::pair<node_type*,bool>(res,false);
-        }
-      }
-      BOOST_CATCH(...){
-        boost::detail::allocator::destroy(&x->value());
-        BOOST_RETHROW;
-      }
-      BOOST_CATCH_END
-    }
-    BOOST_CATCH(...){
-      deallocate_node(x);
-      BOOST_RETHROW;
-    }
-    BOOST_CATCH_END
-  }
-
-  template<typename Variant>
-  std::pair<node_type*,bool> insert_(
-    const Value& v,node_type* position,Variant variant)
-  {
-    node_type* x=0;
-    node_type* res=super::insert_(v,position,x,variant);
-    if(res==x){
-      ++node_count;
-      return std::pair<node_type*,bool>(res,true);
-    }
-    else{
-      return std::pair<node_type*,bool>(res,false);
-    }
-  }
-
-  std::pair<node_type*,bool> insert_(const Value& v,node_type* position)
-  {
-    return insert_(v,position,detail::lvalue_tag());
-  }
-
-  std::pair<node_type*,bool> insert_rv_(const Value& v,node_type* position)
-  {
-    return insert_(v,position,detail::rvalue_tag());
-  }
-
-  template<typename T>
-  std::pair<node_type*,bool> insert_ref_(
-    T& t,node_type* position)
-  {
-    node_type* x=allocate_node();
-    BOOST_TRY{
-      new(&x->value()) value_type(t);
-      BOOST_TRY{
-        node_type* res=super::insert_(
-          x->value(),position,x,detail::emplaced_tag());
-        if(res==x){
-          ++node_count;
-          return std::pair<node_type*,bool>(res,true);
-        }
-        else{
-          boost::detail::allocator::destroy(&x->value());
-          deallocate_node(x);
-          return std::pair<node_type*,bool>(res,false);
-        }
-      }
-      BOOST_CATCH(...){
-        boost::detail::allocator::destroy(&x->value());
-        BOOST_RETHROW;
-      }
-      BOOST_CATCH_END
-    }
-    BOOST_CATCH(...){
-      deallocate_node(x);
-      BOOST_RETHROW;
-    }
-    BOOST_CATCH_END
-  }
-
-  std::pair<node_type*,bool> insert_ref_(
-    const value_type& x,node_type* position)
-  {
-    return insert_(x,position);
-  }
-
-  std::pair<node_type*,bool> insert_ref_(
-    value_type& x,node_type* position)
-  {
-    return insert_(x,position);
-  }
-
-  template<BOOST_MULTI_INDEX_TEMPLATE_PARAM_PACK>
-  std::pair<node_type*,bool> emplace_hint_(
-    node_type* position,
-    BOOST_MULTI_INDEX_FUNCTION_PARAM_PACK)
-  {
-    node_type* x=allocate_node();
-    BOOST_TRY{
-      detail::vartempl_placement_new(
-        &x->value(),BOOST_MULTI_INDEX_FORWARD_PARAM_PACK);
-      BOOST_TRY{
-        node_type* res=super::insert_(
-          x->value(),position,x,detail::emplaced_tag());
-        if(res==x){
-          ++node_count;
-          return std::pair<node_type*,bool>(res,true);
-        }
-        else{
-          boost::detail::allocator::destroy(&x->value());
-          deallocate_node(x);
-          return std::pair<node_type*,bool>(res,false);
-        }
-      }
-      BOOST_CATCH(...){
-        boost::detail::allocator::destroy(&x->value());
-        BOOST_RETHROW;
-      }
-      BOOST_CATCH_END
-    }
-    BOOST_CATCH(...){
-      deallocate_node(x);
-      BOOST_RETHROW;
-    }
-    BOOST_CATCH_END
-  }
-
-  void erase_(node_type* x)
-  {
-    --node_count;
-    super::erase_(x);
-    deallocate_node(x);
-  }
-
-  void delete_node_(node_type* x)
-  {
-    super::delete_node_(x);
-    deallocate_node(x);
-  }
-
-  void delete_all_nodes_()
-  {
-    super::delete_all_nodes_();
-  }
-
-  void clear_()
-  {
-    delete_all_nodes_();
-    super::clear_();
-    node_count=0;
-  }
-
-  void swap_(multi_index_container<Value,IndexSpecifierList,Allocator>& x)
-  {
-    if(bfm_allocator::member!=x.bfm_allocator::member){
-      detail::adl_swap(bfm_allocator::member,x.bfm_allocator::member);
-    }
-    std::swap(bfm_header::member,x.bfm_header::member);
-    super::swap_(x);
-    std::swap(node_count,x.node_count);
-  }
-
-  void swap_elements_(
-    multi_index_container<Value,IndexSpecifierList,Allocator>& x)
-  {
-    std::swap(bfm_header::member,x.bfm_header::member);
-    super::swap_elements_(x);
-    std::swap(node_count,x.node_count);
-  }
-
-  bool replace_(const Value& k,node_type* x)
-  {
-    return super::replace_(k,x,detail::lvalue_tag());
-  }
-
-  bool replace_rv_(const Value& k,node_type* x)
-  {
-    return super::replace_(k,x,detail::rvalue_tag());
-  }
-
-  template<typename Modifier>
-  bool modify_(Modifier& mod,node_type* x)
-  {
-    mod(const_cast<value_type&>(x->value()));
-
-    BOOST_TRY{
-      if(!super::modify_(x)){
-        deallocate_node(x);
-        --node_count;
-        return false;
-      }
-      else return true;
-    }
-    BOOST_CATCH(...){
-      deallocate_node(x);
-      --node_count;
-      BOOST_RETHROW;
-    }
-    BOOST_CATCH_END
-  }
-
-  template<typename Modifier,typename Rollback>
-  bool modify_(Modifier& mod,Rollback& back_,node_type* x)
-  {
-    mod(const_cast<value_type&>(x->value()));
-
-    bool b;
-    BOOST_TRY{
-      b=super::modify_rollback_(x);
-    }
-    BOOST_CATCH(...){
-      BOOST_TRY{
-        back_(const_cast<value_type&>(x->value()));
-        BOOST_RETHROW;
-      }
-      BOOST_CATCH(...){
-        this->erase_(x);
-        BOOST_RETHROW;
-      }
-      BOOST_CATCH_END
-    }
-    BOOST_CATCH_END
-
-    BOOST_TRY{
-      if(!b){
-        back_(const_cast<value_type&>(x->value()));
-        return false;
-      }
-      else return true;
-    }
-    BOOST_CATCH(...){
-      this->erase_(x);
-      BOOST_RETHROW;
-    }
-    BOOST_CATCH_END
-  }
-
-#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
-  /* serialization */
-
-  friend class boost::serialization::access;
-
-  BOOST_SERIALIZATION_SPLIT_MEMBER()
-
-  typedef typename super::index_saver_type        index_saver_type;
-  typedef typename super::index_loader_type       index_loader_type;
-
-  template<class Archive>
-  void save(Archive& ar,const unsigned int version)const
-  {
-    const serialization::collection_size_type       s(size_());
-    const detail::serialization_version<value_type> value_version;
-    ar<<serialization::make_nvp("count",s);
-    ar<<serialization::make_nvp("value_version",value_version);
-
-    index_saver_type sm(bfm_allocator::member,s);
-
-    for(iterator it=super::begin(),it_end=super::end();it!=it_end;++it){
-      serialization::save_construct_data_adl(ar,&*it,value_version);
-      ar<<serialization::make_nvp("item",*it);
-      sm.add(it.get_node(),ar,version);
-    }
-    sm.add_track(header(),ar,version);
-
-    super::save_(ar,version,sm);
-  }
-
-  template<class Archive>
-  void load(Archive& ar,const unsigned int version)
-  {
-    BOOST_MULTI_INDEX_CHECK_INVARIANT;
-
-    clear_(); 
-    serialization::collection_size_type       s;
-    detail::serialization_version<value_type> value_version;
-    if(version<1){
-      std::size_t sz;
-      ar>>serialization::make_nvp("count",sz);
-      s=static_cast<serialization::collection_size_type>(sz);
-    }
-    else{
-      ar>>serialization::make_nvp("count",s);
-    }
-    if(version<2){
-      value_version=0;
-    }
-    else{
-      ar>>serialization::make_nvp("value_version",value_version);
-    }
-
-    index_loader_type lm(bfm_allocator::member,s);
-
-    for(std::size_t n=0;n<s;++n){
-      detail::archive_constructed<Value> value("item",ar,value_version);
-      std::pair<node_type*,bool> p=insert_(
-        value.get(),super::end().get_node());
-      if(!p.second)throw_exception(
-        archive::archive_exception(
-          archive::archive_exception::other_exception));
-      ar.reset_object_address(&p.first->value(),&value.get());
-      lm.add(p.first,ar,version);
-    }
-    lm.add_track(header(),ar,version);
-
-    super::load_(ar,version,lm);
-  }
-#endif
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING)
-  /* invariant stuff */
-
-  bool invariant_()const
-  {
-    return super::invariant_();
-  }
-
-  void check_invariant_()const
-  {
-    BOOST_MULTI_INDEX_INVARIANT_ASSERT(invariant_());
-  }
-#endif
-
-private:
-  std::size_t node_count;
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING)&&\
-    BOOST_WORKAROUND(__MWERKS__,<=0x3003)
-#pragma parse_mfunc_templ reset
-#endif
-};
-
-#if BOOST_WORKAROUND(BOOST_MSVC,BOOST_TESTED_AT(1500))
-#pragma warning(pop) /* C4522 */
-#endif
-
-/* retrieval of indices by number */
-
-template<typename MultiIndexContainer,int N>
-struct nth_index
-{
-  BOOST_STATIC_CONSTANT(
-    int,
-    M=mpl::size<typename MultiIndexContainer::index_type_list>::type::value);
-  BOOST_STATIC_ASSERT(N>=0&&N<M);
-  typedef typename mpl::at_c<
-    typename MultiIndexContainer::index_type_list,N>::type type;
-};
-
-template<int N,typename Value,typename IndexSpecifierList,typename Allocator>
-typename nth_index<
-  multi_index_container<Value,IndexSpecifierList,Allocator>,N>::type&
-get(
-  multi_index_container<Value,IndexSpecifierList,Allocator>& m)BOOST_NOEXCEPT
-{
-  typedef multi_index_container<
-    Value,IndexSpecifierList,Allocator>    multi_index_type;
-  typedef typename nth_index<
-    multi_index_container<
-      Value,IndexSpecifierList,Allocator>,
-    N
-  >::type                                  index_type;
-
-  BOOST_STATIC_ASSERT(N>=0&&
-    N<
-    mpl::size<
-      BOOST_DEDUCED_TYPENAME multi_index_type::index_type_list
-    >::type::value);
-
-  return detail::converter<multi_index_type,index_type>::index(m);
-}
-
-template<int N,typename Value,typename IndexSpecifierList,typename Allocator>
-const typename nth_index<
-  multi_index_container<Value,IndexSpecifierList,Allocator>,N>::type&
-get(
-  const multi_index_container<Value,IndexSpecifierList,Allocator>& m
-)BOOST_NOEXCEPT
-{
-  typedef multi_index_container<
-    Value,IndexSpecifierList,Allocator>    multi_index_type;
-  typedef typename nth_index<
-    multi_index_container<
-      Value,IndexSpecifierList,Allocator>,
-    N
-  >::type                                  index_type;
-
-  BOOST_STATIC_ASSERT(N>=0&&
-    N<
-    mpl::size<
-      BOOST_DEDUCED_TYPENAME multi_index_type::index_type_list
-    >::type::value);
-
-  return detail::converter<multi_index_type,index_type>::index(m);
-}
-
-/* retrieval of indices by tag */
-
-template<typename MultiIndexContainer,typename Tag>
-struct index
-{
-  typedef typename MultiIndexContainer::index_type_list index_type_list;
-
-  typedef typename mpl::find_if<
-    index_type_list,
-    detail::has_tag<Tag>
-  >::type                                      iter;
-
-  BOOST_STATIC_CONSTANT(
-    bool,index_found=!(is_same<iter,typename mpl::end<index_type_list>::type >::value));
-  BOOST_STATIC_ASSERT(index_found);
-
-  typedef typename mpl::deref<iter>::type       type;
-};
-
-template<
-  typename Tag,typename Value,typename IndexSpecifierList,typename Allocator
->
-typename ::boost::multi_index::index<
-  multi_index_container<Value,IndexSpecifierList,Allocator>,Tag>::type&
-get(
-  multi_index_container<Value,IndexSpecifierList,Allocator>& m)BOOST_NOEXCEPT
-{
-  typedef multi_index_container<
-    Value,IndexSpecifierList,Allocator>         multi_index_type;
-  typedef typename ::boost::multi_index::index<
-    multi_index_container<
-      Value,IndexSpecifierList,Allocator>,
-    Tag
-  >::type                                       index_type;
-
-  return detail::converter<multi_index_type,index_type>::index(m);
-}
-
-template<
-  typename Tag,typename Value,typename IndexSpecifierList,typename Allocator
->
-const typename ::boost::multi_index::index<
-  multi_index_container<Value,IndexSpecifierList,Allocator>,Tag>::type&
-get(
-  const multi_index_container<Value,IndexSpecifierList,Allocator>& m
-)BOOST_NOEXCEPT
-{
-  typedef multi_index_container<
-    Value,IndexSpecifierList,Allocator>         multi_index_type;
-  typedef typename ::boost::multi_index::index<
-    multi_index_container<
-      Value,IndexSpecifierList,Allocator>,
-    Tag
-  >::type                                       index_type;
-
-  return detail::converter<multi_index_type,index_type>::index(m);
-}
-
-/* projection of iterators by number */
-
-template<typename MultiIndexContainer,int N>
-struct nth_index_iterator
-{
-  typedef typename nth_index<MultiIndexContainer,N>::type::iterator type;
-};
-
-template<typename MultiIndexContainer,int N>
-struct nth_index_const_iterator
-{
-  typedef typename nth_index<MultiIndexContainer,N>::type::const_iterator type;
-};
-
-template<
-  int N,typename IteratorType,
-  typename Value,typename IndexSpecifierList,typename Allocator>
-typename nth_index_iterator<
-  multi_index_container<Value,IndexSpecifierList,Allocator>,N>::type
-project(
-  multi_index_container<Value,IndexSpecifierList,Allocator>& m,
-  IteratorType it)
-{
-  typedef multi_index_container<
-    Value,IndexSpecifierList,Allocator>                multi_index_type;
-  typedef typename nth_index<multi_index_type,N>::type index_type;
-
-#if !defined(__SUNPRO_CC)||!(__SUNPRO_CC<0x580) /* Sun C++ 5.7 fails */
-  BOOST_STATIC_ASSERT((
-    mpl::contains<
-      BOOST_DEDUCED_TYPENAME multi_index_type::iterator_type_list,
-      IteratorType>::value));
-#endif
-
-  BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(it);
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-  typedef detail::converter<
-    multi_index_type,
-    BOOST_DEDUCED_TYPENAME IteratorType::container_type> converter;
-  BOOST_MULTI_INDEX_CHECK_IS_OWNER(it,converter::index(m));
-#endif
-
-  return detail::converter<multi_index_type,index_type>::iterator(
-    m,static_cast<typename multi_index_type::node_type*>(it.get_node()));
-}
-
-template<
-  int N,typename IteratorType,
-  typename Value,typename IndexSpecifierList,typename Allocator>
-typename nth_index_const_iterator<
-  multi_index_container<Value,IndexSpecifierList,Allocator>,N>::type
-project(
-  const multi_index_container<Value,IndexSpecifierList,Allocator>& m,
-  IteratorType it)
-{
-  typedef multi_index_container<
-    Value,IndexSpecifierList,Allocator>                multi_index_type;
-  typedef typename nth_index<multi_index_type,N>::type index_type;
-
-#if !defined(__SUNPRO_CC)||!(__SUNPRO_CC<0x580) /* Sun C++ 5.7 fails */
-  BOOST_STATIC_ASSERT((
-    mpl::contains<
-      BOOST_DEDUCED_TYPENAME multi_index_type::iterator_type_list,
-      IteratorType>::value||
-    mpl::contains<
-      BOOST_DEDUCED_TYPENAME multi_index_type::const_iterator_type_list,
-      IteratorType>::value));
-#endif
-
-  BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(it);
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-  typedef detail::converter<
-    multi_index_type,
-    BOOST_DEDUCED_TYPENAME IteratorType::container_type> converter;
-  BOOST_MULTI_INDEX_CHECK_IS_OWNER(it,converter::index(m));
-#endif
-
-  return detail::converter<multi_index_type,index_type>::const_iterator(
-    m,static_cast<typename multi_index_type::node_type*>(it.get_node()));
-}
-
-/* projection of iterators by tag */
-
-template<typename MultiIndexContainer,typename Tag>
-struct index_iterator
-{
-  typedef typename ::boost::multi_index::index<
-    MultiIndexContainer,Tag>::type::iterator    type;
-};
-
-template<typename MultiIndexContainer,typename Tag>
-struct index_const_iterator
-{
-  typedef typename ::boost::multi_index::index<
-    MultiIndexContainer,Tag>::type::const_iterator type;
-};
-
-template<
-  typename Tag,typename IteratorType,
-  typename Value,typename IndexSpecifierList,typename Allocator>
-typename index_iterator<
-  multi_index_container<Value,IndexSpecifierList,Allocator>,Tag>::type
-project(
-  multi_index_container<Value,IndexSpecifierList,Allocator>& m,
-  IteratorType it)
-{
-  typedef multi_index_container<
-    Value,IndexSpecifierList,Allocator>         multi_index_type;
-  typedef typename ::boost::multi_index::index<
-    multi_index_type,Tag>::type                 index_type;
-
-#if !defined(__SUNPRO_CC)||!(__SUNPRO_CC<0x580) /* Sun C++ 5.7 fails */
-  BOOST_STATIC_ASSERT((
-    mpl::contains<
-      BOOST_DEDUCED_TYPENAME multi_index_type::iterator_type_list,
-      IteratorType>::value));
-#endif
-
-  BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(it);
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-  typedef detail::converter<
-    multi_index_type,
-    BOOST_DEDUCED_TYPENAME IteratorType::container_type> converter;
-  BOOST_MULTI_INDEX_CHECK_IS_OWNER(it,converter::index(m));
-#endif
-
-  return detail::converter<multi_index_type,index_type>::iterator(
-    m,static_cast<typename multi_index_type::node_type*>(it.get_node()));
-}
-
-template<
-  typename Tag,typename IteratorType,
-  typename Value,typename IndexSpecifierList,typename Allocator>
-typename index_const_iterator<
-  multi_index_container<Value,IndexSpecifierList,Allocator>,Tag>::type
-project(
-  const multi_index_container<Value,IndexSpecifierList,Allocator>& m,
-  IteratorType it)
-{
-  typedef multi_index_container<
-    Value,IndexSpecifierList,Allocator>         multi_index_type;
-  typedef typename ::boost::multi_index::index<
-    multi_index_type,Tag>::type                 index_type;
-
-#if !defined(__SUNPRO_CC)||!(__SUNPRO_CC<0x580) /* Sun C++ 5.7 fails */
-  BOOST_STATIC_ASSERT((
-    mpl::contains<
-      BOOST_DEDUCED_TYPENAME multi_index_type::iterator_type_list,
-      IteratorType>::value||
-    mpl::contains<
-      BOOST_DEDUCED_TYPENAME multi_index_type::const_iterator_type_list,
-      IteratorType>::value));
-#endif
-
-  BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(it);
-
-#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
-  typedef detail::converter<
-    multi_index_type,
-    BOOST_DEDUCED_TYPENAME IteratorType::container_type> converter;
-  BOOST_MULTI_INDEX_CHECK_IS_OWNER(it,converter::index(m));
-#endif
-
-  return detail::converter<multi_index_type,index_type>::const_iterator(
-    m,static_cast<typename multi_index_type::node_type*>(it.get_node()));
-}
-
-/* Comparison. Simple forward to first index. */
-
-template<
-  typename Value1,typename IndexSpecifierList1,typename Allocator1,
-  typename Value2,typename IndexSpecifierList2,typename Allocator2
->
-bool operator==(
-  const multi_index_container<Value1,IndexSpecifierList1,Allocator1>& x,
-  const multi_index_container<Value2,IndexSpecifierList2,Allocator2>& y)
-{
-  return get<0>(x)==get<0>(y);
-}
-
-template<
-  typename Value1,typename IndexSpecifierList1,typename Allocator1,
-  typename Value2,typename IndexSpecifierList2,typename Allocator2
->
-bool operator<(
-  const multi_index_container<Value1,IndexSpecifierList1,Allocator1>& x,
-  const multi_index_container<Value2,IndexSpecifierList2,Allocator2>& y)
-{
-  return get<0>(x)<get<0>(y);
-}
-
-template<
-  typename Value1,typename IndexSpecifierList1,typename Allocator1,
-  typename Value2,typename IndexSpecifierList2,typename Allocator2
->
-bool operator!=(
-  const multi_index_container<Value1,IndexSpecifierList1,Allocator1>& x,
-  const multi_index_container<Value2,IndexSpecifierList2,Allocator2>& y)
-{
-  return get<0>(x)!=get<0>(y);
-}
-
-template<
-  typename Value1,typename IndexSpecifierList1,typename Allocator1,
-  typename Value2,typename IndexSpecifierList2,typename Allocator2
->
-bool operator>(
-  const multi_index_container<Value1,IndexSpecifierList1,Allocator1>& x,
-  const multi_index_container<Value2,IndexSpecifierList2,Allocator2>& y)
-{
-  return get<0>(x)>get<0>(y);
-}
-
-template<
-  typename Value1,typename IndexSpecifierList1,typename Allocator1,
-  typename Value2,typename IndexSpecifierList2,typename Allocator2
->
-bool operator>=(
-  const multi_index_container<Value1,IndexSpecifierList1,Allocator1>& x,
-  const multi_index_container<Value2,IndexSpecifierList2,Allocator2>& y)
-{
-  return get<0>(x)>=get<0>(y);
-}
-
-template<
-  typename Value1,typename IndexSpecifierList1,typename Allocator1,
-  typename Value2,typename IndexSpecifierList2,typename Allocator2
->
-bool operator<=(
-  const multi_index_container<Value1,IndexSpecifierList1,Allocator1>& x,
-  const multi_index_container<Value2,IndexSpecifierList2,Allocator2>& y)
-{
-  return get<0>(x)<=get<0>(y);
-}
-
-/*  specialized algorithms */
-
-template<typename Value,typename IndexSpecifierList,typename Allocator>
-void swap(
-  multi_index_container<Value,IndexSpecifierList,Allocator>& x,
-  multi_index_container<Value,IndexSpecifierList,Allocator>& y)
-{
-  x.swap(y);
-}
-
-} /* namespace multi_index */
-
-#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
-/* class version = 1 : we now serialize the size through
- * boost::serialization::collection_size_type.
- * class version = 2 : proper use of {save|load}_construct_data.
- */
-
-namespace serialization {
-template<typename Value,typename IndexSpecifierList,typename Allocator>
-struct version<
-  boost::multi_index_container<Value,IndexSpecifierList,Allocator>
->
-{
-  BOOST_STATIC_CONSTANT(int,value=2);
-};
-} /* namespace serialization */
-#endif
-
-/* Associated global functions are promoted to namespace boost, except
- * comparison operators and swap, which are meant to be Koenig looked-up.
- */
-
-using multi_index::get;
-using multi_index::project;
-
-} /* namespace boost */
-
-#undef BOOST_MULTI_INDEX_CHECK_INVARIANT
-#undef BOOST_MULTI_INDEX_CHECK_INVARIANT_OF
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/multi_index_container_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/multi_index_container_fwd.hpp
deleted file mode 100644
index b35acad407a..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/multi_index_container_fwd.hpp
+++ /dev/null
@@ -1,121 +0,0 @@
-/* Copyright 2003-2013 Joaquin M Lopez Munoz.
- * Distributed under the Boost Software License, Version 1.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/multi_index for library home page.
- */
-
-#ifndef BOOST_MULTI_INDEX_FWD_HPP
-#define BOOST_MULTI_INDEX_FWD_HPP
-
-#if defined(_MSC_VER)
-#pragma once
-#endif
-
-#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
-#include <boost/multi_index/identity.hpp>
-#include <boost/multi_index/indexed_by.hpp>
-#include <boost/multi_index/ordered_index_fwd.hpp>
-#include <memory>
-
-namespace boost{
-
-namespace multi_index{
-
-/* Default value for IndexSpecifierList specifies a container
- * equivalent to std::set<Value>.
- */
-
-template<
-  typename Value,
-  typename IndexSpecifierList=indexed_by<ordered_unique<identity<Value> > >,
-  typename Allocator=std::allocator<Value> >
-class multi_index_container;
-
-template<typename MultiIndexContainer,int N>
-struct nth_index;
-
-template<typename MultiIndexContainer,typename Tag>
-struct index;
-
-template<typename MultiIndexContainer,int N>
-struct nth_index_iterator;
-
-template<typename MultiIndexContainer,int N>
-struct nth_index_const_iterator;
-
-template<typename MultiIndexContainer,typename Tag>
-struct index_iterator;
-
-template<typename MultiIndexContainer,typename Tag>
-struct index_const_iterator;
-
-/* get and project functions not fwd declared due to problems
- * with dependent typenames
- */
-
-template<
-  typename Value1,typename IndexSpecifierList1,typename Allocator1,
-  typename Value2,typename IndexSpecifierList2,typename Allocator2
->
-bool operator==(
-  const multi_index_container<Value1,IndexSpecifierList1,Allocator1>& x,
-  const multi_index_container<Value2,IndexSpecifierList2,Allocator2>& y);
-
-template<
-  typename Value1,typename IndexSpecifierList1,typename Allocator1,
-  typename Value2,typename IndexSpecifierList2,typename Allocator2
->
-bool operator<(
-  const multi_index_container<Value1,IndexSpecifierList1,Allocator1>& x,
-  const multi_index_container<Value2,IndexSpecifierList2,Allocator2>& y);
-
-template<
-  typename Value1,typename IndexSpecifierList1,typename Allocator1,
-  typename Value2,typename IndexSpecifierList2,typename Allocator2
->
-bool operator!=(
-  const multi_index_container<Value1,IndexSpecifierList1,Allocator1>& x,
-  const multi_index_container<Value2,IndexSpecifierList2,Allocator2>& y);
-
-template<
-  typename Value1,typename IndexSpecifierList1,typename Allocator1,
-  typename Value2,typename IndexSpecifierList2,typename Allocator2
->
-bool operator>(
-  const multi_index_container<Value1,IndexSpecifierList1,Allocator1>& x,
-  const multi_index_container<Value2,IndexSpecifierList2,Allocator2>& y);
-
-template<
-  typename Value1,typename IndexSpecifierList1,typename Allocator1,
-  typename Value2,typename IndexSpecifierList2,typename Allocator2
->
-bool operator>=(
-  const multi_index_container<Value1,IndexSpecifierList1,Allocator1>& x,
-  const multi_index_container<Value2,IndexSpecifierList2,Allocator2>& y);
-
-template<
-  typename Value1,typename IndexSpecifierList1,typename Allocator1,
-  typename Value2,typename IndexSpecifierList2,typename Allocator2
->
-bool operator<=(
-  const multi_index_container<Value1,IndexSpecifierList1,Allocator1>& x,
-  const multi_index_container<Value2,IndexSpecifierList2,Allocator2>& y);
-
-template<typename Value,typename IndexSpecifierList,typename Allocator>
-void swap(
-  multi_index_container<Value,IndexSpecifierList,Allocator>& x,
-  multi_index_container<Value,IndexSpecifierList,Allocator>& y);
-
-} /* namespace multi_index */
-
-/* multi_index_container, being the main type of this library, is promoted to
- * namespace boost.
- */
-
-using multi_index::multi_index_container;
-
-} /* namespace boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/access.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/access.hpp
deleted file mode 100644
index f6581accc91..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/access.hpp
+++ /dev/null
@@ -1,145 +0,0 @@
-#ifndef BOOST_SERIALIZATION_ACCESS_HPP
-#define BOOST_SERIALIZATION_ACCESS_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// access.hpp: interface for serialization system.
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/config.hpp>
-
-namespace boost {
-
-namespace archive {
-namespace detail {
-    template<class Archive, class T>
-    class iserializer;
-    template<class Archive, class T>
-    class oserializer;
-} // namespace detail
-} // namespace archive
-
-namespace serialization {
-
-// forward declarations
-template<class Archive, class T>
-inline void serialize_adl(Archive &, T &, const unsigned int);
-namespace detail {
-    template<class Archive, class T>
-    struct member_saver;
-    template<class Archive, class T>
-    struct member_loader;
-} // namespace detail
-
-// use an "accessor class so that we can use: 
-// "friend class boost::serialization::access;" 
-// in any serialized class to permit clean, safe access to private class members
-// by the serialization system
-
-class access {
-public:
-    // grant access to "real" serialization defaults
-#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
-public:
-#else
-    template<class Archive, class T>
-    friend struct detail::member_saver;
-    template<class Archive, class T>
-    friend struct detail::member_loader;
-    template<class Archive, class T>
-    friend class archive::detail::iserializer;
-    template<class Archive, class T>
-    friend class archive::detail::oserializer;
-    template<class Archive, class T>
-    friend inline void serialize(
-        Archive & ar, 
-        T & t, 
-        const unsigned int file_version
-    );
-    template<class Archive, class T>
-    friend inline void save_construct_data(
-        Archive & ar, 
-        const T * t, 
-        const unsigned int file_version
-    );
-    template<class Archive, class T>
-    friend inline void load_construct_data(
-        Archive & ar, 
-        T * t, 
-        const unsigned int file_version
-    );
-#endif
-
-    // pass calls to users's class implementation
-    template<class Archive, class T>
-    static void member_save(
-        Archive & ar, 
-        //const T & t,
-        T & t,
-        const unsigned int file_version
-    ){
-        t.save(ar, file_version);
-    }
-    template<class Archive, class T>
-    static void member_load(
-        Archive & ar, 
-        T & t,
-        const unsigned int file_version
-    ){
-        t.load(ar, file_version);
-    }
-    template<class Archive, class T>
-    static void serialize(
-        Archive & ar, 
-        T & t, 
-        const unsigned int file_version
-    ){
-        // note: if you get a compile time error here with a
-        // message something like:
-        // cannot convert parameter 1 from <file type 1> to <file type 2 &>
-        // a likely possible cause is that the class T contains a 
-        // serialize function - but that serialize function isn't 
-        // a template and corresponds to a file type different than
-        // the class Archive.  To resolve this, don't include an
-        // archive type other than that for which the serialization
-        // function is defined!!!
-        t.serialize(ar, file_version);
-    }
-    template<class T>
-    static void destroy( const T * t) // const appropriate here?
-    {
-        // the const business is an MSVC 6.0 hack that should be
-        // benign on everything else
-        delete const_cast<T *>(t);
-    }
-    template<class T>
-    static void construct(T * t){
-        // default is inplace invocation of default constructor
-        // Note the :: before the placement new. Required if the
-        // class doesn't have a class-specific placement new defined.
-        ::new(t)T;
-    }
-    template<class T, class U>
-    static T & cast_reference(U & u){
-        return static_cast<T &>(u);
-    }
-    template<class T, class U>
-    static T * cast_pointer(U * u){
-        return static_cast<T *>(u);
-    }
-};
-
-} // namespace serialization
-} // namespace boost
-
-#endif // BOOST_SERIALIZATION_ACCESS_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/archive_input_unordered_map.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/archive_input_unordered_map.hpp
deleted file mode 100644
index ccf806b1813..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/archive_input_unordered_map.hpp
+++ /dev/null
@@ -1,85 +0,0 @@
-#ifndef  BOOST_SERIALIZATION_ARCHIVE_INPUT_UNORDERED_MAP_HPP
-#define BOOST_SERIALIZATION_ARCHIVE_INPUT_UNORDERED_MAP_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// serialization/unordered_map.hpp:
-// serialization for stl unordered_map templates
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// (C) Copyright 2014 Jim Bell
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/config.hpp>
-#include <boost/serialization/nvp.hpp>
-#include <boost/serialization/detail/stack_constructor.hpp>
-#include <boost/serialization/utility.hpp>
-#include <boost/move/utility_core.hpp>
-
-namespace boost { 
-namespace serialization {
-namespace stl {
-
-// map input
-template<class Archive, class Container>
-struct archive_input_unordered_map
-{
-    inline void operator()(
-        Archive &ar, 
-        Container &s, 
-        const unsigned int v
-    ){
-        typedef typename Container::value_type type;
-        detail::stack_construct<Archive, type> t(ar, v);
-        ar >> boost::serialization::make_nvp("item", t.reference());
-        std::pair<typename Container::const_iterator, bool> result = 
-            s.insert(boost::move(t.reference()));
-        // note: the following presumes that the map::value_type was NOT tracked
-        // in the archive.  This is the usual case, but here there is no way
-        // to determine that.  
-        if(result.second){
-            ar.reset_object_address(
-                & (result.first->second),
-                & t.reference().second
-            );
-        }
-    }
-};
-
-// multimap input
-template<class Archive, class Container>
-struct archive_input_unordered_multimap
-{
-    inline void operator()(
-        Archive &ar, 
-        Container &s, 
-        const unsigned int v
-    ){
-        typedef typename Container::value_type type;
-        detail::stack_construct<Archive, type> t(ar, v);
-        ar >> boost::serialization::make_nvp("item", t.reference());
-        typename Container::const_iterator result =
-            s.insert(t.reference());
-        // note: the following presumes that the map::value_type was NOT tracked
-        // in the archive.  This is the usual case, but here there is no way
-        // to determine that.  
-        ar.reset_object_address(
-            & result->second,
-            & t.reference()
-        );
-    }
-};
-
-} // stl
-} // namespace serialization
-} // namespace boost
-
-#endif // BOOST_SERIALIZATION_ARCHIVE_INPUT_UNORDERED_MAP_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/archive_input_unordered_set.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/archive_input_unordered_set.hpp
deleted file mode 100644
index 7f0003cc6a4..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/archive_input_unordered_set.hpp
+++ /dev/null
@@ -1,72 +0,0 @@
-#ifndef  BOOST_SERIALIZATION_ARCHIVE_INPUT_UNORDERED_SET_HPP
-#define BOOST_SERIALIZATION_ARCHIVE_INPUT_UNORDERED_SET_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// archive_input_unordered_set.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// (C) Copyright 2014 Jim Bell
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <utility>
-#include <boost/serialization/nvp.hpp>
-#include <boost/serialization/detail/stack_constructor.hpp>
-#include <boost/move/utility_core.hpp>
-
-namespace boost {
-namespace serialization {
-
-namespace stl {
-
-// unordered_set input
-template<class Archive, class Container>
-struct archive_input_unordered_set
-{
-    inline void operator()(
-        Archive &ar, 
-        Container &s, 
-        const unsigned int v
-    ){
-        typedef typename Container::value_type type;
-        detail::stack_construct<Archive, type> t(ar, v);
-        // borland fails silently w/o full namespace
-        ar >> boost::serialization::make_nvp("item", t.reference());
-        std::pair<typename Container::const_iterator, bool> result = 
-            s.insert(boost::move(t.reference()));
-        if(result.second)
-            ar.reset_object_address(& (* result.first), & t.reference());
-    }
-};
-
-// unordered_multiset input
-template<class Archive, class Container>
-struct archive_input_unordered_multiset
-{
-    inline void operator()(
-        Archive &ar, 
-        Container &s, 
-        const unsigned int v
-    ){
-        typedef typename Container::value_type type;
-        detail::stack_construct<Archive, type> t(ar, v);
-        ar >> boost::serialization::make_nvp("item", t.reference());
-        typename Container::const_iterator result =
-            s.insert(boost::move(t.reference()));
-        ar.reset_object_address(& (* result), & t.reference());
-    }
-};
-
-} // stl
-} // serialization
-} // boost
-
-#endif // BOOST_SERIALIZATION_ARCHIVE_INPUT_UNORDERED_SET_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/array.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/array.hpp
deleted file mode 100644
index 612d1a61985..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/array.hpp
+++ /dev/null
@@ -1,48 +0,0 @@
-#ifndef BOOST_SERIALIZATION_ARRAY_HPP
-#define BOOST_SERIALIZATION_ARRAY_HPP
-
-// (C) Copyright 2005 Matthias Troyer and Dave Abrahams
-// Use, modification and distribution is subject to the 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 serialization of <array>. If <array> not supported by the standard
-// library - this file becomes empty.  This is to avoid breaking backward
-// compatibiliy for applications which used this header to support
-// serialization of native arrays.  Code to serialize native arrays is
-// now always include by default.  RR
-
-#include <boost/config.hpp> // msvc 6.0 needs this for warning suppression
-
-#if defined(BOOST_NO_STDC_NAMESPACE)
-
-#include <iostream>
-#include <cstddef> // std::size_t
-namespace std{ 
-    using ::size_t; 
-} // namespace std
-#endif
-
-#include <boost/serialization/array_wrapper.hpp>
-
-#ifndef BOOST_NO_CXX11_HDR_ARRAY
-
-#include <array>
-#include <boost/serialization/nvp.hpp>
-
-namespace boost { namespace serialization {
-
-template <class Archive, class T, std::size_t N>
-void serialize(Archive& ar, std::array<T,N>& a, const unsigned int /* version */)
-{
-    ar & boost::serialization::make_nvp(
-        "elems",
-        *static_cast<T (*)[N]>(static_cast<void *>(a.data()))
-    );
-    
-}
-} } // end namespace boost::serialization
-
-#endif // BOOST_NO_CXX11_HDR_ARRAY
-
-#endif //BOOST_SERIALIZATION_ARRAY_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/array_optimization.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/array_optimization.hpp
deleted file mode 100644
index 40dffba871a..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/array_optimization.hpp
+++ /dev/null
@@ -1,37 +0,0 @@
-#ifndef BOOST_SERIALIZATION_ARRAY_OPTIMIZATON_HPP
-#define BOOST_SERIALIZATION_ARRAY_OPTIMIZATON_HPP
-
-// (C) Copyright 2005 Matthias Troyer and Dave Abrahams
-// Use, modification and distribution is subject to the 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> // msvc 6.0 needs this for warning suppression
-
-#if defined(BOOST_NO_STDC_NAMESPACE)
-namespace std{ 
-    using ::size_t; 
-} // namespace std
-#endif
-
-#include <boost/mpl/always.hpp>
-#include <boost/mpl/apply.hpp>
-#include <boost/type_traits/remove_const.hpp>
-
-namespace boost { namespace serialization {
-
-template <class Archive>
-struct use_array_optimization : boost::mpl::always<boost::mpl::false_> {};
-
-} } // end namespace boost::serialization
-
-#define BOOST_SERIALIZATION_USE_ARRAY_OPTIMIZATION(Archive)           \
-namespace boost { namespace serialization {                           \
-template <> struct use_array_optimization<Archive> {                  \
-  template <class ValueType>                                          \
-  struct apply : boost::mpl::apply1<Archive::use_array_optimization   \
-      , typename boost::remove_const<ValueType>::type                 \
-    >::type {};                                                       \
-}; }}
-
-#endif //BOOST_SERIALIZATION_ARRAY_OPTIMIZATON_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/array_wrapper.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/array_wrapper.hpp
deleted file mode 100644
index adf436e15b4..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/array_wrapper.hpp
+++ /dev/null
@@ -1,121 +0,0 @@
-#ifndef BOOST_SERIALIZATION_ARRAY_WRAPPER_HPP
-#define BOOST_SERIALIZATION_ARRAY_WRAPPER_HPP
-
-// (C) Copyright 2005 Matthias Troyer and Dave Abrahams
-// Use, modification and distribution is subject to the 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 <iostream>
-
-#include <boost/config.hpp> // msvc 6.0 needs this for warning suppression
-
-#if defined(BOOST_NO_STDC_NAMESPACE)
-namespace std{ 
-    using ::size_t; 
-} // namespace std
-#endif
-
-#include <boost/serialization/nvp.hpp>
-#include <boost/serialization/split_member.hpp>
-#include <boost/serialization/wrapper.hpp>
-#include <boost/serialization/collection_size_type.hpp>
-#include <boost/serialization/array_optimization.hpp>
-#include <boost/mpl/always.hpp>
-#include <boost/mpl/apply.hpp>
-#include <boost/mpl/bool_fwd.hpp>
-#include <boost/type_traits/remove_const.hpp>
-
-namespace boost { namespace serialization {
-
-template<class T>
-class array_wrapper :
-    public wrapper_traits<const array_wrapper< T > >
-{
-private:
-    array_wrapper & operator=(const array_wrapper & rhs);
-    // note: I would like to make the copy constructor private but this breaks
-    // make_array.  So I make make_array a friend
-    template<class Tx, class S>
-    friend const boost::serialization::array_wrapper<Tx> make_array(Tx * t, S s);
-public:
-
-    array_wrapper(const array_wrapper & rhs) :
-        m_t(rhs.m_t),
-        m_element_count(rhs.m_element_count)
-    {}
-public:
-    array_wrapper(T * t, std::size_t s) :
-        m_t(t),
-        m_element_count(s)
-    {}
-
-    // default implementation
-    template<class Archive>
-    void serialize_optimized(Archive &ar, const unsigned int, mpl::false_ ) const
-    {
-      // default implemention does the loop
-      std::size_t c = count();
-      T * t = address();
-      while(0 < c--)
-            ar & boost::serialization::make_nvp("item", *t++);
-    }
-
-    // optimized implementation
-    template<class Archive>
-    void serialize_optimized(Archive &ar, const unsigned int version, mpl::true_ )
-    {
-      boost::serialization::split_member(ar, *this, version);
-    }
-
-    // default implementation
-    template<class Archive>
-    void save(Archive &ar, const unsigned int version) const
-    {
-      ar.save_array(*this,version);
-    }
-
-    // default implementation
-    template<class Archive>
-    void load(Archive &ar, const unsigned int version)
-    {
-      ar.load_array(*this,version);
-    }
-    
-    // default implementation
-    template<class Archive>
-    void serialize(Archive &ar, const unsigned int version)
-    {
-      typedef typename 
-          boost::serialization::use_array_optimization<Archive>::template apply<
-                    typename remove_const< T >::type 
-                >::type use_optimized;
-      serialize_optimized(ar,version,use_optimized());
-    }
-    
-    T * address() const
-    {
-      return m_t;
-    }
-
-    std::size_t count() const
-    {
-      return m_element_count;
-    }
-
-private:
-    T * const m_t;
-    const std::size_t m_element_count;
-};
-
-template<class T, class S>
-inline
-const array_wrapper< T > make_array(T* t, S s){
-    const array_wrapper< T > a(t, s);
-    return a;
-}
-
-} } // end namespace boost::serialization
-
-
-#endif //BOOST_SERIALIZATION_ARRAY_WRAPPER_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/assume_abstract.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/assume_abstract.hpp
deleted file mode 100644
index 632f9312f5f..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/assume_abstract.hpp
+++ /dev/null
@@ -1,60 +0,0 @@
-#ifndef BOOST_SERIALIZATION_ASSUME_ABSTRACT_HPP
-#define BOOST_SERIALIZATION_ASSUME_ABSTRACT_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// assume_abstract_class.hpp:
-
-// (C) Copyright 2008 Robert Ramey
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-// this is useful for compilers which don't support the boost::is_abstract
-
-#include <boost/type_traits/is_abstract.hpp>
-#include <boost/mpl/bool_fwd.hpp>
-
-#ifndef BOOST_NO_IS_ABSTRACT
-
-// if there is an intrinsic is_abstract defined, we don't have to do anything
-#define BOOST_SERIALIZATION_ASSUME_ABSTRACT(T)
-
-// but forward to the "official" is_abstract
-namespace boost {
-namespace serialization {
-    template<class T>
-    struct is_abstract : boost::is_abstract< T > {} ;
-} // namespace serialization
-} // namespace boost
-
-#else
-// we have to "make" one
-
-namespace boost {
-namespace serialization {
-    template<class T>
-    struct is_abstract : boost::false_type {};
-} // namespace serialization
-} // namespace boost
-
-// define a macro to make explicit designation of this more transparent
-#define BOOST_SERIALIZATION_ASSUME_ABSTRACT(T)        \
-namespace boost {                                     \
-namespace serialization {                             \
-template<>                                            \
-struct is_abstract< T > : boost::true_type {};        \
-template<>                                            \
-struct is_abstract< const T > : boost::true_type {};  \
-}}                                                    \
-/**/
-
-#endif // BOOST_NO_IS_ABSTRACT
-
-#endif //BOOST_SERIALIZATION_ASSUME_ABSTRACT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/base_object.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/base_object.hpp
deleted file mode 100644
index 1a82cecd4b5..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/base_object.hpp
+++ /dev/null
@@ -1,100 +0,0 @@
-#ifndef BOOST_SERIALIZATION_BASE_OBJECT_HPP
-#define BOOST_SERIALIZATION_BASE_OBJECT_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// base_object.hpp:
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-// if no archive headers have been included this is a no op
-// this is to permit BOOST_EXPORT etc to be included in a 
-// file declaration header
-
-#include <boost/config.hpp>
-#include <boost/detail/workaround.hpp>
-
-#include <boost/mpl/eval_if.hpp>
-#include <boost/mpl/int.hpp>
-#include <boost/mpl/identity.hpp>
-
-#include <boost/type_traits/is_base_and_derived.hpp>
-#include <boost/type_traits/is_pointer.hpp>
-#include <boost/type_traits/is_const.hpp>
-#include <boost/type_traits/is_polymorphic.hpp>
-
-#include <boost/static_assert.hpp>
-#include <boost/serialization/access.hpp>
-#include <boost/serialization/force_include.hpp>
-#include <boost/serialization/void_cast_fwd.hpp>
-
-namespace boost {
-namespace serialization {
-
-namespace detail
-{
-    // get the base type for a given derived type
-    // preserving the const-ness
-    template<class B, class D>
-    struct base_cast
-    {
-        typedef typename
-        mpl::if_<
-            is_const<D>,
-            const B,
-            B
-        >::type type;
-        BOOST_STATIC_ASSERT(is_const<type>::value == is_const<D>::value);
-    };
-
-    // only register void casts if the types are polymorphic
-    template<class Base, class Derived>
-    struct base_register
-    {
-        struct polymorphic {
-            static void const * invoke(){
-                Base const * const b = 0;
-                Derived const * const d = 0;
-                return & void_cast_register(d, b);
-            }
-        };
-        struct non_polymorphic {
-            static void const * invoke(){
-                return 0;
-            }
-        };
-        static void const * invoke(){
-            typedef typename mpl::eval_if<
-                is_polymorphic<Base>,
-                mpl::identity<polymorphic>,
-                mpl::identity<non_polymorphic>
-            >::type type;
-            return type::invoke();
-        }
-    };
-
-} // namespace detail
-template<class Base, class Derived>
-typename detail::base_cast<Base, Derived>::type & 
-base_object(Derived &d)
-{
-    BOOST_STATIC_ASSERT(( is_base_and_derived<Base,Derived>::value));
-    BOOST_STATIC_ASSERT(! is_pointer<Derived>::value);
-    typedef typename detail::base_cast<Base, Derived>::type type;
-    detail::base_register<type, Derived>::invoke();
-    return access::cast_reference<type, Derived>(d);
-}
-
-} // namespace serialization
-} // namespace boost
-
-#endif // BOOST_SERIALIZATION_BASE_OBJECT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/binary_object.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/binary_object.hpp
deleted file mode 100644
index 5c9038e5a9f..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/binary_object.hpp
+++ /dev/null
@@ -1,79 +0,0 @@
-#ifndef BOOST_SERIALIZATION_BINARY_OBJECT_HPP
-#define BOOST_SERIALIZATION_BINARY_OBJECT_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// nvp.hpp: interface for serialization system.
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/assert.hpp>
-
-#include <cstddef> // std::size_t
-#include <boost/config.hpp>
-#if defined(BOOST_NO_STDC_NAMESPACE)
-namespace std{ 
-    using ::size_t; 
-} // namespace std
-#endif
-
-#include <boost/preprocessor/stringize.hpp>
-#include <boost/serialization/tracking.hpp>
-#include <boost/serialization/level.hpp>
-#include <boost/serialization/split_member.hpp>
-#include <boost/serialization/nvp.hpp>
-#include <boost/serialization/wrapper.hpp>
-
-namespace boost {
-namespace serialization {
-
-struct binary_object :
-    public wrapper_traits<nvp<const binary_object> >
-{
-    void const * m_t;
-    std::size_t m_size;
-    template<class Archive>
-    void save(Archive & ar, const unsigned int /* file_version */) const {
-        ar.save_binary(m_t, m_size);
-    }
-    template<class Archive>
-    void load(Archive & ar, const unsigned int /* file_version */) const {
-        ar.load_binary(const_cast<void *>(m_t), m_size);
-    }
-    BOOST_SERIALIZATION_SPLIT_MEMBER()
-    binary_object & operator=(const binary_object & rhs) {
-        m_t = rhs.m_t;
-        m_size = rhs.m_size;
-        return *this;
-    }
-    binary_object(const void * const t, std::size_t size) :
-        m_t(t),
-        m_size(size)
-    {}
-    binary_object(const binary_object & rhs) :
-        m_t(rhs.m_t),
-        m_size(rhs.m_size)
-    {}
-};
-
-// just a little helper to support the convention that all serialization
-// wrappers follow the naming convention make_xxxxx
-inline 
-const binary_object
-make_binary_object(const void * t, std::size_t size){
-    return binary_object(t, size);
-}
-
-} // namespace serialization
-} // boost
-
-#endif // BOOST_SERIALIZATION_BINARY_OBJECT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/bitset.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/bitset.hpp
deleted file mode 100644
index 78f9bd74336..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/bitset.hpp
+++ /dev/null
@@ -1,75 +0,0 @@
-/*!
- * \file      bitset.hpp
- * \brief     Provides Boost.Serialization support for std::bitset
- * \author    Brian Ravnsgaard Riis
- * \author    Kenneth Riddile
- * \date      16.09.2004, updated 04.03.2009
- * \copyright 2004 Brian Ravnsgaard Riis
- * \license   Boost Software License 1.0
- */
-#ifndef BOOST_SERIALIZATION_BITSET_HPP
-#define BOOST_SERIALIZATION_BITSET_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-#include <bitset>
-#include <cstddef> // size_t
-
-#include <boost/config.hpp>
-#include <boost/serialization/split_free.hpp>
-#include <boost/serialization/string.hpp>
-#include <boost/serialization/nvp.hpp>
-
-namespace boost{
-namespace serialization{
-
-template <class Archive, std::size_t size>
-inline void save(
-    Archive & ar,
-    std::bitset<size> const & t,
-    const unsigned int /* version */
-){
-    const std::string bits = t.template to_string<
-        std::string::value_type,
-        std::string::traits_type,
-        std::string::allocator_type
-    >();
-    ar << BOOST_SERIALIZATION_NVP( bits );
-}
-
-template <class Archive, std::size_t size>
-inline void load(
-    Archive & ar,
-    std::bitset<size> & t,
-    const unsigned int /* version */
-){
-    std::string bits;
-    ar >> BOOST_SERIALIZATION_NVP( bits );
-    t = std::bitset<size>(bits);
-}
-
-template <class Archive, std::size_t size>
-inline void serialize(
-    Archive & ar,
-    std::bitset<size> & t,
-    const unsigned int version
-){
-    boost::serialization::split_free( ar, t, version );
-}
-
-// don't track bitsets since that would trigger tracking
-// all over the program - which probably would be a surprise.
-// also, tracking would be hard to implement since, we're
-// serialization a representation of the data rather than
-// the data itself.
-template <std::size_t size>
-struct tracking_level<std::bitset<size> >
-    : mpl::int_<track_never> {} ;
-
-} //serialization
-} //boost
-
-#endif // BOOST_SERIALIZATION_BITSET_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/boost_array.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/boost_array.hpp
deleted file mode 100644
index d564ff15de0..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/boost_array.hpp
+++ /dev/null
@@ -1,33 +0,0 @@
-#ifndef BOOST_SERIALIZATION_ARRAY_HPP
-#define BOOST_SERIALIZATION_ARRAY_HPP
-
-// (C) Copyright 2005 Matthias Troyer and Dave Abrahams
-// Use, modification and distribution is subject to the 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 <iostream>
-
-#include <boost/config.hpp> // msvc 6.0 needs this for warning suppression
-
-#if defined(BOOST_NO_STDC_NAMESPACE)
-namespace std{ 
-    using ::size_t; 
-} // namespace std
-#endif
-
-#include <boost/serialization/nvp.hpp>
-#include <boost/array.hpp>
-
-namespace boost { namespace serialization {
-// implement serialization for boost::array
-template <class Archive, class T, std::size_t N>
-void serialize(Archive& ar, boost::array<T,N>& a, const unsigned int /* version */)
-{
-    ar & boost::serialization::make_nvp("elems", a.elems);
-}
-
-} } // end namespace boost::serialization
-
-
-#endif //BOOST_SERIALIZATION_ARRAY_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/boost_unordered_map.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/boost_unordered_map.hpp
deleted file mode 100644
index 8913b31f9e6..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/boost_unordered_map.hpp
+++ /dev/null
@@ -1,154 +0,0 @@
-#ifndef  BOOST_SERIALIZATION_UNORDERED_MAP_HPP
-#define BOOST_SERIALIZATION_UNORDERED_MAP_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// serialization/unordered_map.hpp:
-// serialization for stl unordered_map templates
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// (C) Copyright 2014 Jim Bell
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/config.hpp>
-
-#include <boost/unordered_map.hpp>
-
-#include <boost/serialization/utility.hpp>
-#include <boost/serialization/unordered_collections_save_imp.hpp>
-#include <boost/serialization/unordered_collections_load_imp.hpp>
-#include <boost/serialization/archive_input_unordered_map.hpp>
-#include <boost/serialization/split_free.hpp>
-
-namespace boost { 
-namespace serialization {
-
-template<
-    class Archive, 
-    class Key, 
-    class HashFcn, 
-    class EqualKey,
-    class Allocator
->
-inline void save(
-    Archive & ar,
-    const boost::unordered_map<Key, HashFcn, EqualKey, Allocator> &t,
-    const unsigned int /*file_version*/
-){
-    boost::serialization::stl::save_unordered_collection<
-        Archive, 
-        boost::unordered_map<Key, HashFcn, EqualKey, Allocator>
-    >(ar, t);
-}
-
-template<
-    class Archive, 
-    class Key, 
-    class HashFcn, 
-    class EqualKey,
-    class Allocator
->
-inline void load(
-    Archive & ar,
-    boost::unordered_map<Key, HashFcn, EqualKey, Allocator> &t,
-    const unsigned int /*file_version*/
-){
-    boost::serialization::stl::load_unordered_collection<
-        Archive,
-        boost::unordered_map<Key, HashFcn, EqualKey, Allocator>,
-        boost::serialization::stl::archive_input_unordered_map<
-            Archive, 
-            boost::unordered_map<Key, HashFcn, EqualKey, Allocator>
-        >
-    >(ar, t);
-}
-
-// split non-intrusive serialization function member into separate
-// non intrusive save/load member functions
-template<
-    class Archive, 
-    class Key, 
-    class HashFcn, 
-    class EqualKey,
-    class Allocator
->
-inline void serialize(
-    Archive & ar,
-    boost::unordered_map<Key, HashFcn, EqualKey, Allocator> &t,
-    const unsigned int file_version
-){
-    boost::serialization::split_free(ar, t, file_version);
-}
-
-// unordered_multimap
-template<
-    class Archive, 
-    class Key, 
-    class HashFcn, 
-    class EqualKey,
-    class Allocator
->
-inline void save(
-    Archive & ar,
-    const boost::unordered_multimap<Key, HashFcn, EqualKey, Allocator> &t,
-    const unsigned int /*file_version*/
-){
-    boost::serialization::stl::save_unordered_collection<
-        Archive, 
-        boost::unordered_multimap<Key, HashFcn, EqualKey, Allocator>
-    >(ar, t);
-}
-
-template<
-    class Archive, 
-    class Key, 
-    class HashFcn, 
-    class EqualKey,
-    class Allocator
->
-inline void load(
-    Archive & ar,
-    boost::unordered_multimap<
-        Key, HashFcn, EqualKey, Allocator
-    > &t,
-    const unsigned int /*file_version*/
-){
-    boost::serialization::stl::load_unordered_collection<
-        Archive,
-        boost::unordered_multimap<Key, HashFcn, EqualKey, Allocator>,
-        boost::serialization::stl::archive_input_unordered_multimap<
-            Archive, 
-            boost::unordered_multimap<Key, HashFcn, EqualKey, Allocator>
-        >
-    >(ar, t);
-}
-
-// split non-intrusive serialization function member into separate
-// non intrusive save/load member functions
-template<
-    class Archive, 
-    class Key, 
-    class HashFcn, 
-    class EqualKey,
-    class Allocator
->
-inline void serialize(
-    Archive & ar,
-    boost::unordered_multimap<Key, HashFcn, EqualKey, Allocator> &t,
-    const unsigned int file_version
-){
-    boost::serialization::split_free(ar, t, file_version);
-}
-
-} // namespace serialization
-} // namespace boost
-
-#endif // BOOST_SERIALIZATION_UNORDERED_MAP_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/boost_unordered_set.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/boost_unordered_set.hpp
deleted file mode 100644
index 307c7819cbd..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/boost_unordered_set.hpp
+++ /dev/null
@@ -1,150 +0,0 @@
-#ifndef  BOOST_SERIALIZATION_BOOST_UNORDERED_SET_HPP
-#define BOOST_SERIALIZATION_BOOST_UNORDERED_SET_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// unordered_set.hpp: serialization for boost unordered_set templates
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// (C) Copyright 2014 Jim Bell
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/config.hpp>
-
-#include <boost/unordered_set.hpp>
-
-#include <boost/serialization/unordered_collections_save_imp.hpp>
-#include <boost/serialization/unordered_collections_load_imp.hpp>
-#include <boost/serialization/archive_input_unordered_set.hpp>
-#include <boost/serialization/split_free.hpp>
-
-namespace boost { 
-namespace serialization {
-
-template<
-    class Archive, 
-    class Key, 
-    class HashFcn, 
-    class EqualKey,
-    class Allocator
->
-inline void save(
-    Archive & ar,
-    const boost::unordered_set<Key, HashFcn, EqualKey, Allocator> &t,
-    const unsigned int /*file_version*/
-){
-    boost::serialization::stl::save_unordered_collection<
-        Archive, 
-        boost::unordered_set<Key, HashFcn, EqualKey, Allocator>
-    >(ar, t);
-}
-
-template<
-    class Archive, 
-    class Key, 
-    class HashFcn, 
-    class EqualKey,
-    class Allocator
->
-inline void load(
-    Archive & ar,
-    boost::unordered_set<Key, HashFcn, EqualKey, Allocator> &t,
-    const unsigned int /*file_version*/
-){
-    boost::serialization::stl::load_unordered_collection<
-        Archive,
-        boost::unordered_set<Key, HashFcn, EqualKey, Allocator>,
-        boost::serialization::stl::archive_input_unordered_set<
-            Archive, 
-            boost::unordered_set<Key, HashFcn, EqualKey, Allocator>
-        >
-    >(ar, t);
-}
-
-// split non-intrusive serialization function member into separate
-// non intrusive save/load member functions
-template<
-    class Archive, 
-    class Key, 
-    class HashFcn, 
-    class EqualKey,
-    class Allocator
->
-inline void serialize(
-    Archive & ar,
-    boost::unordered_set<Key, HashFcn, EqualKey, Allocator> &t,
-    const unsigned int file_version
-){
-    boost::serialization::split_free(ar, t, file_version);
-}
-
-// unordered_multiset
-template<
-    class Archive, 
-    class Key, 
-    class HashFcn, 
-    class EqualKey,
-    class Allocator
->
-inline void save(
-    Archive & ar,
-    const boost::unordered_multiset<Key, HashFcn, EqualKey, Allocator> &t,
-    const unsigned int /*file_version*/
-){
-    boost::serialization::stl::save_unordered_collection<
-        Archive, 
-        boost::unordered_multiset<Key, HashFcn, EqualKey, Allocator>
-    >(ar, t);
-}
-
-template<
-    class Archive, 
-    class Key, 
-    class HashFcn, 
-    class EqualKey,
-    class Allocator
->
-inline void load(
-    Archive & ar,
-    boost::unordered_multiset<Key, HashFcn, EqualKey, Allocator> &t,
-    const unsigned int /*file_version*/
-){
-    boost::serialization::stl::load_unordered_collection<
-        Archive,
-        boost::unordered_multiset<Key, HashFcn, EqualKey, Allocator>,
-        boost::serialization::stl::archive_input_unordered_multiset<
-            Archive,
-            boost::unordered_multiset<Key, HashFcn, EqualKey, Allocator>
-        >
-    >(ar, t);
-}
-
-// split non-intrusive serialization function member into separate
-// non intrusive save/load member functions
-template<
-    class Archive, 
-    class Key, 
-    class HashFcn, 
-    class EqualKey,
-    class Allocator
->
-inline void serialize(
-    Archive & ar,
-    boost::unordered_multiset<Key, HashFcn, EqualKey, Allocator> &t,
-    const unsigned int file_version
-){
-    boost::serialization::split_free(ar, t, file_version);
-}
-
-} // namespace serialization
-} // namespace boost
-
-#endif // BOOST_SERIALIZATION_BOOST_UNORDERED_SET_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/collection_size_type.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/collection_size_type.hpp
deleted file mode 100644
index 2dd8fa72584..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/collection_size_type.hpp
+++ /dev/null
@@ -1,62 +0,0 @@
-#ifndef BOOST_SERIALIZATION_COLLECTION_SIZE_TYPE_HPP
-#define BOOST_SERIALIZATION_COLLECTION_SIZE_TYPE_HPP
-
-// (C) Copyright 2005 Matthias Troyer
-// Use, modification and distribution is subject to the 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 <cstddef> // size_t
-#include <boost/serialization/strong_typedef.hpp>
-#include <boost/serialization/level.hpp>
-#include <boost/serialization/split_free.hpp>
-#include <boost/serialization/is_bitwise_serializable.hpp>
-
-namespace boost { 
-namespace serialization {
-
-//BOOST_STRONG_TYPEDEF(std::size_t, collection_size_type)
-
-class collection_size_type {
-private:
-    typedef std::size_t base_type;
-    base_type t;
-public:
-    collection_size_type(): t(0) {};
-    explicit collection_size_type(const std::size_t & t_) : 
-        t(t_)
-    {}
-    collection_size_type(const collection_size_type & t_) : 
-        t(t_.t)
-    {}
-    collection_size_type & operator=(const collection_size_type & rhs){
-        t = rhs.t; 
-        return *this;
-    }
-    collection_size_type & operator=(const unsigned int & rhs){
-        t = rhs; 
-        return *this;
-    }
-    // used for text output
-    operator base_type () const {
-        return t;
-    }                
-    // used for text input
-    operator base_type & () {
-        return t;
-    }                
-    bool operator==(const collection_size_type & rhs) const {
-        return t == rhs.t;
-    } 
-    bool operator<(const collection_size_type & rhs) const {
-        return t < rhs.t;
-    }   
-};
-
-
-} } // end namespace boost::serialization
-
-BOOST_CLASS_IMPLEMENTATION(collection_size_type, primitive_type)
-BOOST_IS_BITWISE_SERIALIZABLE(collection_size_type)
-
-#endif //BOOST_SERIALIZATION_COLLECTION_SIZE_TYPE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/collection_traits.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/collection_traits.hpp
deleted file mode 100644
index 3ec9401eff0..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/collection_traits.hpp
+++ /dev/null
@@ -1,79 +0,0 @@
-#ifndef BOOST_SERIALIZATION_COLLECTION_TRAITS_HPP
-#define BOOST_SERIALIZATION_COLLECTION_TRAITS_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// collection_traits.hpp:
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-// This header assigns a level implemenation trait to a collection type
-// for all primitives.  It is needed so that archives which are meant to be
-// portable don't write class information in the archive.  Since, not all
-// compiles recognize the same set of primitive types, the possibility
-// exists for archives to be non-portable if class information for primitive
-// types is included.  This is addressed by the following macros.
-#include <boost/config.hpp>
-//#include <boost/mpl/integral_c.hpp>
-#include <boost/mpl/integral_c_tag.hpp>
-
-#include <boost/cstdint.hpp>
-#include <boost/integer_traits.hpp>
-#include <climits> // ULONG_MAX
-#include <boost/serialization/level.hpp>
-
-#define BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(T, C)          \
-template<>                                                          \
-struct implementation_level< C < T > > {                            \
-    typedef mpl::integral_c_tag tag;                                \
-    typedef mpl::int_<object_serializable> type;                    \
-    BOOST_STATIC_CONSTANT(int, value = object_serializable);        \
-};                                                                  \
-/**/
-
-#if defined(BOOST_NO_CWCHAR) || defined(BOOST_NO_INTRINSIC_WCHAR_T)
-    #define BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER_WCHAR(C)
-#else
-    #define BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER_WCHAR(C)   \
-    BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(wchar_t, C)        \
-    /**/
-#endif
-
-#if defined(BOOST_HAS_LONG_LONG)
-    #define BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER_INT64(C)    \
-    BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(boost::long_long_type, C)  \
-    BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(boost::ulong_long_type, C) \
-    /**/
-#else
-    #define BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER_INT64(C)
-#endif
-
-#define BOOST_SERIALIZATION_COLLECTION_TRAITS(C)                     \
-    namespace boost { namespace serialization {                      \
-    BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(bool, C)            \
-    BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(char, C)            \
-    BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(signed char, C)     \
-    BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(unsigned char, C)   \
-    BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(signed int, C)      \
-    BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(unsigned int, C)    \
-    BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(signed long, C)     \
-    BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(unsigned long, C)   \
-    BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(float, C)           \
-    BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(double, C)          \
-    BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(unsigned short, C)  \
-    BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(signed short, C)    \
-    BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER_INT64(C)            \
-    BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER_WCHAR(C)            \
-    } }                                                              \
-    /**/
-
-#endif // BOOST_SERIALIZATION_COLLECTION_TRAITS
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/collections_load_imp.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/collections_load_imp.hpp
deleted file mode 100644
index e042c0c130d..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/collections_load_imp.hpp
+++ /dev/null
@@ -1,106 +0,0 @@
-#ifndef  BOOST_SERIALIZATION_COLLECTIONS_LOAD_IMP_HPP
-#define BOOST_SERIALIZATION_COLLECTIONS_LOAD_IMP_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-#if defined(_MSC_VER) && (_MSC_VER <= 1020)
-#  pragma warning (disable : 4786) // too long name, harmless warning
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// collections_load_imp.hpp: serialization for loading stl collections
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-// helper function templates for serialization of collections
-
-#include <boost/assert.hpp>
-#include <cstddef> // size_t
-#include <boost/config.hpp> // msvc 6.0 needs this for warning suppression
-#if defined(BOOST_NO_STDC_NAMESPACE)
-namespace std{ 
-    using ::size_t; 
-} // namespace std
-#endif
-#include <boost/detail/workaround.hpp>
-
-#include <boost/archive/detail/basic_iarchive.hpp>
-#include <boost/serialization/access.hpp>
-#include <boost/serialization/nvp.hpp>
-#include <boost/serialization/detail/stack_constructor.hpp>
-#include <boost/serialization/collection_size_type.hpp>
-#include <boost/serialization/item_version_type.hpp>
-#include <boost/serialization/detail/is_default_constructible.hpp>
-#include <boost/utility/enable_if.hpp>
-#include <boost/move/utility_core.hpp>
-
-namespace boost{
-namespace serialization {
-namespace stl {
-
-//////////////////////////////////////////////////////////////////////
-// implementation of serialization for STL containers
-//
-
-template<
-    class Archive,
-    class T
->
-typename boost::enable_if<
-    typename detail::is_default_constructible<
-        typename T::value_type
-    >,
-    void
->::type
-collection_load_impl(
-    Archive & ar,
-    T & t,
-    collection_size_type count,
-    item_version_type /*item_version*/
-){
-    t.resize(count);
-    typename T::iterator hint;
-    hint = t.begin();
-    while(count-- > 0){
-        ar >> boost::serialization::make_nvp("item", *hint++);
-    }
-}
-
-template<
-    class Archive,
-    class T
->
-typename boost::disable_if<
-    typename detail::is_default_constructible<
-        typename T::value_type
-    >,
-    void
->::type
-collection_load_impl(
-    Archive & ar,
-    T & t,
-    collection_size_type count,
-    item_version_type item_version
-){
-    t.clear();
-    while(count-- > 0){
-        detail::stack_construct<Archive, typename T::value_type> u(ar, item_version);
-        ar >> boost::serialization::make_nvp("item", u.reference());
-        t.push_back(boost::move(u.reference()));
-        ar.reset_object_address(& t.back() , & u.reference());
-     }
-}
-
-} // namespace stl 
-} // namespace serialization
-} // namespace boost
-
-#endif //BOOST_SERIALIZATION_COLLECTIONS_LOAD_IMP_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/collections_save_imp.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/collections_save_imp.hpp
deleted file mode 100644
index f3cabfcf3f5..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/collections_save_imp.hpp
+++ /dev/null
@@ -1,82 +0,0 @@
-#ifndef BOOST_SERIALIZATION_COLLECTIONS_SAVE_IMP_HPP
-#define BOOST_SERIALIZATION_COLLECTIONS_SAVE_IMP_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// collections_save_imp.hpp: serialization for stl collections
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-// helper function templates for serialization of collections
-
-#include <boost/config.hpp>
-#include <boost/serialization/nvp.hpp>
-#include <boost/serialization/serialization.hpp>
-#include <boost/serialization/version.hpp>
-#include <boost/serialization/collection_size_type.hpp>
-#include <boost/serialization/item_version_type.hpp>
-
-namespace boost{
-namespace serialization {
-namespace stl {
-
-//////////////////////////////////////////////////////////////////////
-// implementation of serialization for STL containers
-//
-
-template<class Archive, class Container>
-inline void save_collection(
-    Archive & ar,
-    const Container &s,
-    collection_size_type count)
-{
-    ar << BOOST_SERIALIZATION_NVP(count);
-    // record number of elements
-    const item_version_type item_version(
-        version<typename Container::value_type>::value
-    );
-    #if 0
-        boost::archive::library_version_type library_version(
-            ar.get_library_version()
-        );
-        if(boost::archive::library_version_type(3) < library_version){
-            ar << BOOST_SERIALIZATION_NVP(item_version);
-        }
-    #else
-        ar << BOOST_SERIALIZATION_NVP(item_version);
-    #endif
-
-    typename Container::const_iterator it = s.begin();
-    while(count-- > 0){
-        // note borland emits a no-op without the explicit namespace
-        boost::serialization::save_construct_data_adl(
-            ar, 
-            &(*it), 
-            item_version
-        );
-        ar << boost::serialization::make_nvp("item", *it++);
-    }
-}
-
-template<class Archive, class Container>
-inline void save_collection(Archive & ar, const Container &s)
-{
-    // record number of elements
-    collection_size_type count(s.size());
-    save_collection(ar, s, count);
-}
-
-} // namespace stl 
-} // namespace serialization
-} // namespace boost
-
-#endif //BOOST_SERIALIZATION_COLLECTIONS_SAVE_IMP_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/complex.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/complex.hpp
deleted file mode 100644
index b4ef44cf973..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/complex.hpp
+++ /dev/null
@@ -1,81 +0,0 @@
-#ifndef  BOOST_SERIALIZATION_COMPLEX_HPP
-#define BOOST_SERIALIZATION_COMPLEX_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// serialization/utility.hpp:
-// serialization for stl utility templates
-
-// (C) Copyright 2007 Matthias Troyer . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <complex>
-#include <boost/config.hpp>
-
-#include <boost/serialization/nvp.hpp>
-#include <boost/serialization/is_bitwise_serializable.hpp>
-#include <boost/serialization/split_free.hpp>
-
-namespace boost { 
-namespace serialization {
-
-template<class Archive, class T>
-inline void serialize(
-    Archive & ar,
-    std::complex< T > & t,
-    const unsigned int file_version 
-){
-    boost::serialization::split_free(ar, t, file_version);
-}
-
-template<class Archive, class T>
-inline void save(
-    Archive & ar,
-    std::complex< T > const & t,
-    const unsigned int /* file_version */
-){
-    const T re = t.real();
-    const T im = t.imag();
-    ar << boost::serialization::make_nvp("real", re);
-    ar << boost::serialization::make_nvp("imag", im);
-}
-
-template<class Archive, class T>
-inline void load(
-    Archive & ar,
-    std::complex< T >& t,
-    const unsigned int /* file_version */ 
-){
-    T re;
-    T im;
-    ar >> boost::serialization::make_nvp("real", re);
-    ar >> boost::serialization::make_nvp("imag", im);
-    t = std::complex< T >(re,im);
-}
-
-// specialization of serialization traits for complex
-template <class T>
-struct is_bitwise_serializable<std::complex< T > >
-    : public is_bitwise_serializable< T > {};
-
-template <class T>
-struct implementation_level<std::complex< T > >
-    : mpl::int_<object_serializable> {} ;
-
-// treat complex just like builtin arithmetic types for tracking
-template <class T>
-struct tracking_level<std::complex< T > >
-    : mpl::int_<track_never> {} ;
-
-} // serialization
-} // namespace boost
-
-#endif // BOOST_SERIALIZATION_COMPLEX_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/config.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/config.hpp
deleted file mode 100644
index ea8cb9239ed..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/config.hpp
+++ /dev/null
@@ -1,74 +0,0 @@
-#ifndef BOOST_SERIALIZATION_CONFIG_HPP
-#define BOOST_SERIALIZATION_CONFIG_HPP
-
-//  config.hpp  ---------------------------------------------//
-
-//  (c) Copyright Robert Ramey 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)
-
-//  See library home page at http://www.boost.org/libs/serialization
-
-//----------------------------------------------------------------------------// 
-
-// This header implements separate compilation features as described in
-// http://www.boost.org/more/separate_compilation.html
-
-#include <boost/config.hpp>
-#include <boost/detail/workaround.hpp>
-
-// note: this version incorporates the related code into the the 
-// the same library as BOOST_ARCHIVE.  This could change some day in the
-// future
-
-// if BOOST_SERIALIZATION_DECL is defined undefine it now:
-#ifdef BOOST_SERIALIZATION_DECL
-    #undef BOOST_SERIALIZATION_DECL
-#endif
-
-// we need to import/export our code only if the user has specifically
-// asked for it by defining either BOOST_ALL_DYN_LINK if they want all boost
-// libraries to be dynamically linked, or BOOST_SERIALIZATION_DYN_LINK
-// if they want just this one to be dynamically liked:
-#if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_SERIALIZATION_DYN_LINK)
-    #if !defined(BOOST_DYN_LINK)
-        #define BOOST_DYN_LINK
-    #endif
-    // export if this is our own source, otherwise import:
-    #if defined(BOOST_SERIALIZATION_SOURCE)
-        #define BOOST_SERIALIZATION_DECL BOOST_SYMBOL_EXPORT
-    #else
-        #define BOOST_SERIALIZATION_DECL BOOST_SYMBOL_IMPORT
-    #endif // defined(BOOST_SERIALIZATION_SOURCE)
-#endif // defined(BOOST_ALL_DYN_LINK) || defined(BOOST_SERIALIZATION_DYN_LINK)
-
-// if BOOST_SERIALIZATION_DECL isn't defined yet define it now:
-#ifndef BOOST_SERIALIZATION_DECL
-    #define BOOST_SERIALIZATION_DECL
-#endif
-
-//  enable automatic library variant selection  ------------------------------// 
-
-#if !defined(BOOST_ALL_NO_LIB) && !defined(BOOST_SERIALIZATION_NO_LIB) \
-&&  !defined(BOOST_ARCHIVE_SOURCE) && !defined(BOOST_WARCHIVE_SOURCE)  \
-&&  !defined(BOOST_SERIALIZATION_SOURCE)
-    //
-    // Set the name of our library, this will get undef'ed by auto_link.hpp
-    // once it's done with it:
-    //
-    #define BOOST_LIB_NAME boost_serialization
-    //
-    // If we're importing code from a dll, then tell auto_link.hpp about it:
-    //
-    #if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_SERIALIZATION_DYN_LINK)
-    #  define BOOST_DYN_LINK
-    #endif
-    //
-    // And include the header that does the work:
-    //
-    #include <boost/config/auto_link.hpp>
-
-#endif  
-
-#endif // BOOST_SERIALIZATION_CONFIG_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/deque.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/deque.hpp
deleted file mode 100644
index bba81364ce2..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/deque.hpp
+++ /dev/null
@@ -1,80 +0,0 @@
-#ifndef  BOOST_SERIALIZATION_DEQUE_HPP
-#define BOOST_SERIALIZATION_DEQUE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// deque.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <deque>
-
-#include <boost/config.hpp>
-
-#include <boost/archive/basic_archive.hpp>
-
-#include <boost/serialization/collections_save_imp.hpp>
-#include <boost/serialization/collections_load_imp.hpp>
-#include <boost/serialization/split_free.hpp>
-
-namespace boost { 
-namespace serialization {
-
-template<class Archive, class U, class Allocator>
-inline void save(
-    Archive & ar,
-    const std::deque<U, Allocator> &t,
-    const unsigned int /* file_version */
-){
-    boost::serialization::stl::save_collection<
-        Archive, std::deque<U, Allocator> 
-    >(ar, t);
-}
-
-template<class Archive, class U, class Allocator>
-inline void load(
-    Archive & ar,
-    std::deque<U, Allocator> &t,
-    const unsigned int /* file_version */
-){
-    const boost::archive::library_version_type library_version(
-        ar.get_library_version()
-    );
-    // retrieve number of elements
-    item_version_type item_version(0);
-    collection_size_type count;
-    ar >> BOOST_SERIALIZATION_NVP(count);
-    if(boost::archive::library_version_type(3) < library_version){
-        ar >> BOOST_SERIALIZATION_NVP(item_version);
-    }
-    stl::collection_load_impl(ar, t, count, item_version);
-}
-
-// split non-intrusive serialization function member into separate
-// non intrusive save/load member functions
-template<class Archive, class U, class Allocator>
-inline void serialize(
-    Archive & ar,
-    std::deque<U, Allocator> &t,
-    const unsigned int file_version
-){
-    boost::serialization::split_free(ar, t, file_version);
-}
-
-} // namespace serialization
-} // namespace boost
-
-#include <boost/serialization/collection_traits.hpp>
-
-BOOST_SERIALIZATION_COLLECTION_TRAITS(std::deque)
-
-#endif // BOOST_SERIALIZATION_DEQUE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/detail/is_default_constructible.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/detail/is_default_constructible.hpp
deleted file mode 100644
index 4d20b13bf3e..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/detail/is_default_constructible.hpp
+++ /dev/null
@@ -1,54 +0,0 @@
-#ifndef  BOOST_SERIALIZATION_DETAIL_IS_DEFAULT_CONSTRUCTIBLE_HPP
-#define BOOST_SERIALIZATION_DETAIL_IS_DEFAULT_CONSTRUCTIBLE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// is_default_constructible.hpp: serialization for loading stl collections
-//
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/config.hpp>
-
-#if ! defined(BOOST_NO_CXX11_HDR_TYPE_TRAITS)
-    #include <type_traits>
-    namespace boost{
-    namespace serialization {
-    namespace detail {
-
-    template<typename T>
-    struct is_default_constructible : public std::is_default_constructible<T> {};
-
-    } // detail
-    } // serializaition
-    } // boost
-#else
-    // we don't have standard library support for is_default_constructible
-    // so we fake it by using boost::has_trivial_construtor.  But this is not
-    // actually correct because it's possible that a default constructor
-    // to be non trivial. So when using this, make sure you're not using your
-    // own definition of of T() but are using the actual default one!
-    #include <boost/type_traits/has_trivial_constructor.hpp>
-    namespace boost{
-    namespace serialization {
-    namespace detail {
-
-    template<typename T>
-    struct is_default_constructible : public boost::has_trivial_constructor<T> {};
-
-    } // detail
-    } // serializaition
-    } // boost
-
-#endif
-
-
-#endif //  BOOST_SERIALIZATION_DETAIL_IS_DEFAULT_CONSTRUCTIBLE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/detail/shared_count_132.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/detail/shared_count_132.hpp
deleted file mode 100644
index a5872557cf2..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/detail/shared_count_132.hpp
+++ /dev/null
@@ -1,551 +0,0 @@
-#ifndef BOOST_DETAIL_SHARED_COUNT_132_HPP_INCLUDED
-#define BOOST_DETAIL_SHARED_COUNT_132_HPP_INCLUDED
-
-// MS compatible compilers support #pragma once
-
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-//
-//  detail/shared_count.hpp
-//
-//  Copyright (c) 2001, 2002, 2003 Peter Dimov and Multi Media Ltd.
-//
-// Distributed under the 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_SP_USE_STD_ALLOCATOR) && defined(BOOST_SP_USE_QUICK_ALLOCATOR)
-# error BOOST_SP_USE_STD_ALLOCATOR and BOOST_SP_USE_QUICK_ALLOCATOR are incompatible.
-#endif
-
-#include <boost/checked_delete.hpp>
-#include <boost/serialization/throw_exception.hpp>
-#include <boost/detail/lightweight_mutex.hpp>
-
-#if defined(BOOST_SP_USE_QUICK_ALLOCATOR)
-#include <boost/detail/quick_allocator.hpp>
-#endif
-
-#include <memory>           // std::auto_ptr, std::allocator
-#include <functional>       // std::less
-#include <exception>        // std::exception
-#include <new>              // std::bad_alloc
-#include <typeinfo>         // std::type_info in get_deleter
-#include <cstddef>          // std::size_t
-
-#include <boost/config.hpp> // msvc 6.0 needs this for warning suppression
-#if defined(BOOST_NO_STDC_NAMESPACE)
-namespace std{ 
-    using ::size_t; 
-} // namespace std
-#endif
-
-namespace boost_132 {
-
-// Debug hooks
-
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
-
-void sp_scalar_constructor_hook(void * px, std::size_t size, void * pn);
-void sp_array_constructor_hook(void * px);
-void sp_scalar_destructor_hook(void * px, std::size_t size, void * pn);
-void sp_array_destructor_hook(void * px);
-
-#endif
-
-
-// The standard library that comes with Borland C++ 5.5.1
-// defines std::exception and its members as having C calling
-// convention (-pc). When the definition of bad_weak_ptr
-// is compiled with -ps, the compiler issues an error.
-// Hence, the temporary #pragma option -pc below. The version
-// check is deliberately conservative.
-
-class bad_weak_ptr: public std::exception
-{
-public:
-
-    virtual char const * what() const throw()
-    {
-        return "boost::bad_weak_ptr";
-    }
-};
-
-namespace detail{
-
-class sp_counted_base
-{
-//private:
-
-    typedef boost::detail::lightweight_mutex mutex_type;
-
-public:
-
-    sp_counted_base(): use_count_(1), weak_count_(1)
-    {
-    }
-
-    virtual ~sp_counted_base() // nothrow
-    {
-    }
-
-    // dispose() is called when use_count_ drops to zero, to release
-    // the resources managed by *this.
-
-    virtual void dispose() = 0; // nothrow
-
-    // destruct() is called when weak_count_ drops to zero.
-
-    virtual void destruct() // nothrow
-    {
-        delete this;
-    }
-
-    virtual void * get_deleter(std::type_info const & ti) = 0;
-
-    void add_ref_copy()
-    {
-#if defined(BOOST_HAS_THREADS)
-        mutex_type::scoped_lock lock(mtx_);
-#endif
-        ++use_count_;
-    }
-
-    void add_ref_lock()
-    {
-#if defined(BOOST_HAS_THREADS)
-        mutex_type::scoped_lock lock(mtx_);
-#endif
-        if(use_count_ == 0) boost::serialization::throw_exception(bad_weak_ptr());
-        ++use_count_;
-    }
-
-    void release() // nothrow
-    {
-        {
-#if defined(BOOST_HAS_THREADS)
-            mutex_type::scoped_lock lock(mtx_);
-#endif
-            long new_use_count = --use_count_;
-
-            if(new_use_count != 0) return;
-        }
-
-        dispose();
-        weak_release();
-    }
-
-    void weak_add_ref() // nothrow
-    {
-#if defined(BOOST_HAS_THREADS)
-        mutex_type::scoped_lock lock(mtx_);
-#endif
-        ++weak_count_;
-    }
-
-    void weak_release() // nothrow
-    {
-        long new_weak_count;
-
-        {
-#if defined(BOOST_HAS_THREADS)
-            mutex_type::scoped_lock lock(mtx_);
-#endif
-            new_weak_count = --weak_count_;
-        }
-
-        if(new_weak_count == 0)
-        {
-            destruct();
-        }
-    }
-
-    long use_count() const // nothrow
-    {
-#if defined(BOOST_HAS_THREADS)
-        mutex_type::scoped_lock lock(mtx_);
-#endif
-        return use_count_;
-    }
-
-//private:
-public:
-    sp_counted_base(sp_counted_base const &);
-    sp_counted_base & operator= (sp_counted_base const &);
-
-    long use_count_;        // #shared
-    long weak_count_;       // #weak + (#shared != 0)
-
-#if defined(BOOST_HAS_THREADS) || defined(BOOST_LWM_WIN32)
-    mutable mutex_type mtx_;
-#endif
-};
-
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
-
-template<class T> void cbi_call_constructor_hook(sp_counted_base * pn, T * px, boost::checked_deleter< T > const &)
-{
-    boost::sp_scalar_constructor_hook(px, sizeof(T), pn);
-}
-
-template<class T> void cbi_call_constructor_hook(sp_counted_base *, T * px, boost::checked_array_deleter< T > const &)
-{
-    boost::sp_array_constructor_hook(px);
-}
-
-template<class P, class D> void cbi_call_constructor_hook(sp_counted_base *, P const &, D const &, long)
-{
-}
-
-template<class T> void cbi_call_destructor_hook(sp_counted_base * pn, T * px, boost::checked_deleter< T > const &)
-{
-    boost::sp_scalar_destructor_hook(px, sizeof(T), pn);
-}
-
-template<class T> void cbi_call_destructor_hook(sp_counted_base *, T * px, boost::checked_array_deleter< T > const &)
-{
-    boost::sp_array_destructor_hook(px);
-}
-
-template<class P, class D> void cbi_call_destructor_hook(sp_counted_base *, P const &, D const &, long)
-{
-}
-
-#endif
-
-//
-// Borland's Codeguard trips up over the -Vx- option here:
-//
-#ifdef __CODEGUARD__
-# pragma option push -Vx-
-#endif
-
-template<class P, class D> class sp_counted_base_impl: public sp_counted_base
-{
-//private:
-public:
-    P ptr; // copy constructor must not throw
-    D del; // copy constructor must not throw
-
-    sp_counted_base_impl(sp_counted_base_impl const &);
-    sp_counted_base_impl & operator= (sp_counted_base_impl const &);
-
-    typedef sp_counted_base_impl<P, D> this_type;
-
-public:
-
-    // pre: initial_use_count <= initial_weak_count, d(p) must not throw
-
-    sp_counted_base_impl(P p, D d): ptr(p), del(d)
-    {
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
-        detail::cbi_call_constructor_hook(this, p, d, 0);
-#endif
-    }
-
-    virtual void dispose() // nothrow
-    {
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
-        detail::cbi_call_destructor_hook(this, ptr, del, 0);
-#endif
-        del(ptr);
-    }
-
-    virtual void * get_deleter(std::type_info const & ti)
-    {
-        return ti == typeid(D)? &del: 0;
-    }
-
-#if defined(BOOST_SP_USE_STD_ALLOCATOR)
-
-    void * operator new(std::size_t)
-    {
-        return std::allocator<this_type>().allocate(1, static_cast<this_type *>(0));
-    }
-
-    void operator delete(void * p)
-    {
-        std::allocator<this_type>().deallocate(static_cast<this_type *>(p), 1);
-    }
-
-#endif
-
-#if defined(BOOST_SP_USE_QUICK_ALLOCATOR)
-
-    void * operator new(std::size_t)
-    {
-        return boost::detail::quick_allocator<this_type>::alloc();
-    }
-
-    void operator delete(void * p)
-    {
-        boost::detail::quick_allocator<this_type>::dealloc(p);
-    }
-
-#endif
-};
-
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
-
-int const shared_count_id = 0x2C35F101;
-int const   weak_count_id = 0x298C38A4;
-
-#endif
-
-class weak_count;
-
-class shared_count
-{
-//private:
-public:
-    sp_counted_base * pi_;
-
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
-    int id_;
-#endif
-
-    friend class weak_count;
-
-public:
-
-    shared_count(): pi_(0) // nothrow
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
-        , id_(shared_count_id)
-#endif
-    {
-    }
-
-    template<class P, class D> shared_count(P p, D d): pi_(0)
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
-        , id_(shared_count_id)
-#endif
-    {
-#ifndef BOOST_NO_EXCEPTIONS
-
-        try
-        {
-            pi_ = new sp_counted_base_impl<P, D>(p, d);
-        }
-        catch(...)
-        {
-            d(p); // delete p
-            throw;
-        }
-
-#else
-
-        pi_ = new sp_counted_base_impl<P, D>(p, d);
-
-        if(pi_ == 0)
-        {
-            d(p); // delete p
-            boost::serialization::throw_exception(std::bad_alloc());
-        }
-
-#endif
-    }
-
-#ifndef BOOST_NO_AUTO_PTR
-
-    // auto_ptr<Y> is special cased to provide the strong guarantee
-
-    template<class Y>
-    explicit shared_count(std::auto_ptr<Y> & r): pi_(
-        new sp_counted_base_impl<
-            Y *, 
-            boost::checked_deleter<Y>
-        >(r.get(), boost::checked_deleter<Y>()))
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
-        , id_(shared_count_id)
-#endif
-    {
-        r.release();
-    }
-
-#endif 
-
-    ~shared_count() // nothrow
-    {
-        if(pi_ != 0) pi_->release();
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
-        id_ = 0;
-#endif
-    }
-
-    shared_count(shared_count const & r): pi_(r.pi_) // nothrow
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
-        , id_(shared_count_id)
-#endif
-    {
-        if(pi_ != 0) pi_->add_ref_copy();
-    }
-
-    explicit shared_count(weak_count const & r); // throws bad_weak_ptr when r.use_count() == 0
-
-    shared_count & operator= (shared_count const & r) // nothrow
-    {
-        sp_counted_base * tmp = r.pi_;
-
-        if(tmp != pi_)
-        {
-            if(tmp != 0) tmp->add_ref_copy();
-            if(pi_ != 0) pi_->release();
-            pi_ = tmp;
-        }
-
-        return *this;
-    }
-
-    void swap(shared_count & r) // nothrow
-    {
-        sp_counted_base * tmp = r.pi_;
-        r.pi_ = pi_;
-        pi_ = tmp;
-    }
-
-    long use_count() const // nothrow
-    {
-        return pi_ != 0? pi_->use_count(): 0;
-    }
-
-    bool unique() const // nothrow
-    {
-        return use_count() == 1;
-    }
-
-    friend inline bool operator==(shared_count const & a, shared_count const & b)
-    {
-        return a.pi_ == b.pi_;
-    }
-
-    friend inline bool operator<(shared_count const & a, shared_count const & b)
-    {
-        return std::less<sp_counted_base *>()(a.pi_, b.pi_);
-    }
-
-    void * get_deleter(std::type_info const & ti) const
-    {
-        return pi_? pi_->get_deleter(ti): 0;
-    }
-};
-
-#ifdef __CODEGUARD__
-# pragma option pop
-#endif
-
-
-class weak_count
-{
-private:
-
-    sp_counted_base * pi_;
-
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
-    int id_;
-#endif
-
-    friend class shared_count;
-
-public:
-
-    weak_count(): pi_(0) // nothrow
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
-        , id_(weak_count_id)
-#endif
-    {
-    }
-
-    weak_count(shared_count const & r): pi_(r.pi_) // nothrow
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
-        , id_(shared_count_id)
-#endif
-    {
-        if(pi_ != 0) pi_->weak_add_ref();
-    }
-
-    weak_count(weak_count const & r): pi_(r.pi_) // nothrow
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
-        , id_(shared_count_id)
-#endif
-    {
-        if(pi_ != 0) pi_->weak_add_ref();
-    }
-
-    ~weak_count() // nothrow
-    {
-        if(pi_ != 0) pi_->weak_release();
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
-        id_ = 0;
-#endif
-    }
-
-    weak_count & operator= (shared_count const & r) // nothrow
-    {
-        sp_counted_base * tmp = r.pi_;
-        if(tmp != 0) tmp->weak_add_ref();
-        if(pi_ != 0) pi_->weak_release();
-        pi_ = tmp;
-
-        return *this;
-    }
-
-    weak_count & operator= (weak_count const & r) // nothrow
-    {
-        sp_counted_base * tmp = r.pi_;
-        if(tmp != 0) tmp->weak_add_ref();
-        if(pi_ != 0) pi_->weak_release();
-        pi_ = tmp;
-
-        return *this;
-    }
-
-    void swap(weak_count & r) // nothrow
-    {
-        sp_counted_base * tmp = r.pi_;
-        r.pi_ = pi_;
-        pi_ = tmp;
-    }
-
-    long use_count() const // nothrow
-    {
-        return pi_ != 0? pi_->use_count(): 0;
-    }
-
-    friend inline bool operator==(weak_count const & a, weak_count const & b)
-    {
-        return a.pi_ == b.pi_;
-    }
-
-    friend inline bool operator<(weak_count const & a, weak_count const & b)
-    {
-        return std::less<sp_counted_base *>()(a.pi_, b.pi_);
-    }
-};
-
-inline shared_count::shared_count(weak_count const & r): pi_(r.pi_)
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
-        , id_(shared_count_id)
-#endif
-{
-    if(pi_ != 0)
-    {
-        pi_->add_ref_lock();
-    }
-    else
-    {
-        boost::serialization::throw_exception(bad_weak_ptr());
-    }
-}
-
-} // namespace detail
-
-} // namespace boost
-
-BOOST_SERIALIZATION_ASSUME_ABSTRACT(boost_132::detail::sp_counted_base)
-
-#endif  // #ifndef BOOST_DETAIL_SHARED_COUNT_HPP_INCLUDED
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/detail/shared_ptr_132.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/detail/shared_ptr_132.hpp
deleted file mode 100644
index ee98b7b9449..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/detail/shared_ptr_132.hpp
+++ /dev/null
@@ -1,443 +0,0 @@
-#ifndef BOOST_SHARED_PTR_132_HPP_INCLUDED
-#define BOOST_SHARED_PTR_132_HPP_INCLUDED
-
-//
-//  shared_ptr.hpp
-//
-//  (C) Copyright Greg Colvin and Beman Dawes 1998, 1999.
-//  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)
-//
-//  See http://www.boost.org/libs/smart_ptr/shared_ptr.htm for documentation.
-//
-
-#include <boost/config.hpp>   // for broken compiler workarounds
-
-#if defined(BOOST_NO_MEMBER_TEMPLATES) && !defined(BOOST_MSVC6_MEMBER_TEMPLATES)
-#include <boost/serialization/detail/shared_ptr_nmt_132.hpp>
-#else
-
-#include <boost/assert.hpp>
-#include <boost/checked_delete.hpp>
-#include <boost/serialization/throw_exception.hpp>
-#include <boost/detail/workaround.hpp>
-
-#include <boost/serialization/access.hpp>
-#include <boost/serialization/detail/shared_count_132.hpp>
-
-#include <memory>               // for std::auto_ptr
-#include <algorithm>            // for std::swap
-#include <functional>           // for std::less
-#include <typeinfo>             // for std::bad_cast
-#include <iosfwd>               // for std::basic_ostream
-
-#ifdef BOOST_MSVC  // moved here to work around VC++ compiler crash
-# pragma warning(push)
-# pragma warning(disable:4284) // odd return type for operator->
-#endif
-
-namespace boost_132 {
-
-template<class T> class weak_ptr;
-template<class T> class enable_shared_from_this;
-
-namespace detail
-{
-
-struct static_cast_tag {};
-struct const_cast_tag {};
-struct dynamic_cast_tag {};
-struct polymorphic_cast_tag {};
-
-template<class T> struct shared_ptr_traits
-{
-    typedef T & reference;
-};
-
-template<> struct shared_ptr_traits<void>
-{
-    typedef void reference;
-};
-
-#if !defined(BOOST_NO_CV_VOID_SPECIALIZATIONS)
-
-template<> struct shared_ptr_traits<void const>
-{
-    typedef void reference;
-};
-
-template<> struct shared_ptr_traits<void volatile>
-{
-    typedef void reference;
-};
-
-template<> struct shared_ptr_traits<void const volatile>
-{
-    typedef void reference;
-};
-
-#endif
-
-// enable_shared_from_this support
-
-template<class T, class Y> void sp_enable_shared_from_this( shared_count const & pn, enable_shared_from_this< T > const * pe, Y const * px )
-{
-    if(pe != 0) pe->_internal_weak_this._internal_assign(const_cast<Y*>(px), pn);
-}
-
-inline void sp_enable_shared_from_this( shared_count const & /*pn*/, ... )
-{
-}
-
-} // namespace detail
-
-
-//
-//  shared_ptr
-//
-//  An enhanced relative of scoped_ptr with reference counted copy semantics.
-//  The object pointed to is deleted when the last shared_ptr pointing to it
-//  is destroyed or reset.
-//
-
-template<class T> class shared_ptr
-{
-private:
-    // Borland 5.5.1 specific workaround
-    typedef shared_ptr< T > this_type;
-
-public:
-
-    typedef T element_type;
-    typedef T value_type;
-    typedef T * pointer;
-    typedef typename detail::shared_ptr_traits< T >::reference reference;
-
-    shared_ptr(): px(0), pn() // never throws in 1.30+
-    {
-    }
-
-    template<class Y>
-    explicit shared_ptr(Y * p): px(p), pn(p, boost::checked_deleter<Y>()) // Y must be complete
-    {
-        detail::sp_enable_shared_from_this( pn, p, p );
-    }
-
-    //
-    // Requirements: D's copy constructor must not throw
-    //
-    // shared_ptr will release p by calling d(p)
-    //
-
-    template<class Y, class D> shared_ptr(Y * p, D d): px(p), pn(p, d)
-    {
-        detail::sp_enable_shared_from_this( pn, p, p );
-    }
-
-//  generated copy constructor, assignment, destructor are fine...
-
-//  except that Borland C++ has a bug, and g++ with -Wsynth warns
-#if defined(__GNUC__)
-    shared_ptr & operator=(shared_ptr const & r) // never throws
-    {
-        px = r.px;
-        pn = r.pn; // shared_count::op= doesn't throw
-        return *this;
-    }
-#endif
-
-    template<class Y>
-    explicit shared_ptr(weak_ptr<Y> const & r): pn(r.pn) // may throw
-    {
-        // it is now safe to copy r.px, as pn(r.pn) did not throw
-        px = r.px;
-    }
-
-    template<class Y>
-    shared_ptr(shared_ptr<Y> const & r): px(r.px), pn(r.pn) // never throws
-    {
-    }
-
-    template<class Y>
-    shared_ptr(shared_ptr<Y> const & r, detail::static_cast_tag): px(static_cast<element_type *>(r.px)), pn(r.pn)
-    {
-    }
-
-    template<class Y>
-    shared_ptr(shared_ptr<Y> const & r, detail::const_cast_tag): px(const_cast<element_type *>(r.px)), pn(r.pn)
-    {
-    }
-
-    template<class Y>
-    shared_ptr(shared_ptr<Y> const & r, detail::dynamic_cast_tag): px(dynamic_cast<element_type *>(r.px)), pn(r.pn)
-    {
-        if(px == 0) // need to allocate new counter -- the cast failed
-        {
-            pn = detail::shared_count();
-        }
-    }
-
-    template<class Y>
-    shared_ptr(shared_ptr<Y> const & r, detail::polymorphic_cast_tag): px(dynamic_cast<element_type *>(r.px)), pn(r.pn)
-    {
-        if(px == 0)
-        {
-            boost::serialization::throw_exception(std::bad_cast());
-        }
-    }
-
-#ifndef BOOST_NO_AUTO_PTR
-
-    template<class Y>
-    explicit shared_ptr(std::auto_ptr<Y> & r): px(r.get()), pn()
-    {
-        Y * tmp = r.get();
-        pn = detail::shared_count(r);
-        detail::sp_enable_shared_from_this( pn, tmp, tmp );
-    }
-
-#endif
-
-#if !defined(BOOST_MSVC) || (BOOST_MSVC > 1200)
-
-    template<class Y>
-    shared_ptr & operator=(shared_ptr<Y> const & r) // never throws
-    {
-        px = r.px;
-        pn = r.pn; // shared_count::op= doesn't throw
-        return *this;
-    }
-
-#endif
-
-#ifndef BOOST_NO_AUTO_PTR
-
-    template<class Y>
-    shared_ptr & operator=(std::auto_ptr<Y> & r)
-    {
-        this_type(r).swap(*this);
-        return *this;
-    }
-
-#endif
-
-    void reset() // never throws in 1.30+
-    {
-        this_type().swap(*this);
-    }
-
-    template<class Y> void reset(Y * p) // Y must be complete
-    {
-        BOOST_ASSERT(p == 0 || p != px); // catch self-reset errors
-        this_type(p).swap(*this);
-    }
-
-    template<class Y, class D> void reset(Y * p, D d)
-    {
-        this_type(p, d).swap(*this);
-    }
-
-    reference operator* () const // never throws
-    {
-        BOOST_ASSERT(px != 0);
-        return *px;
-    }
-
-    T * operator-> () const // never throws
-    {
-        BOOST_ASSERT(px != 0);
-        return px;
-    }
-    
-    T * get() const // never throws
-    {
-        return px;
-    }
-
-    // implicit conversion to "bool"
-
-#if defined(__SUNPRO_CC) && BOOST_WORKAROUND(__SUNPRO_CC, <= 0x530)
-
-    operator bool () const
-    {
-        return px != 0;
-    }
-
-#elif defined(__MWERKS__) && BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3003))
-    typedef T * (this_type::*unspecified_bool_type)() const;
-    
-    operator unspecified_bool_type() const // never throws
-    {
-        return px == 0? 0: &this_type::get;
-    }
-
-#else 
-
-    typedef T * this_type::*unspecified_bool_type;
-
-    operator unspecified_bool_type() const // never throws
-    {
-        return px == 0? 0: &this_type::px;
-    }
-
-#endif
-
-    // operator! is redundant, but some compilers need it
-
-    bool operator! () const // never throws
-    {
-        return px == 0;
-    }
-
-    bool unique() const // never throws
-    {
-        return pn.unique();
-    }
-
-    long use_count() const // never throws
-    {
-        return pn.use_count();
-    }
-
-    void swap(shared_ptr< T > & other) // never throws
-    {
-        std::swap(px, other.px);
-        pn.swap(other.pn);
-    }
-
-    template<class Y> bool _internal_less(shared_ptr<Y> const & rhs) const
-    {
-        return pn < rhs.pn;
-    }
-
-    void * _internal_get_deleter(std::type_info const & ti) const
-    {
-        return pn.get_deleter(ti);
-    }
-
-// Tasteless as this may seem, making all members public allows member templates
-// to work in the absence of member template friends. (Matthew Langston)
-
-#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
-
-private:
-
-    template<class Y> friend class shared_ptr;
-    template<class Y> friend class weak_ptr;
-
-
-#endif
-public: // for serialization
-    T * px;                     // contained pointer
-    detail::shared_count pn;    // reference counter
-
-};  // shared_ptr
-
-template<class T, class U> inline bool operator==(shared_ptr< T > const & a, shared_ptr<U> const & b)
-{
-    return a.get() == b.get();
-}
-
-template<class T, class U> inline bool operator!=(shared_ptr< T > const & a, shared_ptr<U> const & b)
-{
-    return a.get() != b.get();
-}
-
-template<class T, class U> inline bool operator<(shared_ptr< T > const & a, shared_ptr<U> const & b)
-{
-    return a._internal_less(b);
-}
-
-template<class T> inline void swap(shared_ptr< T > & a, shared_ptr< T > & b)
-{
-    a.swap(b);
-}
-
-template<class T, class U> shared_ptr< T > static_pointer_cast(shared_ptr<U> const & r)
-{
-    return shared_ptr< T >(r, detail::static_cast_tag());
-}
-
-template<class T, class U> shared_ptr< T > const_pointer_cast(shared_ptr<U> const & r)
-{
-    return shared_ptr< T >(r, detail::const_cast_tag());
-}
-
-template<class T, class U> shared_ptr< T > dynamic_pointer_cast(shared_ptr<U> const & r)
-{
-    return shared_ptr< T >(r, detail::dynamic_cast_tag());
-}
-
-// shared_*_cast names are deprecated. Use *_pointer_cast instead.
-
-template<class T, class U> shared_ptr< T > shared_static_cast(shared_ptr<U> const & r)
-{
-    return shared_ptr< T >(r, detail::static_cast_tag());
-}
-
-template<class T, class U> shared_ptr< T > shared_dynamic_cast(shared_ptr<U> const & r)
-{
-    return shared_ptr< T >(r, detail::dynamic_cast_tag());
-}
-
-template<class T, class U> shared_ptr< T > shared_polymorphic_cast(shared_ptr<U> const & r)
-{
-    return shared_ptr< T >(r, detail::polymorphic_cast_tag());
-}
-
-template<class T, class U> shared_ptr< T > shared_polymorphic_downcast(shared_ptr<U> const & r)
-{
-    BOOST_ASSERT(dynamic_cast<T *>(r.get()) == r.get());
-    return shared_static_cast< T >(r);
-}
-
-// get_pointer() enables boost::mem_fn to recognize shared_ptr
-
-template<class T> inline T * get_pointer(shared_ptr< T > const & p)
-{
-    return p.get();
-}
-
-// operator<<
-
-
-template<class E, class T, class Y> std::basic_ostream<E, T> & operator<< (std::basic_ostream<E, T> & os, shared_ptr<Y> const & p)
-{
-    os << p.get();
-    return os;
-}
-
-// get_deleter (experimental)
-
-#if defined(__EDG_VERSION__) && (__EDG_VERSION__ <= 238)
-
-// g++ 2.9x doesn't allow static_cast<X const *>(void *)
-// apparently EDG 2.38 also doesn't accept it
-
-template<class D, class T> D * get_deleter(shared_ptr< T > const & p)
-{
-    void const * q = p._internal_get_deleter(typeid(D));
-    return const_cast<D *>(static_cast<D const *>(q));
-}
-
-#else
-
-template<class D, class T> D * get_deleter(shared_ptr< T > const & p)
-{
-    return static_cast<D *>(p._internal_get_deleter(typeid(D)));
-}
-
-#endif
-
-} // namespace boost
-
-#ifdef BOOST_MSVC
-# pragma warning(pop)
-#endif    
-
-#endif  // #if defined(BOOST_NO_MEMBER_TEMPLATES) && !defined(BOOST_MSVC6_MEMBER_TEMPLATES)
-
-#endif  // #ifndef BOOST_SHARED_PTR_132_HPP_INCLUDED
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/detail/shared_ptr_nmt_132.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/detail/shared_ptr_nmt_132.hpp
deleted file mode 100644
index 490e7ddd3d0..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/detail/shared_ptr_nmt_132.hpp
+++ /dev/null
@@ -1,182 +0,0 @@
-#ifndef BOOST_DETAIL_SHARED_PTR_NMT_132_HPP_INCLUDED
-#define BOOST_DETAIL_SHARED_PTR_NMT_132_HPP_INCLUDED
-
-//
-//  detail/shared_ptr_nmt.hpp - shared_ptr.hpp without member templates
-//
-//  (C) Copyright Greg Colvin and Beman Dawes 1998, 1999.
-//  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)
-//
-//  See http://www.boost.org/libs/smart_ptr/shared_ptr.htm for documentation.
-//
-
-#include <boost/assert.hpp>
-#include <boost/checked_delete.hpp>
-#include <boost/serialization/throw_exception.hpp>
-#include <boost/detail/atomic_count.hpp>
-
-#ifndef BOOST_NO_AUTO_PTR
-# include <memory>          // for std::auto_ptr
-#endif
-
-#include <algorithm>        // for std::swap
-#include <functional>       // for std::less
-#include <new>              // for std::bad_alloc
-
-namespace boost
-{
-
-template<class T> class shared_ptr
-{
-private:
-
-    typedef detail::atomic_count count_type;
-
-public:
-
-    typedef T element_type;
-    typedef T value_type;
-
-    explicit shared_ptr(T * p = 0): px(p)
-    {
-#ifndef BOOST_NO_EXCEPTIONS
-
-        try  // prevent leak if new throws
-        {
-            pn = new count_type(1);
-        }
-        catch(...)
-        {
-            boost::checked_delete(p);
-            throw;
-        }
-
-#else
-
-        pn = new count_type(1);
-
-        if(pn == 0)
-        {
-            boost::checked_delete(p);
-            boost::serialization::throw_exception(std::bad_alloc());
-        }
-
-#endif
-    }
-
-    ~shared_ptr()
-    {
-        if(--*pn == 0)
-        {
-            boost::checked_delete(px);
-            delete pn;
-        }
-    }
-
-    shared_ptr(shared_ptr const & r): px(r.px)  // never throws
-    {
-        pn = r.pn;
-        ++*pn;
-    }
-
-    shared_ptr & operator=(shared_ptr const & r)
-    {
-        shared_ptr(r).swap(*this);
-        return *this;
-    }
-
-#ifndef BOOST_NO_AUTO_PTR
-
-    explicit shared_ptr(std::auto_ptr< T > & r)
-    { 
-        pn = new count_type(1); // may throw
-        px = r.release(); // fix: moved here to stop leak if new throws
-    } 
-
-    shared_ptr & operator=(std::auto_ptr< T > & r)
-    {
-        shared_ptr(r).swap(*this);
-        return *this;
-    }
-
-#endif
-
-    void reset(T * p = 0)
-    {
-        BOOST_ASSERT(p == 0 || p != px);
-        shared_ptr(p).swap(*this);
-    }
-
-    T & operator*() const  // never throws
-    {
-        BOOST_ASSERT(px != 0);
-        return *px;
-    }
-
-    T * operator->() const  // never throws
-    {
-        BOOST_ASSERT(px != 0);
-        return px;
-    }
-
-    T * get() const  // never throws
-    {
-        return px;
-    }
-
-    long use_count() const  // never throws
-    {
-        return *pn;
-    }
-
-    bool unique() const  // never throws
-    {
-        return *pn == 1;
-    }
-    
-    void swap(shared_ptr< T > & other)  // never throws
-    {
-        std::swap(px, other.px);
-        std::swap(pn, other.pn);
-    }
-
-private:
-
-    T * px;            // contained pointer
-    count_type * pn;   // ptr to reference counter
-};
-
-template<class T, class U> inline bool operator==(shared_ptr< T > const & a, shared_ptr<U> const & b)
-{
-    return a.get() == b.get();
-}
-
-template<class T, class U> inline bool operator!=(shared_ptr< T > const & a, shared_ptr<U> const & b)
-{
-    return a.get() != b.get();
-}
-
-template<class T> inline bool operator<(shared_ptr< T > const & a, shared_ptr< T > const & b)
-{
-    return std::less<T*>()(a.get(), b.get());
-}
-
-template<class T> void swap(shared_ptr< T > & a, shared_ptr< T > & b)
-{
-    a.swap(b);
-}
-
-// get_pointer() enables boost::mem_fn to recognize shared_ptr
-
-template<class T> inline T * get_pointer(shared_ptr< T > const & p)
-{
-    return p.get();
-}
-
-} // namespace boost
-
-#endif  // #ifndef BOOST_DETAIL_SHARED_PTR_NMT_132_HPP_INCLUDED
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/detail/stack_constructor.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/detail/stack_constructor.hpp
deleted file mode 100644
index ae14832c6db..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/detail/stack_constructor.hpp
+++ /dev/null
@@ -1,66 +0,0 @@
-#ifndef  BOOST_SERIALIZATION_DETAIL_STACK_CONSTRUCTOR_HPP
-#define BOOST_SERIALIZATION_DETAIL_STACK_CONSTRUCTOR_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// stack_constructor.hpp: serialization for loading stl collections
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/aligned_storage.hpp>
-#include <boost/serialization/serialization.hpp>
-
-namespace boost{
-namespace serialization {
-namespace detail {
-
-// reserve space on stack for an object of type T without actually
-// construction such an object
-template<typename T > 
-struct stack_allocate
-{
-    T * address() {
-        return static_cast<T*>(storage_.address()); 
-    }
-    T & reference() {
-        return * address();
-    }
-private:
-    typedef typename boost::aligned_storage<
-        sizeof(T), 
-        boost::alignment_of<T>::value
-    > type;
-    type storage_;
-};
-
-// construct element on the stack
-template<class Archive, class T>
-struct stack_construct : public stack_allocate<T>
-{
-    stack_construct(Archive & ar, const unsigned int version){
-        // note borland emits a no-op without the explicit namespace
-        boost::serialization::load_construct_data_adl(
-            ar, 
-            this->address(), 
-            version
-        );
-    }
-    ~stack_construct(){
-        this->address()->~T(); // undo load_construct_data above
-    }
-};
-
-} // detail
-} // serializaition
-} // boost
-
-#endif //  BOOST_SERIALIZATION_DETAIL_STACH_CONSTRUCTOR_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/ephemeral.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/ephemeral.hpp
deleted file mode 100644
index 3a422c30a35..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/ephemeral.hpp
+++ /dev/null
@@ -1,72 +0,0 @@
-#ifndef BOOST_SERIALIZATION_EPHEMERAL_HPP
-#define BOOST_SERIALIZATION_EPHEMERAL_HPP
-
-// MS compatible compilers support 
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// ephemeral_object.hpp: interface for serialization system.
-
-// (C) Copyright 2007 Matthias Troyer. 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <utility>
-
-#include <boost/config.hpp>
-#include <boost/detail/workaround.hpp>
-
-#include <boost/mpl/integral_c.hpp>
-#include <boost/mpl/integral_c_tag.hpp>
-
-#include <boost/serialization/level.hpp>
-#include <boost/serialization/tracking.hpp>
-#include <boost/serialization/split_member.hpp>
-#include <boost/serialization/base_object.hpp>
-#include <boost/serialization/traits.hpp>
-#include <boost/serialization/wrapper.hpp>
-
-namespace boost {
-namespace serialization {
-
-template<class T>
-struct ephemeral_object : 
-    public wrapper_traits<ephemeral_object<T> >
-{
-    explicit ephemeral_object(T& t) :
-        val(t)
-    {}
-
-    T & value() const {
-        return val;
-    }
-
-    const T & const_value() const {
-        return val;
-    }
-
-    template<class Archive>
-    void serialize(Archive &ar, const unsigned int) const
-    {
-       ar & val;
-    }
-
-private:
-    T & val;
-};
-
-template<class T>
-inline
-const ephemeral_object<T> ephemeral(const char * name, T & t){
-    return ephemeral_object<T>(name, t);
-}
-
-} // seralization
-} // boost
-
-#endif // BOOST_SERIALIZATION_EPHEMERAL_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/export.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/export.hpp
deleted file mode 100644
index 9eef440df42..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/export.hpp
+++ /dev/null
@@ -1,225 +0,0 @@
-#ifndef BOOST_SERIALIZATION_EXPORT_HPP
-#define BOOST_SERIALIZATION_EXPORT_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// export.hpp: set traits of classes to be serialized
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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 2006 David Abrahams - http://www.boost.org.
-// implementation of class export functionality.  This is an alternative to
-// "forward declaration" method to provoke instantiation of derived classes
-// that are to be serialized through pointers.
-
-#include <utility>
-#include <cstddef> // NULL
-
-#include <boost/config.hpp>
-#include <boost/static_assert.hpp>
-#include <boost/preprocessor/stringize.hpp>
-#include <boost/type_traits/is_polymorphic.hpp>
-
-#include <boost/mpl/assert.hpp>
-#include <boost/mpl/and.hpp>
-#include <boost/mpl/not.hpp>
-#include <boost/mpl/bool_fwd.hpp>
-
-#include <boost/serialization/extended_type_info.hpp> // for guid_defined only
-#include <boost/serialization/static_warning.hpp>
-#include <boost/serialization/assume_abstract.hpp>
-#include <boost/serialization/force_include.hpp>
-#include <boost/serialization/singleton.hpp>
-
-#include <boost/archive/detail/register_archive.hpp>
-
-#include <iostream>
-
-namespace boost {
-namespace archive {
-namespace detail {
-
-class basic_pointer_iserializer;
-class basic_pointer_oserializer;
-
-template<class Archive, class T>
-class pointer_iserializer;
-template<class Archive, class T>
-class pointer_oserializer;
-
-template <class Archive, class Serializable>
-struct export_impl
-{
-    static const basic_pointer_iserializer &
-    enable_load(mpl::true_){
-        return boost::serialization::singleton<
-            pointer_iserializer<Archive, Serializable> 
-        >::get_const_instance();
-    }
-
-    static const basic_pointer_oserializer &
-    enable_save(mpl::true_){
-        return boost::serialization::singleton<
-            pointer_oserializer<Archive, Serializable> 
-        >::get_const_instance();
-    }
-    inline static void enable_load(mpl::false_) {}
-    inline static void enable_save(mpl::false_) {}
-};
-
-// On many platforms, naming a specialization of this template is
-// enough to cause its argument to be instantiated.
-template <void(*)()>
-struct instantiate_function {};
-
-template <class Archive, class Serializable>
-struct ptr_serialization_support
-{
-# if defined(BOOST_MSVC) || defined(__SUNPRO_CC)
-    virtual BOOST_DLLEXPORT void instantiate() BOOST_USED;
-# else
-    static BOOST_DLLEXPORT void instantiate() BOOST_USED;
-    typedef instantiate_function<
-        &ptr_serialization_support::instantiate
-    > x;
-# endif
-};
-
-template <class Archive, class Serializable>
-BOOST_DLLEXPORT void 
-ptr_serialization_support<Archive,Serializable>::instantiate()
-{
-    export_impl<Archive,Serializable>::enable_save(
-        typename Archive::is_saving()
-    );
-
-    export_impl<Archive,Serializable>::enable_load(
-        typename Archive::is_loading()
-    );
-}
-
-// Note INTENTIONAL usage of anonymous namespace in header.
-// This was made this way so that export.hpp could be included
-// in other headers.  This is still under study.
-
-namespace extra_detail {
-
-template<class T>
-struct guid_initializer
-{
-    void export_guid(mpl::false_) const {
-        // generates the statically-initialized objects whose constructors
-        // register the information allowing serialization of T objects
-        // through pointers to their base classes.
-        instantiate_ptr_serialization((T*)0, 0, adl_tag());
-    }
-    void export_guid(mpl::true_) const {
-    }
-    guid_initializer const & export_guid() const {
-        BOOST_STATIC_WARNING(boost::is_polymorphic< T >::value);
-        // note: exporting an abstract base class will have no effect
-        // and cannot be used to instantitiate serialization code
-        // (one might be using this in a DLL to instantiate code)
-        //BOOST_STATIC_WARNING(! boost::serialization::is_abstract< T >::value);
-        export_guid(boost::serialization::is_abstract< T >());
-        return *this;
-    }
-};
-
-template<typename T>
-struct init_guid;
-
-} // anonymous
-} // namespace detail
-} // namespace archive
-} // namespace boost
-
-#define BOOST_CLASS_EXPORT_IMPLEMENT(T)                      \
-    namespace boost {                                        \
-    namespace archive {                                      \
-    namespace detail {                                       \
-    namespace extra_detail {                                 \
-    template<>                                               \
-    struct init_guid< T > {                                  \
-        static guid_initializer< T > const & g;              \
-    };                                                       \
-    guid_initializer< T > const & init_guid< T >::g =        \
-        ::boost::serialization::singleton<                   \
-            guid_initializer< T >                            \
-        >::get_mutable_instance().export_guid();             \
-    }}}}                                                     \
-/**/
-
-#define BOOST_CLASS_EXPORT_KEY2(T, K)          \
-namespace boost {                              \
-namespace serialization {                      \
-template<>                                     \
-struct guid_defined< T > : boost::mpl::true_ {}; \
-template<>                                     \
-inline const char * guid< T >(){                 \
-    return K;                                  \
-}                                              \
-} /* serialization */                          \
-} /* boost */                                  \
-/**/
-
-#define BOOST_CLASS_EXPORT_KEY(T)                                      \
-    BOOST_CLASS_EXPORT_KEY2(T, BOOST_PP_STRINGIZE(T))                                                                  \
-/**/
-
-#define BOOST_CLASS_EXPORT_GUID(T, K)                                  \
-BOOST_CLASS_EXPORT_KEY2(T, K)                                          \
-BOOST_CLASS_EXPORT_IMPLEMENT(T)                                        \
-/**/
-
-#if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3205))
-
-// CodeWarrior fails to construct static members of class templates
-// when they are instantiated from within templates, so on that
-// compiler we ask users to specifically register base/derived class
-// relationships for exported classes.  On all other compilers, use of
-// this macro is entirely optional.
-# define BOOST_SERIALIZATION_MWERKS_BASE_AND_DERIVED(Base,Derived)             \
-namespace {                                                                    \
-  static int BOOST_PP_CAT(boost_serialization_mwerks_init_, __LINE__) =        \
-  (::boost::archive::detail::instantiate_ptr_serialization((Derived*)0,0), 3); \
-  static int BOOST_PP_CAT(boost_serialization_mwerks_init2_, __LINE__) = (     \
-      ::boost::serialization::void_cast_register((Derived*)0,(Base*)0)         \
-    , 3);                                                                      \
-}
-
-#else
-
-# define BOOST_SERIALIZATION_MWERKS_BASE_AND_DERIVED(Base,Derived)
-
-#endif 
-
-// check for unnecessary export.  T isn't polymorphic so there is no
-// need to export it.
-#define BOOST_CLASS_EXPORT_CHECK(T)                              \
-    BOOST_STATIC_WARNING(                                        \
-        boost::is_polymorphic<U>::value                          \
-    );                                                           \
-    /**/
-
-// the default exportable class identifier is the class name
-// the default list of archives types for which code id generated
-// are the originally included with this serialization system
-#define BOOST_CLASS_EXPORT(T)                   \
-    BOOST_CLASS_EXPORT_GUID(                    \
-        T,                                      \
-        BOOST_PP_STRINGIZE(T)                   \
-    )                                           \
-    /**/
-
-#endif // BOOST_SERIALIZATION_EXPORT_HPP
-
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/extended_type_info.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/extended_type_info.hpp
deleted file mode 100644
index bb2a190d465..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/extended_type_info.hpp
+++ /dev/null
@@ -1,116 +0,0 @@
-#ifndef BOOST_SERIALIZATION_EXTENDED_TYPE_INFO_HPP
-#define BOOST_SERIALIZATION_EXTENDED_TYPE_INFO_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// extended_type_info.hpp: interface for portable version of type_info
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-// for now, extended type info is part of the serialization libraries
-// this could change in the future.
-#include <cstdarg>
-#include <boost/assert.hpp>
-#include <cstddef> // NULL
-#include <boost/config.hpp>
-#include <boost/noncopyable.hpp>
-#include <boost/mpl/bool.hpp>
-
-#include <boost/serialization/config.hpp>
-#include <boost/config/abi_prefix.hpp> // must be the last header
-#ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable : 4251 4231 4660 4275)
-#endif
-
-#define BOOST_SERIALIZATION_MAX_KEY_SIZE 128
-
-namespace boost { 
-namespace serialization {
-
-namespace void_cast_detail{
-    class void_caster;
-}
-
-class BOOST_SYMBOL_VISIBLE extended_type_info :
-    private boost::noncopyable
-{
-private:
-    friend class boost::serialization::void_cast_detail::void_caster;
-
-    // used to uniquely identify the type of class derived from this one
-    // so that different derivations of this class can be simultaneously
-    // included in implementation of sets and maps.
-    const unsigned int m_type_info_key;
-    virtual bool is_less_than(const extended_type_info & /*rhs*/) const = 0;
-    virtual bool is_equal(const extended_type_info & /*rhs*/) const = 0;
-    const char * m_key;
-
-protected:
-    BOOST_SERIALIZATION_DECL void key_unregister() const;
-    BOOST_SERIALIZATION_DECL void key_register() const;
-    // this class can't be used as is. It's just the 
-    // common functionality for all type_info replacement
-    // systems.  Hence, make these protected
-    BOOST_SERIALIZATION_DECL extended_type_info(
-        const unsigned int type_info_key,
-        const char * key
-    );
-    virtual BOOST_SERIALIZATION_DECL ~extended_type_info();
-public:
-    const char * get_key() const {
-        return m_key;
-    }
-    virtual const char * get_debug_info() const = 0;
-    BOOST_SERIALIZATION_DECL bool operator<(const extended_type_info &rhs) const;
-    BOOST_SERIALIZATION_DECL bool operator==(const extended_type_info &rhs) const;
-    bool operator!=(const extended_type_info &rhs) const {
-        return !(operator==(rhs));
-    }
-    // note explicit "export" of static function to work around
-    // gcc 4.5 mingw error
-    static BOOST_SERIALIZATION_DECL const extended_type_info *
-    find(const char *key);
-    // for plugins
-    virtual void * construct(unsigned int /*count*/ = 0, ...) const = 0;
-    virtual void destroy(void const * const /*p*/) const = 0;
-};
-
-template<class T>
-struct guid_defined : boost::mpl::false_ {};
-
-namespace ext {
-    template <typename T>
-    struct guid_impl
-    {
-        static inline const char * call()
-        {
-            return NULL;
-        }
-    };
-}
-
-template<class T>
-inline const char * guid(){
-    return ext::guid_impl<T>::call();
-}
-
-} // namespace serialization 
-} // namespace boost
-
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
-
-#include <boost/config/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
-
-#endif // BOOST_SERIALIZATION_EXTENDED_TYPE_INFO_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/extended_type_info_no_rtti.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/extended_type_info_no_rtti.hpp
deleted file mode 100644
index aaa8b44459b..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/extended_type_info_no_rtti.hpp
+++ /dev/null
@@ -1,182 +0,0 @@
-#ifndef BOOST_EXTENDED_TYPE_INFO_NO_RTTI_HPP
-#define BOOST_EXTENDED_TYPE_INFO_NO_RTTI_HPP
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-// extended_type_info_no_rtti.hpp: implementation for version that depends
-// on runtime typing (rtti - typeid) but uses a user specified string
-// as the portable class identifier.
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-#include <boost/assert.hpp>
-
-#include <boost/config.hpp>
-#include <boost/static_assert.hpp>
-
-#include <boost/mpl/if.hpp>
-#include <boost/type_traits/is_polymorphic.hpp>
-#include <boost/type_traits/remove_const.hpp>
-
-#include <boost/serialization/static_warning.hpp>
-#include <boost/serialization/singleton.hpp>
-#include <boost/serialization/extended_type_info.hpp>
-#include <boost/serialization/factory.hpp>
-#include <boost/serialization/throw_exception.hpp>
-
-#include <boost/serialization/config.hpp>
-// hijack serialization access
-#include <boost/serialization/access.hpp>
-
-#include <boost/config/abi_prefix.hpp> // must be the last header
-#ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable : 4251 4231 4660 4275 4511 4512)
-#endif
-
-namespace boost {
-namespace serialization {
-///////////////////////////////////////////////////////////////////////
-// define a special type_info that doesn't depend on rtti which is not
-// available in all situations.
-
-namespace no_rtti_system {
-
-// common base class to share type_info_key.  This is used to 
-// identify the method used to keep track of the extended type
-class BOOST_SYMBOL_VISIBLE extended_type_info_no_rtti_0 :
-    public extended_type_info
-{
-protected:
-    BOOST_SERIALIZATION_DECL extended_type_info_no_rtti_0(const char * key);
-    BOOST_SERIALIZATION_DECL ~extended_type_info_no_rtti_0();
-public:
-    virtual BOOST_SERIALIZATION_DECL bool
-    is_less_than(const boost::serialization::extended_type_info &rhs) const ;
-    virtual BOOST_SERIALIZATION_DECL bool
-    is_equal(const boost::serialization::extended_type_info &rhs) const ;
-};
-
-} // no_rtti_system
-
-template<class T>
-class extended_type_info_no_rtti : 
-    public no_rtti_system::extended_type_info_no_rtti_0,
-    public singleton<extended_type_info_no_rtti< T > >
-{
-    template<bool tf>
-    struct action {
-        struct defined {
-            static const char * invoke(){
-                return guid< T >();
-            }
-        };
-        struct undefined {
-            // if your program traps here - you failed to 
-            // export a guid for this type.  the no_rtti
-            // system requires export for types serialized
-            // as pointers.
-            BOOST_STATIC_ASSERT(0 == sizeof(T));
-            static const char * invoke();
-        };
-        static const char * invoke(){
-            typedef 
-                typename boost::mpl::if_c<
-                    tf,
-                    defined,
-                    undefined
-                >::type type;
-            return type::invoke();
-        }
-    };
-public:
-    extended_type_info_no_rtti() :
-        no_rtti_system::extended_type_info_no_rtti_0(get_key())
-    {
-        key_register();
-    }
-    ~extended_type_info_no_rtti(){
-        key_unregister();
-    }
-    const extended_type_info *
-    get_derived_extended_type_info(const T & t) const {
-        // find the type that corresponds to the most derived type.
-        // this implementation doesn't depend on typeid() but assumes
-        // that the specified type has a function of the following signature.
-        // A common implemention of such a function is to define as a virtual
-        // function. So if the is not a polymporphic type it's likely an error
-        BOOST_STATIC_WARNING(boost::is_polymorphic< T >::value);
-        const char * derived_key = t.get_key();
-        BOOST_ASSERT(NULL != derived_key);
-        return boost::serialization::extended_type_info::find(derived_key);
-    }
-    const char * get_key() const{
-        return action<guid_defined< T >::value >::invoke();
-    }
-    virtual const char * get_debug_info() const{
-        return action<guid_defined< T >::value >::invoke();
-    }
-    virtual void * construct(unsigned int count, ...) const{
-        // count up the arguments
-        std::va_list ap;
-        va_start(ap, count);
-        switch(count){
-        case 0:
-            return factory<typename boost::remove_const< T >::type, 0>(ap);
-        case 1:
-            return factory<typename boost::remove_const< T >::type, 1>(ap);
-        case 2:
-            return factory<typename boost::remove_const< T >::type, 2>(ap);
-        case 3:
-            return factory<typename boost::remove_const< T >::type, 3>(ap);
-        case 4:
-            return factory<typename boost::remove_const< T >::type, 4>(ap);
-        default:
-            BOOST_ASSERT(false); // too many arguments
-            // throw exception here?
-            return NULL;
-        }
-    }
-    virtual void destroy(void const * const p) const{
-        boost::serialization::access::destroy(
-            static_cast<T const *>(p)
-        );
-        //delete static_cast<T const * const>(p) ;
-    }
-};
-
-} // namespace serialization
-} // namespace boost
-
-///////////////////////////////////////////////////////////////////////////////
-// If no other implementation has been designated as default, 
-// use this one.  To use this implementation as the default, specify it
-// before any of the other headers.
-
-#ifndef BOOST_SERIALIZATION_DEFAULT_TYPE_INFO
-    #define BOOST_SERIALIZATION_DEFAULT_TYPE_INFO
-    namespace boost {
-    namespace serialization {
-    template<class T>
-    struct extended_type_info_impl {
-        typedef typename 
-            boost::serialization::extended_type_info_no_rtti< T > type;
-    };
-    } // namespace serialization
-    } // namespace boost
-#endif
-
-#ifdef BOOST_MSVC
-#  pragma warning(pop)
-#endif
-#include <boost/config/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
-
-#endif // BOOST_EXTENDED_TYPE_INFO_NO_RTTI_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/extended_type_info_typeid.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/extended_type_info_typeid.hpp
deleted file mode 100644
index 8ee591b3169..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/extended_type_info_typeid.hpp
+++ /dev/null
@@ -1,167 +0,0 @@
-#ifndef BOOST_SERIALIZATION_EXTENDED_TYPE_INFO_TYPEID_HPP
-#define BOOST_SERIALIZATION_EXTENDED_TYPE_INFO_TYPEID_HPP
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-// extended_type_info_typeid.hpp: implementation for version that depends
-// on runtime typing (rtti - typeid) but uses a user specified string
-// as the portable class identifier.
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <typeinfo>
-#include <cstdarg>
-#include <boost/assert.hpp>
-#include <boost/config.hpp>
-
-#include <boost/static_assert.hpp>
-#include <boost/serialization/static_warning.hpp>
-#include <boost/type_traits/is_polymorphic.hpp>
-#include <boost/type_traits/remove_const.hpp>
-
-#include <boost/serialization/config.hpp>
-#include <boost/serialization/singleton.hpp>
-#include <boost/serialization/extended_type_info.hpp>
-#include <boost/serialization/factory.hpp>
-
-// hijack serialization access
-#include <boost/serialization/access.hpp>
-
-#include <boost/mpl/if.hpp>
-
-#include <boost/config/abi_prefix.hpp> // must be the last header
-
-#ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable : 4251 4231 4660 4275 4511 4512)
-#endif
-
-namespace boost {
-namespace serialization {
-namespace typeid_system {
-
-class BOOST_SYMBOL_VISIBLE extended_type_info_typeid_0 :
-    public extended_type_info
-{
-    virtual const char * get_debug_info() const {
-        if(static_cast<const std::type_info *>(0) == m_ti)
-            return static_cast<const char *>(0);
-        return m_ti->name();
-    }
-protected:
-    const std::type_info * m_ti;
-    BOOST_SERIALIZATION_DECL extended_type_info_typeid_0(const char * key);
-    BOOST_SERIALIZATION_DECL ~extended_type_info_typeid_0();
-    BOOST_SERIALIZATION_DECL void type_register(const std::type_info & ti);
-    BOOST_SERIALIZATION_DECL void type_unregister();
-    BOOST_SERIALIZATION_DECL const extended_type_info *
-    get_extended_type_info(const std::type_info & ti) const;
-public:
-    virtual BOOST_SERIALIZATION_DECL bool
-    is_less_than(const extended_type_info &rhs) const;
-    virtual BOOST_SERIALIZATION_DECL bool
-    is_equal(const extended_type_info &rhs) const;
-    const std::type_info & get_typeid() const {
-        return *m_ti;
-    }
-};
-
-} // typeid_system
-
-template<class T>
-class extended_type_info_typeid : 
-    public typeid_system::extended_type_info_typeid_0,
-    public singleton<extended_type_info_typeid< T > >
-{
-public:
-    extended_type_info_typeid() :
-        typeid_system::extended_type_info_typeid_0(
-            boost::serialization::guid< T >()
-        )
-    {
-        type_register(typeid(T));
-        key_register();
-    }
-    ~extended_type_info_typeid(){
-        key_unregister();
-        type_unregister();
-    }
-    // get the eti record for the true type of this record
-    // relying upon standard type info implemenation (rtti)
-    const extended_type_info *
-    get_derived_extended_type_info(const T & t) const {
-        // note: this implementation - based on usage of typeid (rtti)
-        // only does something if the class has at least one virtual function.
-        BOOST_STATIC_WARNING(boost::is_polymorphic< T >::value);
-        return 
-            typeid_system::extended_type_info_typeid_0::get_extended_type_info(
-                typeid(t)
-            );
-    }
-    const char * get_key() const {
-        return boost::serialization::guid< T >();
-    }
-    virtual void * construct(unsigned int count, ...) const{
-        // count up the arguments
-        std::va_list ap;
-        va_start(ap, count);
-        switch(count){
-        case 0:
-            return factory<typename boost::remove_const< T >::type, 0>(ap);
-        case 1:
-            return factory<typename boost::remove_const< T >::type, 1>(ap);
-        case 2:
-            return factory<typename boost::remove_const< T >::type, 2>(ap);
-        case 3:
-            return factory<typename boost::remove_const< T >::type, 3>(ap);
-        case 4:
-            return factory<typename boost::remove_const< T >::type, 4>(ap);
-        default:
-            BOOST_ASSERT(false); // too many arguments
-            // throw exception here?
-            return NULL;
-        }
-    }
-    virtual void destroy(void const * const p) const {
-        boost::serialization::access::destroy(
-            static_cast<T const *>(p)
-        );
-        //delete static_cast<T const * const>(p);
-    }
-};
-
-} // namespace serialization
-} // namespace boost
-
-///////////////////////////////////////////////////////////////////////////////
-// If no other implementation has been designated as default, 
-// use this one.  To use this implementation as the default, specify it
-// before any of the other headers.
-#ifndef BOOST_SERIALIZATION_DEFAULT_TYPE_INFO
-    #define BOOST_SERIALIZATION_DEFAULT_TYPE_INFO
-    namespace boost {
-    namespace serialization {
-    template<class T>
-    struct extended_type_info_impl {
-        typedef typename 
-            boost::serialization::extended_type_info_typeid< T > type;
-    };
-    } // namespace serialization
-    } // namespace boost
-#endif
-
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
-#include <boost/config/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
-
-#endif // BOOST_SERIALIZATION_EXTENDED_TYPE_INFO_TYPEID_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/factory.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/factory.hpp
deleted file mode 100644
index 2db7e7e36c3..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/factory.hpp
+++ /dev/null
@@ -1,102 +0,0 @@
-#ifndef BOOST_SERIALIZATION_FACTORY_HPP
-#define BOOST_SERIALIZATION_FACTORY_HPP
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-// factory.hpp: create an instance from an extended_type_info instance.
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <cstdarg> // valist
-#include <cstddef> // NULL
-
-#include <boost/preprocessor/control/if.hpp> 
-#include <boost/preprocessor/comparison/greater.hpp>
-#include <boost/assert.hpp>
-
-namespace std{
-    #if defined(__LIBCOMO__)
-        using ::va_list;
-    #endif
-} // namespace std
-
-namespace boost {
-namespace serialization {
-
-// default implementation does nothing.
-template<class T, int N>
-T * factory(std::va_list){
-    BOOST_ASSERT(false);
-    // throw exception here?
-    return NULL;
-}
-
-} // namespace serialization
-} // namespace boost
-
-#define BOOST_SERIALIZATION_FACTORY(N, T, A0, A1, A2, A3) \
-namespace boost {                                         \
-namespace serialization {                                 \
-    template<>                                            \
-    T * factory<T, N>(std::va_list ap){                   \
-        BOOST_PP_IF(BOOST_PP_GREATER(N, 0)                \
-            , A0 a0 = va_arg(ap, A0);, BOOST_PP_EMPTY())  \
-        BOOST_PP_IF(BOOST_PP_GREATER(N, 1)                \
-            , A1 a1 = va_arg(ap, A1);, BOOST_PP_EMPTY())  \
-        BOOST_PP_IF(BOOST_PP_GREATER(N, 2)                \
-            , A2 a2 = va_arg(ap, A2);, BOOST_PP_EMPTY())  \
-        BOOST_PP_IF(BOOST_PP_GREATER(N, 3)                \
-            , A3 a3 = va_arg(ap, A3);, BOOST_PP_EMPTY())  \
-        return new T(                                     \
-            BOOST_PP_IF(BOOST_PP_GREATER(N, 0)            \
-                , a0, BOOST_PP_EMPTY())                   \
-            BOOST_PP_IF(BOOST_PP_GREATER(N, 1))           \
-                , BOOST_PP_COMMA, BOOST_PP_EMPTY)()       \
-            BOOST_PP_IF(BOOST_PP_GREATER(N, 1)            \
-                , a1, BOOST_PP_EMPTY())                   \
-            BOOST_PP_IF(BOOST_PP_GREATER(N, 2))           \
-                , BOOST_PP_COMMA, BOOST_PP_EMPTY)()       \
-            BOOST_PP_IF(BOOST_PP_GREATER(N, 2)            \
-                , a2, BOOST_PP_EMPTY())                   \
-            BOOST_PP_IF(BOOST_PP_GREATER(N, 3))           \
-                , BOOST_PP_COMMA, BOOST_PP_EMPTY)()       \
-            BOOST_PP_IF(BOOST_PP_GREATER(N, 3)            \
-                , a3, BOOST_PP_EMPTY())                   \
-        );                                                \
-    }                                                     \
-}                                                         \
-}   /**/
-
-#define BOOST_SERIALIZATION_FACTORY_4(T, A0, A1, A2, A3) \
-    BOOST_SERIALIZATION_FACTORY(4, T, A0, A1, A2, A3)
-
-#define BOOST_SERIALIZATION_FACTORY_3(T, A0, A1, A2)     \
-    BOOST_SERIALIZATION_FACTORY(3, T, A0, A1, A2, 0)
-
-#define BOOST_SERIALIZATION_FACTORY_2(T, A0, A1)         \
-    BOOST_SERIALIZATION_FACTORY(2, T, A0, A1, 0, 0)
-
-#define BOOST_SERIALIZATION_FACTORY_1(T, A0)             \
-    BOOST_SERIALIZATION_FACTORY(1, T, A0, 0, 0, 0)
-
-#define BOOST_SERIALIZATION_FACTORY_0(T)                 \
-namespace boost {                                        \
-namespace serialization {                                \
-    template<>                                           \
-    T * factory<T, 0>(std::va_list){                     \
-        return new T();                                  \
-    }                                                    \
-}                                                        \
-}                                                        \
-/**/
-
-#endif // BOOST_SERIALIZATION_FACTORY_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/force_include.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/force_include.hpp
deleted file mode 100644
index 55ab79d0d58..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/force_include.hpp
+++ /dev/null
@@ -1,55 +0,0 @@
-#ifndef BOOST_SERIALIZATION_FORCE_INCLUDE_HPP
-#define BOOST_SERIALIZATION_FORCE_INCLUDE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// force_include.hpp:
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/config.hpp>
-
-// the following help macro is to guarentee that certain coded
-// is not removed by over-eager linker optimiser.  In certain cases
-// we create static objects must be created but are actually never
-// referenced - creation has a side-effect such as global registration
-// which is important to us. We make an effort to refer these objects
-// so that a smart linker won't remove them as being unreferenced.
-// In microsoft compilers, inlining the code that does the referring
-// means the code gets lost and the static object is not included
-// in the library and hence never registered.  This manifests itself
-// in an ungraceful crash at runtime when (and only when) built in
-// release mode.
-
-#if defined(BOOST_HAS_DECLSPEC) && !defined(__COMO__)
-#   define BOOST_DLLEXPORT __declspec(dllexport)
-#elif ! defined(_WIN32) && ! defined(_WIN64)
-#   if defined(__MWERKS__)
-#       define BOOST_DLLEXPORT __declspec(dllexport)
-#   elif defined(__GNUC__) && (__GNUC__ >= 3)
-#       define BOOST_USED __attribute__ ((__used__))
-#   elif defined(__IBMCPP__) && (__IBMCPP__ >= 1110)
-#       define BOOST_USED __attribute__ ((__used__))
-#   elif defined(__INTEL_COMPILER) && (BOOST_INTEL_CXX_VERSION >= 800)
-#       define BOOST_USED __attribute__ ((__used__))
-#   endif
-#endif
-
-#ifndef BOOST_USED
-#    define BOOST_USED
-#endif
-
-#ifndef BOOST_DLLEXPORT
-#    define BOOST_DLLEXPORT
-#endif
-
-#endif // BOOST_SERIALIZATION_FORCE_INCLUDE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/forward_list.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/forward_list.hpp
deleted file mode 100644
index b8a3c20a6ea..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/forward_list.hpp
+++ /dev/null
@@ -1,124 +0,0 @@
-#ifndef BOOST_SERIALIZATION_FORWARD_LIST_HPP
-#define BOOST_SERIALIZATION_FORWARD_LIST_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// forward_list.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/config.hpp>
-
-#include <forward_list>
-#include <iterator>  // distance
-
-#include <boost/serialization/collections_save_imp.hpp>
-#include <boost/serialization/collections_load_imp.hpp>
-#include <boost/archive/detail/basic_iarchive.hpp>
-#include <boost/serialization/nvp.hpp>
-#include <boost/serialization/collection_size_type.hpp>
-#include <boost/serialization/item_version_type.hpp>
-#include <boost/serialization/split_free.hpp>
-#include <boost/serialization/detail/stack_constructor.hpp>
-#include <boost/serialization/detail/is_default_constructible.hpp>
-#include <boost/move/utility_core.hpp>
-
-namespace boost { 
-namespace serialization {
-
-template<class Archive, class U, class Allocator>
-inline void save(
-    Archive & ar,
-    const std::forward_list<U, Allocator> &t,
-    const unsigned int /*file_version*/
-){
-    const collection_size_type count(std::distance(t.cbegin(), t.cend()));
-    boost::serialization::stl::save_collection<
-        Archive,
-        std::forward_list<U, Allocator>
-    >(ar, t, count);
-}
-
-namespace stl {
-
-template<
-    class Archive,
-    class T,
-    class Allocator
->
-typename boost::disable_if<
-    typename detail::is_default_constructible<
-        typename std::forward_list<T, Allocator>::value_type
-    >,
-    void
->::type
-collection_load_impl(
-    Archive & ar,
-    std::forward_list<T, Allocator> &t,
-    collection_size_type count,
-    item_version_type item_version
-){
-    t.clear();
-    boost::serialization::detail::stack_construct<Archive, T> u(ar, item_version);
-    ar >> boost::serialization::make_nvp("item", u.reference());
-    t.push_front(boost::move(u.reference()));
-    typename std::forward_list<T, Allocator>::iterator last;
-    last = t.begin();
-    ar.reset_object_address(&(*t.begin()) , & u.reference());
-    while(--count > 0){
-        detail::stack_construct<Archive, T> u(ar, item_version);
-        ar >> boost::serialization::make_nvp("item", u.reference());
-        last = t.insert_after(last, boost::move(u.reference()));
-        ar.reset_object_address(&(*last) , & u.reference());
-    }
-}
-
-} // stl
-
-template<class Archive, class U, class Allocator>
-inline void load(
-    Archive & ar,
-    std::forward_list<U, Allocator> &t,
-    const unsigned int /*file_version*/
-){
-    const boost::archive::library_version_type library_version(
-        ar.get_library_version()
-    );
-    // retrieve number of elements
-    item_version_type item_version(0);
-    collection_size_type count;
-    ar >> BOOST_SERIALIZATION_NVP(count);
-    if(boost::archive::library_version_type(3) < library_version){
-        ar >> BOOST_SERIALIZATION_NVP(item_version);
-    }
-    stl::collection_load_impl(ar, t, count, item_version);
-}
-
-// split non-intrusive serialization function member into separate
-// non intrusive save/load member functions
-template<class Archive, class U, class Allocator>
-inline void serialize(
-    Archive & ar,
-    std::forward_list<U, Allocator> &t,
-    const unsigned int file_version
-){
-    boost::serialization::split_free(ar, t, file_version);
-}
-
-} // serialization
-} // namespace boost
-
-#include <boost/serialization/collection_traits.hpp>
-
-BOOST_SERIALIZATION_COLLECTION_TRAITS(std::forward_list)
-
-#endif  // BOOST_SERIALIZATION_FORWARD_LIST_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/hash_collections_load_imp.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/hash_collections_load_imp.hpp
deleted file mode 100644
index 88def8f1aa4..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/hash_collections_load_imp.hpp
+++ /dev/null
@@ -1,77 +0,0 @@
-#ifndef BOOST_SERIALIZATION_HASH_COLLECTIONS_LOAD_IMP_HPP
-#define BOOST_SERIALIZATION_HASH_COLLECTIONS_LOAD_IMP_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-# pragma warning (disable : 4786) // too long name, harmless warning
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// hash_collections_load_imp.hpp: serialization for loading stl collections
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-// helper function templates for serialization of hashed collections
-#include <boost/config.hpp>
-#include <boost/archive/detail/basic_iarchive.hpp>
-#include <boost/serialization/nvp.hpp>
-#include <boost/serialization/collection_size_type.hpp>
-#include <boost/serialization/item_version_type.hpp>
-
-namespace boost{
-namespace serialization {
-namespace stl {
-
-//////////////////////////////////////////////////////////////////////
-// implementation of serialization for STL containers
-//
-template<class Archive, class Container, class InputFunction>
-inline void load_hash_collection(Archive & ar, Container &s)
-{
-    collection_size_type count;
-    collection_size_type bucket_count;
-    boost::serialization::item_version_type item_version(0);
-    boost::archive::library_version_type library_version(
-        ar.get_library_version()
-    );
-    // retrieve number of elements
-    if(boost::archive::library_version_type(6) != library_version){
-        ar >> BOOST_SERIALIZATION_NVP(count);
-        ar >> BOOST_SERIALIZATION_NVP(bucket_count);
-    }
-    else{
-        // note: fixup for error in version 6.  collection size was
-        // changed to size_t BUT for hashed collections it was implemented
-        // as an unsigned int.  This should be a problem only on win64 machines
-        // but I'll leave it for everyone just in case.
-        unsigned int c;
-        unsigned int bc;
-        ar >> BOOST_SERIALIZATION_NVP(c);
-        count = c;
-        ar >> BOOST_SERIALIZATION_NVP(bc);
-        bucket_count = bc;
-    }
-    if(boost::archive::library_version_type(3) < library_version){
-        ar >> BOOST_SERIALIZATION_NVP(item_version);
-    }
-    s.clear();
-    #if ! defined(__MWERKS__)
-    s.resize(bucket_count);
-    #endif
-    InputFunction ifunc;
-    while(count-- > 0){
-        ifunc(ar, s, item_version);
-    }
-}
-
-} // namespace stl 
-} // namespace serialization
-} // namespace boost
-
-#endif //BOOST_SERIALIZATION_HASH_COLLECTIONS_LOAD_IMP_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/hash_collections_save_imp.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/hash_collections_save_imp.hpp
deleted file mode 100644
index 65dfe83f16e..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/hash_collections_save_imp.hpp
+++ /dev/null
@@ -1,97 +0,0 @@
-#ifndef BOOST_SERIALIZATION_HASH_COLLECTIONS_SAVE_IMP_HPP
-#define BOOST_SERIALIZATION_HASH_COLLECTIONS_SAVE_IMP_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// hash_collections_save_imp.hpp: serialization for stl collections
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-// helper function templates for serialization of collections
-
-#include <boost/config.hpp>
-#include <boost/serialization/nvp.hpp>
-#include <boost/serialization/serialization.hpp>
-#include <boost/serialization/version.hpp>
-#include <boost/serialization/collection_size_type.hpp>
-#include <boost/serialization/item_version_type.hpp>
-
-namespace boost{
-namespace serialization {
-namespace stl {
-
-//////////////////////////////////////////////////////////////////////
-// implementation of serialization for STL containers
-//
-
-template<class Archive, class Container>
-inline void save_hash_collection(Archive & ar, const Container &s)
-{
-    collection_size_type count(s.size());
-    const collection_size_type bucket_count(s.bucket_count());
-    const item_version_type item_version(
-        version<typename Container::value_type>::value
-    );
-
-    #if 0
-    /* should only be necessary to create archives of previous versions
-     * which is not currently supported.  So for now comment this out
-     */
-    boost::archive::library_version_type library_version(
-        ar.get_library_version()
-    );
-    // retrieve number of elements
-    if(boost::archive::library_version_type(6) != library_version){
-        ar << BOOST_SERIALIZATION_NVP(count);
-        ar << BOOST_SERIALIZATION_NVP(bucket_count);
-    }
-    else{
-        // note: fixup for error in version 6.  collection size was
-        // changed to size_t BUT for hashed collections it was implemented
-        // as an unsigned int.  This should be a problem only on win64 machines
-        // but I'll leave it for everyone just in case.
-        const unsigned int c = count;
-        const unsigned int bc = bucket_count;
-        ar << BOOST_SERIALIZATION_NVP(c);
-        ar << BOOST_SERIALIZATION_NVP(bc);
-    }
-    if(boost::archive::library_version_type(3) < library_version){
-        // record number of elements
-        // make sure the target type is registered so we can retrieve
-        // the version when we load
-        ar << BOOST_SERIALIZATION_NVP(item_version);
-    }
-    #else
-        ar << BOOST_SERIALIZATION_NVP(count);
-        ar << BOOST_SERIALIZATION_NVP(bucket_count);
-        ar << BOOST_SERIALIZATION_NVP(item_version);
-    #endif
-
-    typename Container::const_iterator it = s.begin();
-    while(count-- > 0){
-        // note borland emits a no-op without the explicit namespace
-        boost::serialization::save_construct_data_adl(
-            ar, 
-            &(*it), 
-            boost::serialization::version<
-                typename Container::value_type
-            >::value
-        );
-        ar << boost::serialization::make_nvp("item", *it++);
-    }
-}
-
-} // namespace stl 
-} // namespace serialization
-} // namespace boost
-
-#endif //BOOST_SERIALIZATION_HASH_COLLECTIONS_SAVE_IMP_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/hash_map.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/hash_map.hpp
deleted file mode 100644
index 22626db6838..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/hash_map.hpp
+++ /dev/null
@@ -1,232 +0,0 @@
-#ifndef  BOOST_SERIALIZATION_HASH_MAP_HPP
-#define BOOST_SERIALIZATION_HASH_MAP_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// serialization/hash_map.hpp:
-// serialization for stl hash_map templates
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/config.hpp>
-#ifdef BOOST_HAS_HASH
-#include BOOST_HASH_MAP_HEADER
-
-#include <boost/serialization/utility.hpp>
-#include <boost/serialization/hash_collections_save_imp.hpp>
-#include <boost/serialization/hash_collections_load_imp.hpp>
-#include <boost/serialization/split_free.hpp>
-#include <boost/move/utility_core.hpp>
-
-namespace boost { 
-namespace serialization {
-
-namespace stl {
-
-// map input
-template<class Archive, class Container>
-struct archive_input_hash_map
-{
-    inline void operator()(
-        Archive &ar, 
-        Container &s, 
-        const unsigned int v
-    ){
-        typedef typename Container::value_type type;
-        detail::stack_construct<Archive, type> t(ar, v);
-        // borland fails silently w/o full namespace
-        ar >> boost::serialization::make_nvp("item", t.reference());
-        std::pair<typename Container::const_iterator, bool> result = 
-            s.insert(boost::move(t.reference()));
-        // note: the following presumes that the map::value_type was NOT tracked
-        // in the archive.  This is the usual case, but here there is no way
-        // to determine that.  
-        if(result.second){
-            ar.reset_object_address(
-                & (result.first->second),
-                & t.reference().second
-            );
-        }
-    }
-};
-
-// multimap input
-template<class Archive, class Container>
-struct archive_input_hash_multimap
-{
-    inline void operator()(
-        Archive &ar, 
-        Container &s, 
-        const unsigned int v
-    ){
-        typedef typename Container::value_type type;
-        detail::stack_construct<Archive, type> t(ar, v);
-        // borland fails silently w/o full namespace
-        ar >> boost::serialization::make_nvp("item", t.reference());
-        typename Container::const_iterator result 
-            = s.insert(boost::move(t.reference()));
-        // note: the following presumes that the map::value_type was NOT tracked
-        // in the archive.  This is the usual case, but here there is no way
-        // to determine that.  
-        ar.reset_object_address(
-            & result->second,
-            & t.reference()
-        );
-    }
-};
-
-} // stl
-
-template<
-    class Archive, 
-    class Key, 
-    class HashFcn, 
-    class EqualKey,
-    class Allocator
->
-inline void save(
-    Archive & ar,
-    const BOOST_STD_EXTENSION_NAMESPACE::hash_map<
-        Key, HashFcn, EqualKey, Allocator
-    > &t,
-    const unsigned int file_version
-){
-    boost::serialization::stl::save_hash_collection<
-        Archive, 
-        BOOST_STD_EXTENSION_NAMESPACE::hash_map<
-            Key, HashFcn, EqualKey, Allocator
-        >
-    >(ar, t);
-}
-
-template<
-    class Archive, 
-    class Key, 
-    class HashFcn, 
-    class EqualKey,
-    class Allocator
->
-inline void load(
-    Archive & ar,
-    BOOST_STD_EXTENSION_NAMESPACE::hash_map<
-        Key, HashFcn, EqualKey, Allocator
-    > &t,
-    const unsigned int file_version
-){
-    boost::serialization::stl::load_hash_collection<
-        Archive,
-        BOOST_STD_EXTENSION_NAMESPACE::hash_map<
-            Key, HashFcn, EqualKey, Allocator
-        >,
-        boost::serialization::stl::archive_input_hash_map<
-            Archive, 
-            BOOST_STD_EXTENSION_NAMESPACE::hash_map<
-                Key, HashFcn, EqualKey, Allocator
-            >
-        >
-    >(ar, t);
-}
-
-// split non-intrusive serialization function member into separate
-// non intrusive save/load member functions
-template<
-    class Archive, 
-    class Key, 
-    class HashFcn, 
-    class EqualKey,
-    class Allocator
->
-inline void serialize(
-    Archive & ar,
-    BOOST_STD_EXTENSION_NAMESPACE::hash_map<
-        Key, HashFcn, EqualKey, Allocator
-    > &t,
-    const unsigned int file_version
-){
-    boost::serialization::split_free(ar, t, file_version);
-}
-
-// hash_multimap
-template<
-    class Archive, 
-    class Key, 
-    class HashFcn, 
-    class EqualKey,
-    class Allocator
->
-inline void save(
-    Archive & ar,
-    const BOOST_STD_EXTENSION_NAMESPACE::hash_multimap<
-        Key, HashFcn, EqualKey, Allocator
-    > &t,
-    const unsigned int file_version
-){
-    boost::serialization::stl::save_hash_collection<
-        Archive, 
-        BOOST_STD_EXTENSION_NAMESPACE::hash_multimap<
-            Key, HashFcn, EqualKey, Allocator
-        >
-    >(ar, t);
-}
-
-template<
-    class Archive, 
-    class Key, 
-    class HashFcn, 
-    class EqualKey,
-    class Allocator
->
-inline void load(
-    Archive & ar,
-    BOOST_STD_EXTENSION_NAMESPACE::hash_multimap<
-        Key, HashFcn, EqualKey, Allocator
-    > &t,
-    const unsigned int file_version
-){
-    boost::serialization::stl::load_hash_collection<
-        Archive,
-        BOOST_STD_EXTENSION_NAMESPACE::hash_multimap<
-            Key, HashFcn, EqualKey, Allocator
-        >,
-        boost::serialization::stl::archive_input_hash_multimap<
-            Archive, 
-            BOOST_STD_EXTENSION_NAMESPACE::hash_multimap<
-                Key, HashFcn, EqualKey, Allocator
-            >
-        >
-    >(ar, t);
-}
-
-// split non-intrusive serialization function member into separate
-// non intrusive save/load member functions
-template<
-    class Archive, 
-    class Key, 
-    class HashFcn, 
-    class EqualKey,
-    class Allocator
->
-inline void serialize(
-    Archive & ar,
-    BOOST_STD_EXTENSION_NAMESPACE::hash_multimap<
-        Key, HashFcn, EqualKey, Allocator
-    > &t,
-    const unsigned int file_version
-){
-    boost::serialization::split_free(ar, t, file_version);
-}
-
-} // namespace serialization
-} // namespace boost
-
-#endif // BOOST_HAS_HASH
-#endif // BOOST_SERIALIZATION_HASH_MAP_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/hash_set.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/hash_set.hpp
deleted file mode 100644
index 0c72c18457e..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/hash_set.hpp
+++ /dev/null
@@ -1,222 +0,0 @@
-#ifndef  BOOST_SERIALIZATION_HASH_SET_HPP
-#define BOOST_SERIALIZATION_HASH_SET_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// hash_set.hpp: serialization for stl hash_set templates
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/config.hpp>
-#ifdef BOOST_HAS_HASH
-#include BOOST_HASH_SET_HEADER
-
-#include <boost/serialization/hash_collections_save_imp.hpp>
-#include <boost/serialization/hash_collections_load_imp.hpp>
-#include <boost/serialization/split_free.hpp>
-#include <boost/move/utility_core.hpp>
-
-namespace boost { 
-namespace serialization {
-
-namespace stl {
-
-// hash_set input
-template<class Archive, class Container>
-struct archive_input_hash_set
-{
-    inline void operator()(
-        Archive &ar, 
-        Container &s, 
-        const unsigned int v
-    ){
-        typedef typename Container::value_type type;
-        detail::stack_construct<Archive, type> t(ar, v);
-        // borland fails silently w/o full namespace
-        ar >> boost::serialization::make_nvp("item", t.reference());
-        std::pair<typename Container::const_iterator, bool> result = 
-            s.insert(boost::move(t.reference()));
-        if(result.second)
-            ar.reset_object_address(& (* result.first), & t.reference());
-    }
-};
-
-// hash_multiset input
-template<class Archive, class Container>
-struct archive_input_hash_multiset
-{
-    inline void operator()(
-        Archive &ar, 
-        Container &s, 
-        const unsigned int v
-    ){
-        typedef typename Container::value_type type;
-        detail::stack_construct<Archive, type> t(ar, v);
-        // borland fails silently w/o full namespace
-        ar >> boost::serialization::make_nvp("item", t.reference());
-        typename Container::const_iterator result 
-            = s.insert(boost::move(t.reference()));
-        ar.reset_object_address(& (* result), & t.reference());
-    }
-};
-
-} // stl
-
-template<
-    class Archive, 
-    class Key, 
-    class HashFcn, 
-    class EqualKey,
-    class Allocator
->
-inline void save(
-    Archive & ar,
-    const BOOST_STD_EXTENSION_NAMESPACE::hash_set<
-        Key, HashFcn, EqualKey, Allocator
-    > &t,
-    const unsigned int file_version
-){
-    boost::serialization::stl::save_hash_collection<
-        Archive, 
-        BOOST_STD_EXTENSION_NAMESPACE::hash_set<
-            Key, HashFcn, EqualKey, Allocator
-        > 
-    >(ar, t);
-}
-
-template<
-    class Archive, 
-    class Key, 
-    class HashFcn, 
-    class EqualKey,
-    class Allocator
->
-inline void load(
-    Archive & ar,
-    BOOST_STD_EXTENSION_NAMESPACE::hash_set<
-        Key, HashFcn, EqualKey, Allocator
-    > &t,
-    const unsigned int file_version
-){
-    boost::serialization::stl::load_hash_collection<
-        Archive,
-        BOOST_STD_EXTENSION_NAMESPACE::hash_set<
-            Key, HashFcn, EqualKey, Allocator
-        >,
-        boost::serialization::stl::archive_input_hash_set<
-            Archive, 
-            BOOST_STD_EXTENSION_NAMESPACE::hash_set<
-                Key, HashFcn, EqualKey, Allocator
-            >
-        >
-    >(ar, t);
-}
-
-// split non-intrusive serialization function member into separate
-// non intrusive save/load member functions
-template<
-    class Archive, 
-    class Key, 
-    class HashFcn, 
-    class EqualKey,
-    class Allocator
->
-inline void serialize(
-    Archive & ar,
-    BOOST_STD_EXTENSION_NAMESPACE::hash_set<
-        Key, HashFcn, EqualKey, Allocator
-    > &t,
-    const unsigned int file_version
-){
-    boost::serialization::split_free(ar, t, file_version);
-}
-
-// hash_multiset
-template<
-    class Archive, 
-    class Key, 
-    class HashFcn, 
-    class EqualKey,
-    class Allocator
->
-inline void save(
-    Archive & ar,
-    const BOOST_STD_EXTENSION_NAMESPACE::hash_multiset<
-        Key, HashFcn, EqualKey, Allocator
-    > &t,
-    const unsigned int file_version
-){
-    boost::serialization::stl::save_hash_collection<
-        Archive, 
-        BOOST_STD_EXTENSION_NAMESPACE::hash_multiset<
-            Key, HashFcn, EqualKey, Allocator
-        > 
-    >(ar, t);
-}
-
-template<
-    class Archive, 
-    class Key, 
-    class HashFcn, 
-    class EqualKey,
-    class Allocator
->
-inline void load(
-    Archive & ar,
-    BOOST_STD_EXTENSION_NAMESPACE::hash_multiset<
-        Key, HashFcn, EqualKey, Allocator
-    > &t,
-    const unsigned int file_version
-){
-    boost::serialization::stl::load_hash_collection<
-        Archive,
-        BOOST_STD_EXTENSION_NAMESPACE::hash_multiset<
-            Key, HashFcn, EqualKey, Allocator
-        >,
-        boost::serialization::stl::archive_input_hash_multiset<
-            Archive,
-            BOOST_STD_EXTENSION_NAMESPACE::hash_multiset<
-                Key, HashFcn, EqualKey, Allocator
-            > 
-        >
-    >(ar, t);
-}
-
-// split non-intrusive serialization function member into separate
-// non intrusive save/load member functions
-template<
-    class Archive, 
-    class Key, 
-    class HashFcn, 
-    class EqualKey,
-    class Allocator
->
-inline void serialize(
-    Archive & ar,
-    BOOST_STD_EXTENSION_NAMESPACE::hash_multiset<
-        Key, HashFcn, EqualKey, Allocator
-    > & t,
-    const unsigned int file_version
-){
-    boost::serialization::split_free(ar, t, file_version);
-}
-
-} // namespace serialization
-} // namespace boost
-
-#include <boost/serialization/collection_traits.hpp>
-
-BOOST_SERIALIZATION_COLLECTION_TRAITS(BOOST_STD_EXTENSION_NAMESPACE::hash_set)
-BOOST_SERIALIZATION_COLLECTION_TRAITS(BOOST_STD_EXTENSION_NAMESPACE::hash_multiset)
-
-#endif // BOOST_HAS_HASH
-#endif // BOOST_SERIALIZATION_HASH_SET_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/is_bitwise_serializable.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/is_bitwise_serializable.hpp
deleted file mode 100644
index 7e24a2cb6d8..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/is_bitwise_serializable.hpp
+++ /dev/null
@@ -1,46 +0,0 @@
-// (C) Copyright 2007 Matthias Troyer
-
-// Use, modification and distribution is subject to the 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: Matthias Troyer
-
-/** @file is_bitwise_serializable.hpp
- *
- *  This header provides a traits class for determining whether a class
- * can be serialized (in a non-portable way) just by copying the bits.
- */
-
-
-#ifndef BOOST_SERIALIZATION_IS_BITWISE_SERIALIZABLE_HPP
-#define BOOST_SERIALIZATION_IS_BITWISE_SERIALIZABLE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-#include <boost/mpl/bool_fwd.hpp>
-#include <boost/type_traits/is_arithmetic.hpp>
-
-namespace boost {
-namespace serialization {
-    template<class T>
-    struct is_bitwise_serializable
-     : public is_arithmetic< T >
-    {};
-} // namespace serialization
-} // namespace boost
-
-
-// define a macro to make explicit designation of this more transparent
-#define BOOST_IS_BITWISE_SERIALIZABLE(T)              \
-namespace boost {                                     \
-namespace serialization {                             \
-template<>                                            \
-struct is_bitwise_serializable< T > : mpl::true_ {};  \
-}}                                                    \
-/**/
-
-#endif //BOOST_SERIALIZATION_IS_BITWISE_SERIALIZABLE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/item_version_type.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/item_version_type.hpp
deleted file mode 100644
index f3e5adac6f8..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/item_version_type.hpp
+++ /dev/null
@@ -1,68 +0,0 @@
-#ifndef BOOST_SERIALIZATION_ITEM_VERSION_TYPE_HPP
-#define BOOST_SERIALIZATION_ITEM_VERSION_TYPE_HPP
-
-// (C) Copyright 2010 Robert Ramey
-// Use, modification and distribution is subject to the 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/cstdint.hpp> // uint_least8_t
-#include <boost/integer_traits.hpp>
-#include <boost/serialization/level.hpp>
-#include <boost/serialization/is_bitwise_serializable.hpp>
-
-// fixes broken example build on x86_64-linux-gnu-gcc-4.6.0
-#include <boost/assert.hpp>
-
-namespace boost { 
-namespace serialization {
-
-#if defined(_MSC_VER)
-#pragma warning( push )
-#pragma warning( disable : 4244 4267 )
-#endif
-
-class item_version_type {
-private:
-    typedef unsigned int base_type;
-    base_type t;
-public:
-    // should be private - but MPI fails if it's not!!!
-    item_version_type(): t(0) {};
-    explicit item_version_type(const unsigned int t_) : t(t_){
-        BOOST_ASSERT(t_ <= boost::integer_traits<base_type>::const_max);
-    }
-    item_version_type(const item_version_type & t_) : 
-        t(t_.t)
-    {}
-    item_version_type & operator=(item_version_type rhs){
-        t = rhs.t; 
-        return *this;
-    }
-    // used for text output
-    operator base_type () const {
-        return t;
-    }                
-    // used for text input
-    operator base_type & () {
-        return t;
-    }
-    bool operator==(const item_version_type & rhs) const {
-        return t == rhs.t;
-    } 
-    bool operator<(const item_version_type & rhs) const {
-        return t < rhs.t;
-    }
-};
-
-#if defined(_MSC_VER)
-#pragma warning( pop )
-#endif
-
-} } // end namespace boost::serialization
-
-BOOST_IS_BITWISE_SERIALIZABLE(item_version_type)
-
-BOOST_CLASS_IMPLEMENTATION(item_version_type, primitive_type)
-
-#endif //BOOST_SERIALIZATION_ITEM_VERSION_TYPE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/level.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/level.hpp
deleted file mode 100644
index f6a84d10422..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/level.hpp
+++ /dev/null
@@ -1,116 +0,0 @@
-#ifndef BOOST_SERIALIZATION_LEVEL_HPP
-#define BOOST_SERIALIZATION_LEVEL_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// level.hpp:
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/config.hpp>
-#include <boost/detail/workaround.hpp>
-
-#include <boost/type_traits/is_fundamental.hpp>
-#include <boost/type_traits/is_enum.hpp>
-#include <boost/type_traits/is_array.hpp>
-#include <boost/type_traits/is_class.hpp>
-#include <boost/type_traits/is_base_and_derived.hpp>
-
-#include <boost/mpl/eval_if.hpp>
-#include <boost/mpl/int.hpp>
-#include <boost/mpl/integral_c.hpp>
-#include <boost/mpl/integral_c_tag.hpp>
-
-#include <boost/serialization/level_enum.hpp>
-
-namespace boost {
-namespace serialization {
-
-struct basic_traits;
-
-// default serialization implementation level
-template<class T>
-struct implementation_level_impl {
-    template<class U>
-    struct traits_class_level {
-        typedef typename U::level type;
-    };
-
-    typedef mpl::integral_c_tag tag;
-    // note: at least one compiler complained w/o the full qualification
-    // on basic traits below
-    typedef
-        typename mpl::eval_if<
-            is_base_and_derived<boost::serialization::basic_traits, T>,
-            traits_class_level< T >,
-        //else
-        typename mpl::eval_if<
-            is_fundamental< T >,
-            mpl::int_<primitive_type>,
-        //else
-        typename mpl::eval_if<
-            is_class< T >,
-            mpl::int_<object_class_info>,
-        //else
-        typename mpl::eval_if<
-            is_array< T >,
-                mpl::int_<object_serializable>,
-        //else
-        typename mpl::eval_if<
-            is_enum< T >,
-                mpl::int_<primitive_type>,
-        //else
-            mpl::int_<not_serializable>
-        >
-        >
-        >
-        >
-        >::type type;
-        // vc 7.1 doesn't like enums here
-    BOOST_STATIC_CONSTANT(int, value = type::value);
-};
-
-template<class T>
-struct implementation_level : 
-    public implementation_level_impl<const T>
-{
-};
-
-template<class T, int L>
-inline bool operator>=(implementation_level< T > t, enum level_type l)
-{
-    return t.value >= (int)l;
-}
-
-} // namespace serialization
-} // namespace boost
-
-// specify the level of serialization implementation for the class
-// require that class info saved when versioning is used
-#define BOOST_CLASS_IMPLEMENTATION(T, E)                 \
-    namespace boost {                                    \
-    namespace serialization {                            \
-    template <>                                          \
-    struct implementation_level_impl< const T >                     \
-    {                                                    \
-        typedef mpl::integral_c_tag tag;                 \
-        typedef mpl::int_< E > type;                     \
-        BOOST_STATIC_CONSTANT(                           \
-            int,                                         \
-            value = implementation_level_impl::type::value    \
-        );                                               \
-    };                                                   \
-    }                                                    \
-    }
-    /**/
-
-#endif // BOOST_SERIALIZATION_LEVEL_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/level_enum.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/level_enum.hpp
deleted file mode 100644
index baf64e04f31..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/level_enum.hpp
+++ /dev/null
@@ -1,55 +0,0 @@
-#ifndef BOOST_SERIALIZATION_LEVEL_ENUM_HPP
-#define BOOST_SERIALIZATION_LEVEL_ENUM_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// level_enum.hpp:
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-namespace boost {
-namespace serialization {
-
-// for each class used in the program, specify which level
-// of serialization should be implemented
-
-// names for each level
-enum level_type
-{
-    // Don't serialize this type. An attempt to do so should
-    // invoke a compile time assertion.
-    not_serializable = 0,
-    // write/read this type directly to the archive. In this case
-    // serialization code won't be called.  This is the default
-    // case for fundamental types.  It presumes a member function or
-    // template in the archive class that can handle this type.
-    // there is no runtime overhead associated reading/writing
-    // instances of this level
-    primitive_type = 1,
-    // Serialize the objects of this type using the objects "serialize"
-    // function or template. This permits values to be written/read
-    // to/from archives but includes no class or version information. 
-    object_serializable = 2,
-    ///////////////////////////////////////////////////////////////////
-    // once an object is serialized at one of the above levels, the
-    // corresponding archives cannot be read if the implementation level
-    // for the archive object is changed.  
-    ///////////////////////////////////////////////////////////////////
-    // Add class information to the archive.  Class information includes
-    // implementation level, class version and class name if available
-    object_class_info = 3
-};
-
-} // namespace serialization
-} // namespace boost
-
-#endif // BOOST_SERIALIZATION_LEVEL_ENUM_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/list.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/list.hpp
deleted file mode 100644
index 5fdc114d7ed..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/list.hpp
+++ /dev/null
@@ -1,85 +0,0 @@
-#ifndef BOOST_SERIALIZATION_LIST_HPP
-#define BOOST_SERIALIZATION_LIST_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// list.hpp: serialization for stl list templates
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <list>
-
-#include <boost/config.hpp>
-
-#include <boost/serialization/collections_save_imp.hpp>
-#include <boost/serialization/collections_load_imp.hpp>
-
-#include <boost/archive/detail/basic_iarchive.hpp>
-#include <boost/serialization/access.hpp>
-#include <boost/serialization/nvp.hpp>
-#include <boost/serialization/collection_size_type.hpp>
-#include <boost/serialization/item_version_type.hpp>
-#include <boost/serialization/split_free.hpp>
-
-namespace boost { 
-namespace serialization {
-
-template<class Archive, class U, class Allocator>
-inline void save(
-    Archive & ar,
-    const std::list<U, Allocator> &t,
-    const unsigned int /* file_version */
-){
-    boost::serialization::stl::save_collection<
-        Archive, 
-        std::list<U, Allocator> 
-    >(ar, t);
-}
-
-template<class Archive, class U, class Allocator>
-inline void load(
-    Archive & ar,
-    std::list<U, Allocator> &t,
-    const unsigned int /* file_version */
-){
-    const boost::archive::library_version_type library_version(
-        ar.get_library_version()
-    );
-    // retrieve number of elements
-    item_version_type item_version(0);
-    collection_size_type count;
-    ar >> BOOST_SERIALIZATION_NVP(count);
-    if(boost::archive::library_version_type(3) < library_version){
-        ar >> BOOST_SERIALIZATION_NVP(item_version);
-    }
-    stl::collection_load_impl(ar, t, count, item_version);
-}
-
-// split non-intrusive serialization function member into separate
-// non intrusive save/load member functions
-template<class Archive, class U, class Allocator>
-inline void serialize(
-    Archive & ar,
-    std::list<U, Allocator> & t,
-    const unsigned int file_version
-){
-    boost::serialization::split_free(ar, t, file_version);
-}
-
-} // serialization
-} // namespace boost
-
-#include <boost/serialization/collection_traits.hpp>
-
-BOOST_SERIALIZATION_COLLECTION_TRAITS(std::list)
-
-#endif // BOOST_SERIALIZATION_LIST_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/map.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/map.hpp
deleted file mode 100644
index 9209864c8cf..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/map.hpp
+++ /dev/null
@@ -1,139 +0,0 @@
-#ifndef  BOOST_SERIALIZATION_MAP_HPP
-#define BOOST_SERIALIZATION_MAP_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// serialization/map.hpp:
-// serialization for stl map templates
-
-// (C) Copyright 2002-2014 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <map>
-
-#include <boost/config.hpp>
-
-#include <boost/archive/detail/basic_iarchive.hpp>
-#include <boost/serialization/access.hpp>
-#include <boost/serialization/nvp.hpp>
-#include <boost/serialization/collection_size_type.hpp>
-#include <boost/serialization/item_version_type.hpp>
-#include <boost/serialization/detail/stack_constructor.hpp>
-
-#include <boost/serialization/utility.hpp>
-#include <boost/serialization/collections_save_imp.hpp>
-#include <boost/serialization/split_free.hpp>
-#include <boost/move/utility_core.hpp>
-
-namespace boost { 
-namespace serialization {
-
-////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// implementation of serialization for map and mult-map STL containers
-
-template<class Archive, class Container>
-inline void load_map_collection(Archive & ar, Container &s)
-{
-    s.clear();
-    const boost::archive::library_version_type library_version(
-        ar.get_library_version()
-    );
-    // retrieve number of elements
-    item_version_type item_version(0);
-    collection_size_type count;
-    ar >> BOOST_SERIALIZATION_NVP(count);
-    if(boost::archive::library_version_type(3) < library_version){
-        ar >> BOOST_SERIALIZATION_NVP(item_version);
-    }
-    typename Container::iterator hint;
-    hint = s.begin();
-    while(count-- > 0){
-        typedef typename Container::value_type type;
-        detail::stack_construct<Archive, type> t(ar, item_version);
-        ar >> boost::serialization::make_nvp("item", t.reference());
-        typename Container::iterator result =
-            s.insert(hint, boost::move(t.reference()));
-        ar.reset_object_address(& (result->second), & t.reference().second);
-        hint = result;
-        ++hint;
-    }
-}
-
-// map
-template<class Archive, class Type, class Key, class Compare, class Allocator >
-inline void save(
-    Archive & ar,
-    const std::map<Key, Type, Compare, Allocator> &t,
-    const unsigned int /* file_version */
-){
-    boost::serialization::stl::save_collection<
-        Archive, 
-        std::map<Key, Type, Compare, Allocator> 
-    >(ar, t);
-}
-
-template<class Archive, class Type, class Key, class Compare, class Allocator >
-inline void load(
-    Archive & ar,
-    std::map<Key, Type, Compare, Allocator> &t,
-    const unsigned int /* file_version */
-){
-    load_map_collection(ar, t);
-}
-
-// split non-intrusive serialization function member into separate
-// non intrusive save/load member functions
-template<class Archive, class Type, class Key, class Compare, class Allocator >
-inline void serialize(
-    Archive & ar,
-    std::map<Key, Type, Compare, Allocator> &t,
-    const unsigned int file_version
-){
-    boost::serialization::split_free(ar, t, file_version);
-}
-
-// multimap
-template<class Archive, class Type, class Key, class Compare, class Allocator >
-inline void save(
-    Archive & ar,
-    const std::multimap<Key, Type, Compare, Allocator> &t,
-    const unsigned int /* file_version */
-){
-    boost::serialization::stl::save_collection<
-        Archive, 
-        std::multimap<Key, Type, Compare, Allocator> 
-    >(ar, t);
-}
-
-template<class Archive, class Type, class Key, class Compare, class Allocator >
-inline void load(
-    Archive & ar,
-    std::multimap<Key, Type, Compare, Allocator> &t,
-    const unsigned int /* file_version */
-){
-    load_map_collection(ar, t);
-}
-
-// split non-intrusive serialization function member into separate
-// non intrusive save/load member functions
-template<class Archive, class Type, class Key, class Compare, class Allocator >
-inline void serialize(
-    Archive & ar,
-    std::multimap<Key, Type, Compare, Allocator> &t,
-    const unsigned int file_version
-){
-    boost::serialization::split_free(ar, t, file_version);
-}
-
-} // serialization
-} // namespace boost
-
-#endif // BOOST_SERIALIZATION_MAP_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/nvp.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/nvp.hpp
deleted file mode 100644
index 4e2297b3cc9..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/nvp.hpp
+++ /dev/null
@@ -1,123 +0,0 @@
-#ifndef BOOST_SERIALIZATION_NVP_HPP
-#define BOOST_SERIALIZATION_NVP_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// nvp.hpp: interface for serialization system.
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <utility>
-
-#include <boost/config.hpp>
-#include <boost/detail/workaround.hpp>
-
-#include <boost/serialization/level.hpp>
-#include <boost/serialization/tracking.hpp>
-#include <boost/serialization/split_member.hpp>
-#include <boost/serialization/base_object.hpp>
-#include <boost/serialization/traits.hpp>
-#include <boost/serialization/wrapper.hpp>
-
-namespace boost {
-namespace serialization {
-
-template<class T>
-struct nvp : 
-    public std::pair<const char *, T *>,
-    public wrapper_traits<const nvp< T > >
-{
-//private:
-    nvp(const nvp & rhs) :
-        std::pair<const char *, T *>(rhs.first, rhs.second)
-    {}
-public:
-    explicit nvp(const char * name_, T & t) :
-        // note: added _ to suppress useless gcc warning
-        std::pair<const char *, T *>(name_, & t)
-    {}
-
-    const char * name() const {
-        return this->first;
-    }
-    T & value() const {
-        return *(this->second);
-    }
-
-    const T & const_value() const {
-        return *(this->second);
-    }
-
-    template<class Archive>
-    void save(
-        Archive & ar,
-        const unsigned int /* file_version */
-    ) const {
-        ar.operator<<(const_value());
-    }
-    template<class Archive>
-    void load(
-        Archive & ar,
-        const unsigned int /* file_version */
-    ){
-        ar.operator>>(value());
-    }
-    BOOST_SERIALIZATION_SPLIT_MEMBER()
-};
-
-template<class T>
-inline
-const nvp< T > make_nvp(const char * name, T & t){
-    return nvp< T >(name, t);
-}
-
-// to maintain efficiency and portability, we want to assign
-// specific serialization traits to all instances of this wrappers.
-// we can't strait forward method below as it depends upon
-// Partial Template Specialization and doing so would mean that wrappers
-// wouldn't be treated the same on different platforms.  This would
-// break archive portability. Leave this here as reminder not to use it !!!
-
-template <class T>
-struct implementation_level<nvp< T > >
-{
-    typedef mpl::integral_c_tag tag;
-    typedef mpl::int_<object_serializable> type;
-    BOOST_STATIC_CONSTANT(int, value = implementation_level::type::value);
-};
-
-// nvp objects are generally created on the stack and are never tracked
-template<class T>
-struct tracking_level<nvp< T > >
-{
-    typedef mpl::integral_c_tag tag;
-    typedef mpl::int_<track_never> type;
-    BOOST_STATIC_CONSTANT(int, value = tracking_level::type::value);
-};
-
-} // seralization
-} // boost
-
-#include <boost/preprocessor/stringize.hpp>
-
-#define BOOST_SERIALIZATION_NVP(name)                              \
-    boost::serialization::make_nvp(BOOST_PP_STRINGIZE(name), name)
-/**/
-
-#define BOOST_SERIALIZATION_BASE_OBJECT_NVP(name)                  \
-    boost::serialization::make_nvp(                                \
-        BOOST_PP_STRINGIZE(name),                                  \
-        boost::serialization::base_object<name >(*this)            \
-    )
-/**/
-
-#endif // BOOST_SERIALIZATION_NVP_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/optional.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/optional.hpp
deleted file mode 100644
index d6ff830a8c3..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/optional.hpp
+++ /dev/null
@@ -1,107 +0,0 @@
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-
-// (C) Copyright 2002-4 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)
-
-// Provides non-intrusive serialization for boost::optional.
-
-#ifndef BOOST_SERIALIZATION_OPTIONAL_HPP_
-#define BOOST_SERIALIZATION_OPTIONAL_HPP_
-
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-#include <boost/config.hpp>
-
-#include <boost/archive/detail/basic_iarchive.hpp>
-
-#include <boost/optional.hpp>
-#include <boost/move/utility_core.hpp>
-
-#include <boost/serialization/item_version_type.hpp>
-#include <boost/serialization/split_free.hpp>
-#include <boost/serialization/level.hpp>
-#include <boost/serialization/nvp.hpp>
-#include <boost/serialization/version.hpp>
-#include <boost/type_traits/is_pointer.hpp>
-#include <boost/serialization/detail/stack_constructor.hpp>
-#include <boost/serialization/detail/is_default_constructible.hpp>
-#include <boost/serialization/force_include.hpp>
-
-// function specializations must be defined in the appropriate
-// namespace - boost::serialization
-namespace boost { 
-namespace serialization {
-
-template<class Archive, class T>
-void save(
-    Archive & ar, 
-    const boost::optional< T > & t, 
-    const unsigned int /*version*/
-){
-    // It is an inherent limitation to the serialization of optional.hpp
-    // that the underlying type must be either a pointer or must have a
-    // default constructor.  It's possible that this could change sometime
-    // in the future, but for now, one will have to work around it.  This can
-    // be done by serialization the optional<T> as optional<T *>
-    #if ! defined(BOOST_NO_CXX11_HDR_TYPE_TRAITS)
-        BOOST_STATIC_ASSERT(
-            boost::serialization::detail::is_default_constructible<T>::value
-            || boost::is_pointer<T>::value
-        );
-    #endif
-    const bool tflag = t.is_initialized();
-    ar << boost::serialization::make_nvp("initialized", tflag);
-    if (tflag){
-        ar << boost::serialization::make_nvp("value", *t);
-    }
-}
-
-template<class Archive, class T>
-void load(
-    Archive & ar, 
-    boost::optional< T > & t, 
-    const unsigned int version
-){
-    bool tflag;
-    ar >> boost::serialization::make_nvp("initialized", tflag);
-    if(! tflag){
-        t.reset();
-        return;
-    }
-
-    if(0 == version){
-        boost::serialization::item_version_type item_version(0);
-        boost::archive::library_version_type library_version(
-            ar.get_library_version()
-        );
-        if(boost::archive::library_version_type(3) < library_version){
-            ar >> BOOST_SERIALIZATION_NVP(item_version);
-        }
-    }
-    if(! t.is_initialized())
-        t = T();
-    ar >> boost::serialization::make_nvp("value", *t);
-}
-
-template<class Archive, class T>
-void serialize(
-    Archive & ar, 
-    boost::optional< T > & t, 
-    const unsigned int version
-){
-    boost::serialization::split_free(ar, t, version);
-}
-
-template<class T>
-struct version<boost::optional<T> > {
-    BOOST_STATIC_CONSTANT(int, value = 1);
-};
-
-} // serialization
-} // boost
-
-#endif // BOOST_SERIALIZATION_OPTIONAL_HPP_
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/priority_queue.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/priority_queue.hpp
deleted file mode 100644
index 5b08ffd1e82..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/priority_queue.hpp
+++ /dev/null
@@ -1,76 +0,0 @@
-#ifndef  BOOST_SERIALIZATION_PRIORITY_QUEUE_HPP
-#define BOOST_SERIALIZATION_PRIORITY_QUEUE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// priority_queue.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <queue>
-#include <boost/config.hpp>
-#include <boost/mpl/eval_if.hpp>
-#include <boost/mpl/identity.hpp>
-
-// function specializations must be defined in the appropriate
-// namespace - boost::serialization
-#if defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION)
-#define STD _STLP_STD
-#else
-#define STD std
-#endif
-
-namespace boost { 
-namespace serialization {
-namespace detail{
-
-template <typename U, typename Container, typename Compare>
-struct priority_queue_save : public STD::priority_queue<U, Container, Compare> {
-    template<class Archive>
-    void operator()(Archive & ar, const unsigned int file_version) const {
-        save(ar, STD::priority_queue<U, Container, Compare>::c, file_version);
-    }
-};
-template <typename U, typename Container, typename Compare>
-struct priority_queue_load : public STD::priority_queue<U, Container, Compare> {
-    template<class Archive>
-    void operator()(Archive & ar, const unsigned int file_version) {
-        load(ar, STD::priority_queue<U, Container, Compare>::c, file_version);
-    }
-};
-
-} // detail
-
-template<class Archive, class T, class Container, class Compare>
-inline void serialize(
-    Archive & ar,
-    std::priority_queue< T, Container, Compare> & t,
-    const unsigned int file_version 
-){
-    typedef typename mpl::eval_if<
-        typename Archive::is_saving,
-        mpl::identity<detail::priority_queue_save<T, Container, Compare> >,
-        mpl::identity<detail::priority_queue_load<T, Container, Compare> >
-    >::type typex;
-    static_cast<typex &>(t)(ar, file_version);
-}
-
-} // namespace serialization
-} // namespace boost
-
-#include <boost/serialization/collection_traits.hpp>
-
-BOOST_SERIALIZATION_COLLECTION_TRAITS(STD::priority_queue)
-
-#undef STD
-
-#endif // BOOST_SERIALIZATION_PRIORITY_QUEUE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/queue.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/queue.hpp
deleted file mode 100644
index b22745215d9..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/queue.hpp
+++ /dev/null
@@ -1,76 +0,0 @@
-#ifndef  BOOST_SERIALIZATION_QUEUE_HPP
-#define BOOST_SERIALIZATION_QUEUE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// queue.hpp
-
-// (C) Copyright 2014 Robert Ramey - http://www.rrsd.com .
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <queue>
-#include <boost/config.hpp>
-#include <boost/mpl/eval_if.hpp>
-#include <boost/mpl/identity.hpp>
-
-// function specializations must be defined in the appropriate
-// namespace - boost::serialization
-#if defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION)
-#define STD _STLP_STD
-#else
-#define STD std
-#endif
-
-namespace boost { 
-namespace serialization {
-namespace detail {
-
-template <typename U, typename C>
-struct queue_save : public STD::queue<U, C> {
-    template<class Archive>
-    void operator()(Archive & ar, const unsigned int file_version) const {
-        save(ar, STD::queue<U, C>::c, file_version);
-    }
-};
-template <typename U, typename C>
-struct queue_load : public STD::queue<U, C> {
-    template<class Archive>
-    void operator()(Archive & ar, const unsigned int file_version) {
-        load(ar, STD::queue<U, C>::c, file_version);
-    }
-};
-
-} // detail
-
-template<class Archive, class T, class C>
-inline void serialize(
-    Archive & ar,
-    std::queue< T, C> & t,
-    const unsigned int file_version 
-){
-    typedef typename mpl::eval_if<
-        typename Archive::is_saving,
-        mpl::identity<detail::queue_save<T, C> >,
-        mpl::identity<detail::queue_load<T, C> >
-    >::type typex;
-    static_cast<typex &>(t)(ar, file_version);
-}
-
-} // namespace serialization
-} // namespace boost
-
-#include <boost/serialization/collection_traits.hpp>
-
-BOOST_SERIALIZATION_COLLECTION_TRAITS(STD::queue)
-
-#undef STD
-
-#endif // BOOST_SERIALIZATION_QUEUE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/scoped_ptr.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/scoped_ptr.hpp
deleted file mode 100644
index 0d11f8436e0..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/scoped_ptr.hpp
+++ /dev/null
@@ -1,58 +0,0 @@
-#ifndef BOOST_SERIALIZATION_SCOPED_PTR_HPP_VP_2003_10_30
-#define BOOST_SERIALIZATION_SCOPED_PTR_HPP_VP_2003_10_30
-
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-//  Copyright (c) 2003 Vladimir Prus.
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-
-// Provides non-intrusive serialization for boost::scoped_ptr
-// Does not allow to serialize scoped_ptr's to builtin types.
-
-#include <boost/config.hpp>
-
-#include <boost/scoped_ptr.hpp>
-#include <boost/serialization/nvp.hpp>
-#include <boost/serialization/split_free.hpp>
-
-namespace boost { 
-namespace serialization {
-    
-    template<class Archive, class T>
-    void save(
-        Archive & ar, 
-        const boost::scoped_ptr< T > & t, 
-        const unsigned int /* version */
-    ){
-        T* r = t.get();
-        ar << boost::serialization::make_nvp("scoped_ptr", r);
-    }
-
-    template<class Archive, class T>
-    void load(
-        Archive & ar, 
-        boost::scoped_ptr< T > & t, 
-        const unsigned int /* version */
-    ){
-        T* r;
-        ar >> boost::serialization::make_nvp("scoped_ptr", r);
-        t.reset(r); 
-    }
-
-    template<class Archive, class T>
-    void serialize(
-        Archive& ar, 
-        boost::scoped_ptr< T >& t, 
-        const unsigned int version
-    ){
-        boost::serialization::split_free(ar, t, version);
-    }
-
-} // namespace serialization
-} // namespace boost
-
-#endif // BOOST_SERIALIZATION_SCOPED_PTR_HPP_VP_2003_10_30
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/serialization.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/serialization.hpp
deleted file mode 100644
index a4d04723c75..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/serialization.hpp
+++ /dev/null
@@ -1,154 +0,0 @@
-#ifndef BOOST_SERIALIZATION_SERIALIZATION_HPP
-#define BOOST_SERIALIZATION_SERIALIZATION_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-#if defined(_MSC_VER)
-#  pragma warning (disable : 4675) // suppress ADL warning
-#endif
-
-#include <boost/config.hpp>
-#include <boost/serialization/strong_typedef.hpp>
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// serialization.hpp: interface for serialization system.
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-//////////////////////////////////////////////////////////////////////
-// public interface to serialization. 
-
-/////////////////////////////////////////////////////////////////////////////
-// layer 0 - intrusive verison
-// declared and implemented for each user defined class to be serialized
-//
-//  template<Archive>
-//  serialize(Archive &ar, const unsigned int file_version){
-//      ar & base_object<base>(*this) & member1 & member2 ... ;
-//  }
-
-/////////////////////////////////////////////////////////////////////////////
-// layer 1 - layer that routes member access through the access class.
-// this is what permits us to grant access to private class member functions
-// by specifying friend class boost::serialization::access
-
-#include <boost/serialization/access.hpp>
-
-/////////////////////////////////////////////////////////////////////////////
-// layer 2 - default implementation of non-intrusive serialization.
-//
-// note the usage of function overloading to compensate that C++ does not
-// currently support Partial Template Specialization for function templates 
-// We have declared the version number as "const unsigned long".  
-// Overriding templates for specific data types should declare the version
-// number as "const unsigned int". Template matching will first be applied
-// to functions with the same version types - that is the overloads.  
-// If there is no declared function prototype that matches, the second argument
-// will be converted to "const unsigned long" and a match will be made with 
-// one of the default template functions below.
-
-namespace boost {
-namespace serialization {
-
-BOOST_STRONG_TYPEDEF(unsigned int, version_type)
-
-// default implementation - call the member function "serialize"
-template<class Archive, class T>
-inline void serialize(
-    Archive & ar, T & t, const unsigned int file_version
-){
-    access::serialize(ar, t, static_cast<unsigned int>(file_version));
-}
-
-// save data required for construction
-template<class Archive, class T>
-inline void save_construct_data(
-    Archive & /*ar*/, 
-    const T * /*t*/, 
-    const unsigned int /*file_version */
-){
-    // default is to save no data because default constructor
-    // requires no arguments.
-}
-
-// load data required for construction and invoke constructor in place
-template<class Archive, class T>
-inline void load_construct_data(
-    Archive & /*ar*/, 
-    T * t, 
-    const unsigned int /*file_version*/
-){
-    // default just uses the default constructor.  going
-    // through access permits usage of otherwise private default
-    // constructor
-    access::construct(t);
-}
-
-/////////////////////////////////////////////////////////////////////////////
-// layer 3 - move call into serialization namespace so that ADL will function
-// in the manner we desire.
-//
-// on compilers which don't implement ADL. only the current namespace
-// i.e. boost::serialization will be searched.
-// 
-// on compilers which DO implement ADL
-// serialize overrides can be in any of the following
-// 
-// 1) same namepace as Archive
-// 2) same namespace as T
-// 3) boost::serialization
-//
-// Due to Martin Ecker
-
-template<class Archive, class T>
-inline void serialize_adl(
-    Archive & ar, 
-    T & t, 
-    const unsigned int file_version
-){
-    // note usage of function overloading to delay final resolution
-    // until the point of instantiation.  This works around the two-phase
-    // lookup "feature" which inhibits redefintion of a default function
-    // template implementation. Due to Robert Ramey
-    //
-    // Note that this trick generates problems for compiles which don't support
-    // PFTO, suppress it here.  As far as we know, there are no compilers
-    // which fail to support PFTO while supporting two-phase lookup.
-    const version_type v(file_version);
-    serialize(ar, t, v);
-}
-
-template<class Archive, class T>
-inline void save_construct_data_adl(
-    Archive & ar, 
-    const T * t, 
-    const unsigned int file_version
-){
-    // see above
-    const version_type v(file_version);
-    save_construct_data(ar, t, v);
-}
-
-template<class Archive, class T>
-inline void load_construct_data_adl(
-    Archive & ar, 
-    T * t, 
-    const unsigned int file_version
-){
-    // see above comment
-    const version_type v(file_version);
-    load_construct_data(ar, t, v);
-}
-
-} // namespace serialization
-} // namespace boost
-
-#endif //BOOST_SERIALIZATION_SERIALIZATION_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/set.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/set.hpp
deleted file mode 100644
index 643906c5aac..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/set.hpp
+++ /dev/null
@@ -1,137 +0,0 @@
-#ifndef  BOOST_SERIALIZATION_SET_HPP
-#define BOOST_SERIALIZATION_SET_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// set.hpp: serialization for stl set templates
-
-// (C) Copyright 2002-2014 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <set>
-
-#include <boost/config.hpp>
-
-#include <boost/archive/detail/basic_iarchive.hpp>
-#include <boost/serialization/access.hpp>
-#include <boost/serialization/nvp.hpp>
-#include <boost/serialization/detail/stack_constructor.hpp>
-#include <boost/serialization/collection_size_type.hpp>
-#include <boost/serialization/item_version_type.hpp>
-
-#include <boost/serialization/collections_save_imp.hpp>
-#include <boost/serialization/split_free.hpp>
-#include <boost/move/utility_core.hpp>
-
-namespace boost { 
-namespace serialization {
-
-template<class Archive, class Container>
-inline void load_set_collection(Archive & ar, Container &s)
-{
-    s.clear();
-    const boost::archive::library_version_type library_version(
-        ar.get_library_version()
-    );
-    // retrieve number of elements
-    item_version_type item_version(0);
-    collection_size_type count;
-    ar >> BOOST_SERIALIZATION_NVP(count);
-    if(boost::archive::library_version_type(3) < library_version){
-        ar >> BOOST_SERIALIZATION_NVP(item_version);
-    }
-    typename Container::iterator hint;
-    hint = s.begin();
-    while(count-- > 0){
-        typedef typename Container::value_type type;
-        detail::stack_construct<Archive, type> t(ar, item_version);
-        // borland fails silently w/o full namespace
-        ar >> boost::serialization::make_nvp("item", t.reference());
-        typename Container::iterator result =
-            s.insert(hint, boost::move(t.reference()));
-        ar.reset_object_address(& (* result), & t.reference());
-        hint = result;
-    }
-}
-
-template<class Archive, class Key, class Compare, class Allocator >
-inline void save(
-    Archive & ar,
-    const std::set<Key, Compare, Allocator> &t,
-    const unsigned int /* file_version */
-){
-    boost::serialization::stl::save_collection<
-        Archive, std::set<Key, Compare, Allocator> 
-    >(ar, t);
-}
-
-template<class Archive, class Key, class Compare, class Allocator >
-inline void load(
-    Archive & ar,
-    std::set<Key, Compare, Allocator> &t,
-    const unsigned int /* file_version */
-){
-    load_set_collection(ar, t);
-}
-
-// split non-intrusive serialization function member into separate
-// non intrusive save/load member functions
-template<class Archive, class Key, class Compare, class Allocator >
-inline void serialize(
-    Archive & ar,
-    std::set<Key, Compare, Allocator> & t,
-    const unsigned int file_version
-){
-    boost::serialization::split_free(ar, t, file_version);
-}
-
-// multiset
-template<class Archive, class Key, class Compare, class Allocator >
-inline void save(
-    Archive & ar,
-    const std::multiset<Key, Compare, Allocator> &t,
-    const unsigned int /* file_version */
-){
-    boost::serialization::stl::save_collection<
-        Archive, 
-        std::multiset<Key, Compare, Allocator> 
-    >(ar, t);
-}
-
-template<class Archive, class Key, class Compare, class Allocator >
-inline void load(
-    Archive & ar,
-    std::multiset<Key, Compare, Allocator> &t,
-    const unsigned int /* file_version */
-){
-    load_set_collection(ar, t);
-}
-
-// split non-intrusive serialization function member into separate
-// non intrusive save/load member functions
-template<class Archive, class Key, class Compare, class Allocator >
-inline void serialize(
-    Archive & ar,
-    std::multiset<Key, Compare, Allocator> & t,
-    const unsigned int file_version
-){
-    boost::serialization::split_free(ar, t, file_version);
-}
-
-} // namespace serialization
-} // namespace boost
-
-#include <boost/serialization/collection_traits.hpp>
-
-BOOST_SERIALIZATION_COLLECTION_TRAITS(std::set)
-BOOST_SERIALIZATION_COLLECTION_TRAITS(std::multiset)
-
-#endif // BOOST_SERIALIZATION_SET_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/shared_ptr.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/shared_ptr.hpp
deleted file mode 100644
index 0d4c5ae6056..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/shared_ptr.hpp
+++ /dev/null
@@ -1,281 +0,0 @@
-#ifndef BOOST_SERIALIZATION_SHARED_PTR_HPP
-#define BOOST_SERIALIZATION_SHARED_PTR_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// shared_ptr.hpp: serialization for boost shared pointer
-
-// (C) Copyright 2004 Robert Ramey and Martin Ecker
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <cstddef> // NULL
-#include <memory>
-
-#include <boost/config.hpp>
-#include <boost/mpl/integral_c.hpp>
-#include <boost/mpl/integral_c_tag.hpp>
-
-#include <boost/detail/workaround.hpp>
-#include <boost/shared_ptr.hpp>
-
-#include <boost/serialization/shared_ptr_helper.hpp>
-#include <boost/serialization/split_free.hpp>
-#include <boost/serialization/nvp.hpp>
-#include <boost/serialization/version.hpp>
-#include <boost/serialization/tracking.hpp>
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// boost:: shared_ptr serialization traits
-// version 1 to distinguish from boost 1.32 version. Note: we can only do this
-// for a template when the compiler supports partial template specialization
-
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-    namespace boost {
-    namespace serialization{
-        template<class T>
-        struct version< ::boost::shared_ptr< T > > {
-            typedef mpl::integral_c_tag tag;
-            #if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3206))
-            typedef typename mpl::int_<1> type;
-            #else
-            typedef mpl::int_<1> type;
-            #endif
-            BOOST_STATIC_CONSTANT(int, value = type::value);
-        };
-        // don't track shared pointers
-        template<class T>
-        struct tracking_level< ::boost::shared_ptr< T > > { 
-            typedef mpl::integral_c_tag tag;
-            #if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3206))
-            typedef typename mpl::int_< ::boost::serialization::track_never> type;
-            #else
-            typedef mpl::int_< ::boost::serialization::track_never> type;
-            #endif
-            BOOST_STATIC_CONSTANT(int, value = type::value);
-        };
-    }}
-    #define BOOST_SERIALIZATION_SHARED_PTR(T)
-#else
-    // define macro to let users of these compilers do this
-    #define BOOST_SERIALIZATION_SHARED_PTR(T)                         \
-    BOOST_CLASS_VERSION(                                              \
-        ::boost::shared_ptr< T >,                                     \
-        1                                                             \
-    )                                                                 \
-    BOOST_CLASS_TRACKING(                                             \
-        ::boost::shared_ptr< T >,                                     \
-        ::boost::serialization::track_never                           \
-    )                                                                 \
-    /**/
-#endif
-
-namespace boost {
-namespace serialization{
-
-struct null_deleter {
-    void operator()(void const *) const {}
-};
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// serialization for boost::shared_ptr
-
-// Using a constant means that all shared pointers are held in the same set.
-// Thus we detect handle multiple pointers to the same value instances
-// in the archive.
-void * const shared_ptr_helper_id = 0;
-
-template<class Archive, class T>
-inline void save(
-    Archive & ar,
-    const boost::shared_ptr< T > &t,
-    const unsigned int /* file_version */
-){
-    // The most common cause of trapping here would be serializing
-    // something like shared_ptr<int>.  This occurs because int
-    // is never tracked by default.  Wrap int in a trackable type
-    BOOST_STATIC_ASSERT((tracking_level< T >::value != track_never));
-    const T * t_ptr = t.get();
-    ar << boost::serialization::make_nvp("px", t_ptr);
-}
-
-#ifdef BOOST_SERIALIZATION_SHARED_PTR_132_HPP
-template<class Archive, class T>
-inline void load(
-    Archive & ar,
-    boost::shared_ptr< T > &t,
-    const unsigned int file_version
-){
-    // something like shared_ptr<int>.  This occurs because int
-    // is never tracked by default.  Wrap int in a trackable type
-    BOOST_STATIC_ASSERT((tracking_level< T >::value != track_never));
-    T* r;
-    if(file_version < 1){
-        ar.register_type(static_cast<
-            boost_132::detail::sp_counted_base_impl<T *, null_deleter > *
-        >(NULL));
-        boost_132::shared_ptr< T > sp;
-        ar >> boost::serialization::make_nvp("px", sp.px);
-        ar >> boost::serialization::make_nvp("pn", sp.pn);
-        // got to keep the sps around so the sp.pns don't disappear
-        boost::serialization::shared_ptr_helper<boost::shared_ptr> & h =
-            ar.template get_helper< shared_ptr_helper<boost::shared_ptr> >(
-                shared_ptr_helper_id
-            );
-        h.append(sp);
-        r = sp.get();
-    }
-    else{
-        ar >> boost::serialization::make_nvp("px", r);
-    }
-    shared_ptr_helper<boost::shared_ptr> & h =
-        ar.template get_helper<shared_ptr_helper<boost::shared_ptr> >(
-            shared_ptr_helper_id
-        );
-    h.reset(t,r);
-}
-#else
-
-template<class Archive, class T>
-inline void load(
-    Archive & ar,
-    boost::shared_ptr< T > &t,
-    const unsigned int /*file_version*/
-){
-    // The most common cause of trapping here would be serializing
-    // something like shared_ptr<int>.  This occurs because int
-    // is never tracked by default.  Wrap int in a trackable type
-    BOOST_STATIC_ASSERT((tracking_level< T >::value != track_never));
-    T* r;
-    ar >> boost::serialization::make_nvp("px", r);
-
-    boost::serialization::shared_ptr_helper<boost::shared_ptr> & h =
-        ar.template get_helper<shared_ptr_helper<boost::shared_ptr> >(
-            shared_ptr_helper_id
-        );
-    h.reset(t,r);    
-}
-#endif
-
-template<class Archive, class T>
-inline void serialize(
-    Archive & ar,
-    boost::shared_ptr< T > &t,
-    const unsigned int file_version
-){
-    // correct shared_ptr serialization depends upon object tracking
-    // being used.
-    BOOST_STATIC_ASSERT(
-        boost::serialization::tracking_level< T >::value
-        != boost::serialization::track_never
-    );
-    boost::serialization::split_free(ar, t, file_version);
-}
-
-} // namespace serialization
-} // namespace boost
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// std::shared_ptr serialization traits
-// version 1 to distinguish from boost 1.32 version. Note: we can only do this
-// for a template when the compiler supports partial template specialization
-
-#ifndef BOOST_NO_CXX11_SMART_PTR
-#include <boost/static_assert.hpp>
-
-// note: we presume that any compiler/library which supports C++11
-// std::pointers also supports template partial specialization
-// trap here if such presumption were to turn out to wrong!!!
-#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-    BOOST_STATIC_ASSERT(false);
-#endif
-
-namespace boost {
-namespace serialization{
-    template<class T>
-    struct version< ::std::shared_ptr< T > > {
-        typedef mpl::integral_c_tag tag;
-        typedef mpl::int_<1> type;
-        BOOST_STATIC_CONSTANT(int, value = type::value);
-    };
-    // don't track shared pointers
-    template<class T>
-    struct tracking_level< ::std::shared_ptr< T > > { 
-        typedef mpl::integral_c_tag tag;
-        typedef mpl::int_< ::boost::serialization::track_never> type;
-        BOOST_STATIC_CONSTANT(int, value = type::value);
-    };
-}}
-// the following just keeps older programs from breaking
-#define BOOST_SERIALIZATION_SHARED_PTR(T)
-
-namespace boost {
-namespace serialization{
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// serialization for std::shared_ptr
-
-template<class Archive, class T>
-inline void save(
-    Archive & ar,
-    const std::shared_ptr< T > &t,
-    const unsigned int /* file_version */
-){
-    // The most common cause of trapping here would be serializing
-    // something like shared_ptr<int>.  This occurs because int
-    // is never tracked by default.  Wrap int in a trackable type
-    BOOST_STATIC_ASSERT((tracking_level< T >::value != track_never));
-    const T * t_ptr = t.get();
-    ar << boost::serialization::make_nvp("px", t_ptr);
-}
-
-template<class Archive, class T>
-inline void load(
-    Archive & ar,
-    std::shared_ptr< T > &t,
-    const unsigned int /*file_version*/
-){
-    // The most common cause of trapping here would be serializing
-    // something like shared_ptr<int>.  This occurs because int
-    // is never tracked by default.  Wrap int in a trackable type
-    BOOST_STATIC_ASSERT((tracking_level< T >::value != track_never));
-    T* r;
-    ar >> boost::serialization::make_nvp("px", r);
-    //void (* const id)(Archive &, std::shared_ptr< T > &, const unsigned int) = & load;
-    boost::serialization::shared_ptr_helper<std::shared_ptr> & h =
-        ar.template get_helper<
-            shared_ptr_helper<std::shared_ptr>
-        >(
-            shared_ptr_helper_id
-        );
-    h.reset(t,r);
-}
-
-template<class Archive, class T>
-inline void serialize(
-    Archive & ar,
-    std::shared_ptr< T > &t,
-    const unsigned int file_version
-){
-    // correct shared_ptr serialization depends upon object tracking
-    // being used.
-    BOOST_STATIC_ASSERT(
-        boost::serialization::tracking_level< T >::value
-        != boost::serialization::track_never
-    );
-    boost::serialization::split_free(ar, t, file_version);
-}
-
-} // namespace serialization
-} // namespace boost
-
-#endif // BOOST_NO_CXX11_SMART_PTR
-
-#endif // BOOST_SERIALIZATION_SHARED_PTR_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/shared_ptr_132.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/shared_ptr_132.hpp
deleted file mode 100644
index 3dfaba4d69a..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/shared_ptr_132.hpp
+++ /dev/null
@@ -1,222 +0,0 @@
-#ifndef BOOST_SERIALIZATION_SHARED_PTR_132_HPP
-#define BOOST_SERIALIZATION_SHARED_PTR_132_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// shared_ptr.hpp: serialization for boost shared pointer
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-// note: totally unadvised hack to gain access to private variables
-// in shared_ptr and shared_count. Unfortunately its the only way to
-// do this without changing shared_ptr and shared_count
-// the best we can do is to detect a conflict here
-#include <boost/config.hpp>
-
-#include <list>
-#include <cstddef> // NULL
-
-#include <boost/serialization/assume_abstract.hpp>
-#include <boost/serialization/split_free.hpp>
-#include <boost/serialization/nvp.hpp>
-#include <boost/serialization/tracking.hpp>
-#include <boost/serialization/void_cast.hpp>
-
-// mark base class as an (uncreatable) base class
-#include <boost/serialization/detail/shared_ptr_132.hpp>
-
-/////////////////////////////////////////////////////////////
-// Maintain a couple of lists of loaded shared pointers of the old previous
-// version (1.32)
-
-namespace boost_132 { 
-namespace serialization {
-namespace detail {
-
-struct null_deleter {
-    void operator()(void const *) const {}
-};
-
-} // namespace detail
-} // namespace serialization
-} // namespace boost_132
-
-/////////////////////////////////////////////////////////////
-// sp_counted_base_impl serialization
-
-namespace boost { 
-namespace serialization {
-
-template<class Archive, class P, class D>
-inline void serialize(
-    Archive & /* ar */,
-    boost_132::detail::sp_counted_base_impl<P, D> & /* t */,
-    const unsigned int /*file_version*/
-){
-    // register the relationship between each derived class
-    // its polymorphic base
-    boost::serialization::void_cast_register<
-        boost_132::detail::sp_counted_base_impl<P, D>,
-        boost_132::detail::sp_counted_base 
-    >(
-        static_cast<boost_132::detail::sp_counted_base_impl<P, D> *>(NULL),
-        static_cast<boost_132::detail::sp_counted_base *>(NULL)
-    );
-}
-
-template<class Archive, class P, class D>
-inline void save_construct_data(
-    Archive & ar,
-    const 
-    boost_132::detail::sp_counted_base_impl<P, D> *t, 
-    const unsigned int /* file_version */
-){
-    // variables used for construction
-    ar << boost::serialization::make_nvp("ptr", t->ptr);
-}
-
-template<class Archive, class P, class D>
-inline void load_construct_data(
-    Archive & ar,
-    boost_132::detail::sp_counted_base_impl<P, D> * t, 
-    const unsigned int /* file_version */
-){
-    P ptr_;
-    ar >> boost::serialization::make_nvp("ptr", ptr_);
-    // ::new(t)boost_132::detail::sp_counted_base_impl<P, D>(ptr_,  D()); 
-    // placement
-    // note: the original ::new... above is replaced by the one here.  This one
-    // creates all new objects with a null_deleter so that after the archive
-    // is finished loading and the shared_ptrs are destroyed - the underlying
-    // raw pointers are NOT deleted.  This is necessary as they are used by the 
-    // new system as well.
-    ::new(t)boost_132::detail::sp_counted_base_impl<
-        P, 
-        boost_132::serialization::detail::null_deleter
-    >(
-        ptr_,  boost_132::serialization::detail::null_deleter()
-    ); // placement new
-    // compensate for that fact that a new shared count always is 
-    // initialized with one. the add_ref_copy below will increment it
-    // every time its serialized so without this adjustment
-    // the use and weak counts will be off by one.
-    t->use_count_ = 0;
-}
-
-} // serialization
-} // namespace boost
-
-/////////////////////////////////////////////////////////////
-// shared_count serialization
-
-namespace boost { 
-namespace serialization {
-
-template<class Archive>
-inline void save(
-    Archive & ar,
-    const boost_132::detail::shared_count &t,
-    const unsigned int /* file_version */
-){
-    ar << boost::serialization::make_nvp("pi", t.pi_);
-}
-
-template<class Archive>
-inline void load(
-    Archive & ar,
-    boost_132::detail::shared_count &t,
-    const unsigned int /* file_version */
-){
-    ar >> boost::serialization::make_nvp("pi", t.pi_);
-    if(NULL != t.pi_)
-        t.pi_->add_ref_copy();
-}
-
-} // serialization
-} // namespace boost
-
-BOOST_SERIALIZATION_SPLIT_FREE(boost_132::detail::shared_count)
-
-/////////////////////////////////////////////////////////////
-// implement serialization for shared_ptr< T >
-
-namespace boost { 
-namespace serialization {
-
-template<class Archive, class T>
-inline void save(
-    Archive & ar,
-    const boost_132::shared_ptr< T > &t,
-    const unsigned int /* file_version */
-){
-    // only the raw pointer has to be saved
-    // the ref count is maintained automatically as shared pointers are loaded
-    ar.register_type(static_cast<
-        boost_132::detail::sp_counted_base_impl<T *, boost::checked_deleter< T > > *
-    >(NULL));
-    ar << boost::serialization::make_nvp("px", t.px);
-    ar << boost::serialization::make_nvp("pn", t.pn);
-}
-
-template<class Archive, class T>
-inline void load(
-    Archive & ar,
-    boost_132::shared_ptr< T > &t,
-    const unsigned int /* file_version */
-){
-    // only the raw pointer has to be saved
-    // the ref count is maintained automatically as shared pointers are loaded
-    ar.register_type(static_cast<
-        boost_132::detail::sp_counted_base_impl<T *, boost::checked_deleter< T > > *
-    >(NULL));
-    ar >> boost::serialization::make_nvp("px", t.px);
-    ar >> boost::serialization::make_nvp("pn", t.pn);
-}
-
-template<class Archive, class T>
-inline void serialize(
-    Archive & ar,
-    boost_132::shared_ptr< T > &t,
-    const unsigned int file_version
-){
-    // correct shared_ptr serialization depends upon object tracking
-    // being used.
-    BOOST_STATIC_ASSERT(
-        boost::serialization::tracking_level< T >::value
-        != boost::serialization::track_never
-    );
-    boost::serialization::split_free(ar, t, file_version);
-}
-
-} // serialization
-} // namespace boost
-
-// note: change below uses null_deleter 
-// This macro is used to export GUIDS for shared pointers to allow
-// the serialization system to export them properly. David Tonge
-#define BOOST_SHARED_POINTER_EXPORT_GUID(T, K)                     \
-    typedef boost_132::detail::sp_counted_base_impl<               \
-        T *,                                                       \
-        boost::checked_deleter< T >                                \
-    > __shared_ptr_ ## T;                                          \
-    BOOST_CLASS_EXPORT_GUID(__shared_ptr_ ## T, "__shared_ptr_" K) \
-    BOOST_CLASS_EXPORT_GUID(T, K)                                  \
-    /**/
-
-#define BOOST_SHARED_POINTER_EXPORT(T)                             \
-    BOOST_SHARED_POINTER_EXPORT_GUID(                              \
-        T,                                                         \
-        BOOST_PP_STRINGIZE(T)                                      \
-    )                                                              \
-    /**/
-
-#endif // BOOST_SERIALIZATION_SHARED_PTR_132_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/shared_ptr_helper.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/shared_ptr_helper.hpp
deleted file mode 100644
index 37c34d6b2c4..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/shared_ptr_helper.hpp
+++ /dev/null
@@ -1,209 +0,0 @@
-#ifndef BOOST_SERIALIZATION_SHARED_PTR_HELPER_HPP
-#define BOOST_SERIALIZATION_SHARED_PTR_HELPER_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// shared_ptr_helper.hpp: serialization for boost shared pointern
-
-// (C) Copyright 2004-2009 Robert Ramey, Martin Ecker and Takatoshi Kondo
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <map>
-#include <list>
-#include <utility>
-#include <cstddef> // NULL
-
-#include <boost/config.hpp>
-#include <boost/shared_ptr.hpp>
-#include <boost/type_traits/is_polymorphic.hpp>
-#include <boost/mpl/if.hpp>
-
-#include <boost/serialization/singleton.hpp>
-#include <boost/serialization/extended_type_info.hpp>
-#include <boost/serialization/throw_exception.hpp>
-#include <boost/serialization/type_info_implementation.hpp>
-#include <boost/archive/archive_exception.hpp>
-
-namespace boost_132 {
-    template<class T> class shared_ptr;
-}
-namespace boost {
-namespace serialization {
-
-#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
-template<class Archive, template<class U> class SPT >
-void load(
-    Archive & ar,
-    SPT< class U > &t,
-    const unsigned int file_version
-);
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// a common class for holding various types of shared pointers
-
-template<template<class T> class SPT>
-class shared_ptr_helper {
-    typedef std::map<
-        const void *, // address of object
-        SPT<const void> // address shared ptr to single instance
-    > object_shared_pointer_map;
-
-    // list of shared_pointers create accessable by raw pointer. This
-    // is used to "match up" shared pointers loaded at different
-    // points in the archive. Note, we delay construction until
-    // it is actually used since this is by default included as
-    // a "mix-in" even if shared_ptr isn't used.
-    object_shared_pointer_map * m_o_sp;
-
-    struct null_deleter {
-        void operator()(void const *) const {}
-    };
-
-#if defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS) \
-|| defined(BOOST_MSVC) \
-|| defined(__SUNPRO_CC)
-public:
-#else
-    template<class Archive, class U>
-    friend void boost::serialization::load(
-        Archive & ar,
-        SPT< U > &t,
-        const unsigned int file_version
-    );
-#endif
-
-    #ifdef BOOST_SERIALIZATION_SHARED_PTR_132_HPP
-    // list of loaded pointers.  This is used to be sure that the pointers
-    // stay around long enough to be "matched" with other pointers loaded
-    // by the same archive.  These are created with a "null_deleter" so that
-    // when this list is destroyed - the underlaying raw pointers are not
-    // destroyed.  This has to be done because the pointers are also held by
-    // new system which is disjoint from this set.  This is implemented
-    // by a change in load_construct_data below.  It makes this file suitable
-    // only for loading pointers into a 1.33 or later boost system.
-    std::list<boost_132::shared_ptr<const void> > * m_pointers_132;
-    void
-    append(const boost_132::shared_ptr<const void> & t){
-        if(NULL == m_pointers_132)
-            m_pointers_132 = new std::list<boost_132::shared_ptr<const void> >;
-        m_pointers_132->push_back(t);
-    }
-    #endif
-
-    struct non_polymorphic {
-        template<class U>
-        static const boost::serialization::extended_type_info * 
-        get_object_type(U & ){
-            return & boost::serialization::singleton<
-                typename 
-                boost::serialization::type_info_implementation< U >::type
-            >::get_const_instance();
-        }
-    };
-    struct polymorphic {
-        template<class U>
-        static const boost::serialization::extended_type_info * 
-        get_object_type(U & u){
-            return boost::serialization::singleton<
-                typename 
-                boost::serialization::type_info_implementation< U >::type
-            >::get_const_instance().get_derived_extended_type_info(u);
-        }
-    };
-
-public:
-    template<class T>
-    void reset(SPT< T > & s, T * t){
-        if(NULL == t){
-            s.reset();
-            return;
-        }
-        const boost::serialization::extended_type_info * this_type
-            = & boost::serialization::type_info_implementation< T >::type
-                    ::get_const_instance();
-
-        // get pointer to the most derived object's eti.  This is effectively
-        // the object type identifer
-        typedef typename mpl::if_<
-            is_polymorphic< T >,
-            polymorphic,
-            non_polymorphic
-        >::type type;
-
-        const boost::serialization::extended_type_info * true_type
-            = type::get_object_type(*t);
-
-        // note:if this exception is thrown, be sure that derived pointern
-        // is either registered or exported.
-        if(NULL == true_type)
-            boost::serialization::throw_exception(
-                boost::archive::archive_exception(
-                    boost::archive::archive_exception::unregistered_class,
-                    this_type->get_debug_info()
-                )
-            );
-        // get void pointer to the most derived type
-        // this uniquely identifies the object referred to
-        // oid = "object identifier"
-        const void * oid = void_downcast(
-            *true_type,
-            *this_type,
-            t
-        );
-        if(NULL == oid)
-            boost::serialization::throw_exception(
-                boost::archive::archive_exception(
-                    boost::archive::archive_exception::unregistered_cast,
-                    true_type->get_debug_info(),
-                    this_type->get_debug_info()
-                )
-            );
-
-        // make tracking array if necessary
-        if(NULL == m_o_sp)
-            m_o_sp = new object_shared_pointer_map;
-
-        typename object_shared_pointer_map::iterator i = m_o_sp->find(oid);
-
-        // if it's a new object
-        if(i == m_o_sp->end()){
-            s.reset(t);
-            std::pair<typename object_shared_pointer_map::iterator, bool> result;
-            result = m_o_sp->insert(std::make_pair(oid, s));
-            BOOST_ASSERT(result.second);
-        }
-        // if the object has already been seen
-        else{
-            s = SPT<T>(i->second, t);
-        }
-    }
-
-    shared_ptr_helper() :
-        m_o_sp(NULL)
-        #ifdef BOOST_SERIALIZATION_SHARED_PTR_132_HPP
-            , m_pointers_132(NULL)
-        #endif
-    {}
-    virtual ~shared_ptr_helper(){
-        if(NULL != m_o_sp)
-            delete m_o_sp;
-        #ifdef BOOST_SERIALIZATION_SHARED_PTR_132_HPP
-        if(NULL != m_pointers_132)
-            delete m_pointers_132;
-        #endif
-    }
-};
-
-} // namespace serialization
-} // namespace boost
-
-#endif // BOOST_SERIALIZATION_SHARED_PTR_HELPER_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/singleton.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/singleton.hpp
deleted file mode 100644
index b50afedbb92..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/singleton.hpp
+++ /dev/null
@@ -1,166 +0,0 @@
-#ifndef BOOST_SERIALIZATION_SINGLETON_HPP
-#define BOOST_SERIALIZATION_SINGLETON_HPP
-
-/////////1/////////2///////// 3/////////4/////////5/////////6/////////7/////////8
-//  singleton.hpp
-//
-// Copyright David Abrahams 2006. Original version
-//
-// Copyright Robert Ramey 2007.  Changes made to permit
-// application throughout the serialization library.
-//
-// Distributed under the Boost
-// Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-// The intention here is to define a template which will convert
-// any class into a singleton with the following features:
-//
-// a) initialized before first use.
-// b) thread-safe for const access to the class
-// c) non-locking
-//
-// In order to do this,
-// a) Initialize dynamically when used.
-// b) Require that all singletons be initialized before main
-// is called or any entry point into the shared library is invoked.
-// This guarentees no race condition for initialization.
-// In debug mode, we assert that no non-const functions are called
-// after main is invoked.
-//
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif 
-
-#include <boost/assert.hpp>
-#include <boost/config.hpp>
-#include <boost/noncopyable.hpp>
-#include <boost/serialization/force_include.hpp>
-
-#include <boost/archive/detail/auto_link_archive.hpp>
-#include <boost/serialization/config.hpp>
-#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
-
-#ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable : 4511 4512)
-#endif
-
-namespace boost { 
-namespace serialization { 
-
-//////////////////////////////////////////////////////////////////////
-// Provides a dynamically-initialized (singleton) instance of T in a
-// way that avoids LNK1179 on vc6.  See http://tinyurl.com/ljdp8 or
-// http://lists.boost.org/Archives/boost/2006/05/105286.php for
-// details.
-//
-
-// singletons created by this code are guarenteed to be unique
-// within the executable or shared library which creates them.
-// This is sufficient and in fact ideal for the serialization library.
-// The singleton is created when the module is loaded and destroyed
-// when the module is unloaded.
-
-// This base class has two functions.
-
-// First it provides a module handle for each singleton indicating
-// the executable or shared library in which it was created. This
-// turns out to be necessary and sufficient to implement the tables
-// used by serialization library.
-
-// Second, it provides a mechanism to detect when a non-const function
-// is called after initialization.
-
-// make a singleton to lock/unlock all singletons for alteration.
-// The intent is that all singletons created/used by this code
-// are to be initialized before main is called. A test program
-// can lock all the singletons when main is entereed.  This any
-// attempt to retieve a mutable instances while locked will
-// generate a assertion if compiled for debug.
-
-// note usage of BOOST_DLLEXPORT.  These functions are in danger of
-// being eliminated by the optimizer when building an application in
-// release mode. Usage of the macro is meant to signal the compiler/linker
-// to avoid dropping these functions which seem to be unreferenced.
-// This usage is not related to autolinking.
-
-class BOOST_SYMBOL_VISIBLE singleton_module :
-    public boost::noncopyable
-{
-private:
-    BOOST_SERIALIZATION_DECL BOOST_DLLEXPORT static bool & get_lock() BOOST_USED;
-public:
-    BOOST_DLLEXPORT static void lock(){
-        get_lock() = true;
-    }
-    BOOST_DLLEXPORT static void unlock(){
-        get_lock() = false;
-    }
-    BOOST_DLLEXPORT static bool is_locked(){
-        return get_lock();
-    }
-};
-
-template <class T>
-class singleton : public singleton_module
-{
-private:
-    static T & m_instance;
-    // include this to provoke instantiation at pre-execution time
-    static void use(T const *) {}
-    static T & get_instance() {
-        // use a wrapper so that types T with protected constructors
-        // can be used
-        class singleton_wrapper : public T {};
-        static singleton_wrapper t;
-        // refer to instance, causing it to be instantiated (and
-        // initialized at startup on working compilers)
-        BOOST_ASSERT(! is_destroyed());
-        // note that the following is absolutely essential.
-        // commenting out this statement will cause compilers to fail to
-        // construct the instance at pre-execution time.  This would prevent
-        // our usage/implementation of "locking" and introduce uncertainty into
-        // the sequence of object initializaition.
-        use(& m_instance);
-        return static_cast<T &>(t);
-    }
-    static bool & get_is_destroyed(){
-        static bool is_destroyed;
-        return is_destroyed;
-    }
-
-public:
-    BOOST_DLLEXPORT static T & get_mutable_instance(){
-        BOOST_ASSERT(! is_locked());
-        return get_instance();
-    }
-    BOOST_DLLEXPORT static const T & get_const_instance(){
-        return get_instance();
-    }
-    BOOST_DLLEXPORT static bool is_destroyed(){
-        return get_is_destroyed();
-    }
-    BOOST_DLLEXPORT singleton(){
-        get_is_destroyed() = false;
-    }
-    BOOST_DLLEXPORT ~singleton() {
-        get_is_destroyed() = true;
-    }
-};
-
-template<class T>
-T & singleton< T >::m_instance = singleton< T >::get_instance();
-
-} // namespace serialization
-} // namespace boost
-
-#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
-
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
-
-#endif // BOOST_SERIALIZATION_SINGLETON_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/slist.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/slist.hpp
deleted file mode 100644
index d9b971bc4f1..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/slist.hpp
+++ /dev/null
@@ -1,145 +0,0 @@
-#ifndef BOOST_SERIALIZATION_SLIST_HPP
-#define BOOST_SERIALIZATION_SLIST_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// slist.hpp
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/config.hpp>
-#ifdef BOOST_HAS_SLIST
-#include BOOST_SLIST_HEADER
-
-#include <boost/serialization/collections_save_imp.hpp>
-#include <boost/serialization/collections_load_imp.hpp>
-#include <boost/archive/detail/basic_iarchive.hpp>
-#include <boost/serialization/nvp.hpp>
-#include <boost/serialization/collection_size_type.hpp>
-#include <boost/serialization/item_version_type.hpp>
-#include <boost/serialization/split_free.hpp>
-#include <boost/serialization/detail/stack_constructor.hpp>
-#include <boost/serialization/detail/is_default_constructible.hpp>
-#include <boost/move/utility_core.hpp>
-
-namespace boost { 
-namespace serialization {
-
-template<class Archive, class U, class Allocator>
-inline void save(
-    Archive & ar,
-    const BOOST_STD_EXTENSION_NAMESPACE::slist<U, Allocator> &t,
-    const unsigned int file_version
-){
-    boost::serialization::stl::save_collection<
-        Archive,
-        BOOST_STD_EXTENSION_NAMESPACE::slist<U, Allocator> 
-    >(ar, t);
-}
-
-namespace stl {
-
-template<
-    class Archive,
-    class T,
-    class Allocator
->
-typename boost::disable_if<
-    typename detail::is_default_constructible<
-        typename BOOST_STD_EXTENSION_NAMESPACE::slist<T, Allocator>::value_type
-    >,
-    void
->::type
-collection_load_impl(
-    Archive & ar,
-    BOOST_STD_EXTENSION_NAMESPACE::slist<T, Allocator> &t,
-    collection_size_type count,
-    item_version_type item_version
-){
-    t.clear();
-    boost::serialization::detail::stack_construct<Archive, T> u(ar, item_version);
-    ar >> boost::serialization::make_nvp("item", u.reference());
-    t.push_front(boost::move(u.reference()));
-    typename BOOST_STD_EXTENSION_NAMESPACE::slist<T, Allocator>::iterator last;
-    last = t.begin();
-    ar.reset_object_address(&(*t.begin()) , & u.reference());
-    while(--count > 0){
-        detail::stack_construct<Archive, T> u(ar, item_version);
-        ar >> boost::serialization::make_nvp("item", u.reference());
-        last = t.insert_after(last, boost::move(u.reference()));
-        ar.reset_object_address(&(*last) , & u.reference());
-    }
-}
-
-} // stl
-
-template<class Archive, class U, class Allocator>
-inline void load(
-    Archive & ar,
-    BOOST_STD_EXTENSION_NAMESPACE::slist<U, Allocator> &t,
-    const unsigned int file_version
-){
-    const boost::archive::library_version_type library_version(
-        ar.get_library_version()
-    );
-    // retrieve number of elements
-    item_version_type item_version(0);
-    collection_size_type count;
-    ar >> BOOST_SERIALIZATION_NVP(count);
-    if(boost::archive::library_version_type(3) < library_version){
-        ar >> BOOST_SERIALIZATION_NVP(item_version);
-    }
-    if(detail::is_default_constructible<U>()){
-        t.resize(count);
-        typename BOOST_STD_EXTENSION_NAMESPACE::slist<U, Allocator>::iterator hint;
-        hint = t.begin();
-        while(count-- > 0){
-            ar >> boost::serialization::make_nvp("item", *hint++);
-        }
-    }
-    else{
-        t.clear();
-        boost::serialization::detail::stack_construct<Archive, U> u(ar, item_version);
-        ar >> boost::serialization::make_nvp("item", u.reference());
-        t.push_front(boost::move(u.reference()));
-        typename BOOST_STD_EXTENSION_NAMESPACE::slist<U, Allocator>::iterator last;
-        last = t.begin();
-        ar.reset_object_address(&(*t.begin()) , & u.reference());
-        while(--count > 0){
-            detail::stack_construct<Archive, U> u(ar, item_version);
-            ar >> boost::serialization::make_nvp("item", u.reference());
-            last = t.insert_after(last, boost::move(u.reference()));
-            ar.reset_object_address(&(*last) , & u.reference());
-        }
-    }
-}
-
-// split non-intrusive serialization function member into separate
-// non intrusive save/load member functions
-template<class Archive, class U, class Allocator>
-inline void serialize(
-    Archive & ar,
-    BOOST_STD_EXTENSION_NAMESPACE::slist<U, Allocator> &t,
-    const unsigned int file_version
-){
-    boost::serialization::split_free(ar, t, file_version);
-}
-
-} // serialization
-} // namespace boost
-
-#include <boost/serialization/collection_traits.hpp>
-
-BOOST_SERIALIZATION_COLLECTION_TRAITS(BOOST_STD_EXTENSION_NAMESPACE::slist)
-
-#endif  // BOOST_HAS_SLIST
-#endif  // BOOST_SERIALIZATION_SLIST_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/smart_cast.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/smart_cast.hpp
deleted file mode 100644
index 563f36aa20b..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/smart_cast.hpp
+++ /dev/null
@@ -1,275 +0,0 @@
-#ifndef BOOST_SERIALIZATION_SMART_CAST_HPP
-#define BOOST_SERIALIZATION_SMART_CAST_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// smart_cast.hpp:
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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/serialization for updates, documentation, and revision history.
-
-// casting of pointers and references.  
-
-// In casting between different C++ classes, there are a number of
-// rules that have to be kept in mind in deciding whether to use
-// static_cast or dynamic_cast.  
-
-// a) dynamic casting can only be applied when one of the types is polymorphic
-// Otherwise static_cast must be used.
-// b) only dynamic casting can do runtime error checking
-// use of static_cast is generally un checked even when compiled for debug
-// c) static_cast would be considered faster than dynamic_cast.
-
-// If casting is applied to a template parameter, there is no apriori way
-// to know which of the two casting methods will be permitted or convenient.
-
-// smart_cast uses C++ type_traits, and program debug mode to select the
-// most convenient cast to use.
-
-#include <exception>
-#include <typeinfo>
-#include <cstddef> // NULL
-
-#include <boost/config.hpp>
-#include <boost/static_assert.hpp>
-
-#include <boost/type_traits/is_base_and_derived.hpp>
-#include <boost/type_traits/is_polymorphic.hpp>
-#include <boost/type_traits/is_pointer.hpp>
-#include <boost/type_traits/is_reference.hpp>
-#include <boost/type_traits/is_same.hpp>
-#include <boost/type_traits/remove_pointer.hpp>
-#include <boost/type_traits/remove_reference.hpp>
-
-#include <boost/mpl/eval_if.hpp>
-#include <boost/mpl/if.hpp>
-#include <boost/mpl/or.hpp>
-#include <boost/mpl/and.hpp>
-#include <boost/mpl/not.hpp>
-#include <boost/mpl/identity.hpp>
-
-#include <boost/serialization/throw_exception.hpp>
-
-namespace boost {
-namespace serialization {
-namespace smart_cast_impl {
-
-    template<class T>
-    struct reference {
-
-        struct polymorphic {
-
-            struct linear {
-                template<class U>
-                 static T cast(U & u){
-                    return static_cast< T >(u);
-                }
-            };
-
-            struct cross {
-                 template<class U>
-                static T cast(U & u){
-                    return dynamic_cast< T >(u);
-                }
-            };
-
-            template<class U>
-            static T cast(U & u){
-                // if we're in debug mode
-                #if ! defined(NDEBUG)                               \
-                || defined(__MWERKS__)
-                    // do a checked dynamic cast
-                    return cross::cast(u);
-                #else
-                    // borland 5.51 chokes here so we can't use it
-                    // note: if remove_reference isn't function for these types
-                    // cross casting will be selected this will work but will
-                    // not be the most efficient method. This will conflict with
-                    // the original smart_cast motivation.
-                    typedef typename mpl::eval_if<
-                            typename mpl::and_<
-                                mpl::not_<is_base_and_derived<
-                                    typename remove_reference< T >::type,
-                                    U
-                                > >,
-                                mpl::not_<is_base_and_derived<
-                                    U,
-                                    typename remove_reference< T >::type
-                                > >
-                            >,
-                            // borland chokes w/o full qualification here
-                            mpl::identity<cross>,
-                            mpl::identity<linear>
-                    >::type typex;
-                    // typex works around gcc 2.95 issue
-                    return typex::cast(u);
-                #endif
-            }
-        };
-
-        struct non_polymorphic {
-            template<class U>
-             static T cast(U & u){
-                return static_cast< T >(u);
-            }
-        };
-        template<class U>
-        static T cast(U & u){
-            typedef typename mpl::eval_if<
-                boost::is_polymorphic<U>,
-                mpl::identity<polymorphic>,
-                mpl::identity<non_polymorphic>
-            >::type typex;
-            return typex::cast(u);
-        }
-    };
-
-    template<class T>
-    struct pointer {
-
-        struct polymorphic {
-            // unfortunately, this below fails to work for virtual base 
-            // classes.  need has_virtual_base to do this.
-            // Subject for further study
-            #if 0
-            struct linear {
-                template<class U>
-                 static T cast(U * u){
-                    return static_cast< T >(u);
-                }
-            };
-
-            struct cross {
-                template<class U>
-                static T cast(U * u){
-                    T tmp = dynamic_cast< T >(u);
-                    #ifndef NDEBUG
-                        if ( tmp == 0 ) throw_exception(std::bad_cast());
-                    #endif
-                    return tmp;
-                }
-            };
-
-            template<class U>
-            static T cast(U * u){
-                typedef
-                    typename mpl::eval_if<
-                        typename mpl::and_<
-                            mpl::not_<is_base_and_derived<
-                                typename remove_pointer< T >::type,
-                                U
-                            > >,
-                            mpl::not_<is_base_and_derived<
-                                U,
-                                typename remove_pointer< T >::type
-                            > >
-                        >,
-                        // borland chokes w/o full qualification here
-                        mpl::identity<cross>,
-                        mpl::identity<linear>
-                    >::type typex;
-                return typex::cast(u);
-            }
-            #else
-            template<class U>
-            static T cast(U * u){
-                T tmp = dynamic_cast< T >(u);
-                #ifndef NDEBUG
-                    if ( tmp == 0 ) throw_exception(std::bad_cast());
-                #endif
-                return tmp;
-            }
-            #endif
-        };
-
-        struct non_polymorphic {
-            template<class U>
-             static T cast(U * u){
-                return static_cast< T >(u);
-            }
-        };
-
-        template<class U>
-        static T cast(U * u){
-            typedef typename mpl::eval_if<
-                boost::is_polymorphic<U>,
-                mpl::identity<polymorphic>,
-                mpl::identity<non_polymorphic>
-            >::type typex;
-            return typex::cast(u);
-        }
-
-    };
-
-    template<class TPtr>
-    struct void_pointer {
-        template<class UPtr>
-        static TPtr cast(UPtr uptr){
-            return static_cast<TPtr>(uptr);
-        }
-    };
-
-    template<class T>
-    struct error {
-        // if we get here, its because we are using one argument in the
-        // cast on a system which doesn't support partial template 
-        // specialization
-        template<class U>
-        static T cast(U){
-            BOOST_STATIC_ASSERT(sizeof(T)==0);
-            return * static_cast<T *>(NULL);
-        }
-    };
-
-} // smart_cast_impl
-
-// this implements:
-// smart_cast<Target *, Source *>(Source * s)
-// smart_cast<Target &, Source &>(s)
-// note that it will fail with
-// smart_cast<Target &>(s)
-template<class T, class U>
-T smart_cast(U u) {
-    typedef
-        typename mpl::eval_if<
-            typename mpl::or_<
-                boost::is_same<void *, U>,
-                boost::is_same<void *, T>,
-                boost::is_same<const void *, U>,
-                boost::is_same<const void *, T>
-            >,
-            mpl::identity<smart_cast_impl::void_pointer< T > >,
-        // else
-        typename mpl::eval_if<boost::is_pointer<U>,
-            mpl::identity<smart_cast_impl::pointer< T > >,
-        // else
-        typename mpl::eval_if<boost::is_reference<U>,
-            mpl::identity<smart_cast_impl::reference< T > >,
-        // else
-            mpl::identity<smart_cast_impl::error< T >
-        >
-        >
-        >
-        >::type typex;
-    return typex::cast(u);
-}
-
-// this implements:
-// smart_cast_reference<Target &>(Source & s)
-template<class T, class U>
-T smart_cast_reference(U & u) {
-    return smart_cast_impl::reference< T >::cast(u);
-}
-
-} // namespace serialization
-} // namespace boost
-
-#endif // BOOST_SERIALIZATION_SMART_CAST_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/split_free.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/split_free.hpp
deleted file mode 100644
index 85e2f590fe4..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/split_free.hpp
+++ /dev/null
@@ -1,93 +0,0 @@
-#ifndef BOOST_SERIALIZATION_SPLIT_FREE_HPP
-#define BOOST_SERIALIZATION_SPLIT_FREE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// split_free.hpp:
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/config.hpp>
-#include <boost/mpl/eval_if.hpp>
-#include <boost/mpl/identity.hpp>
-#include <boost/serialization/serialization.hpp>
-
-namespace boost {
-namespace archive {
-    namespace detail {
-        template<class Archive> class interface_oarchive;
-        template<class Archive> class interface_iarchive;
-    } // namespace detail
-} // namespace archive
-
-namespace serialization {
-
-//namespace detail {
-template<class Archive, class T>
-struct free_saver {
-    static void invoke(
-        Archive & ar, 
-        const  T & t, 
-        const unsigned int file_version
-    ){
-        // use function overload (version_type) to workaround
-        // two-phase lookup issue
-        const version_type v(file_version);
-        save(ar, t, v);
-    }
-};
-template<class Archive, class T>
-struct free_loader {
-    static void invoke(
-        Archive & ar, 
-        T & t, 
-        const unsigned int file_version
-    ){
-        // use function overload (version_type) to workaround
-        // two-phase lookup issue
-        const version_type v(file_version);
-        load(ar, t, v);
-    }
-};
-//} // namespace detail
-
-template<class Archive, class T>
-inline void split_free(
-    Archive & ar, 
-    T & t, 
-    const unsigned int file_version
-){
-    typedef typename mpl::eval_if<
-        typename Archive::is_saving,
-        mpl::identity</* detail:: */ free_saver<Archive, T> >, 
-        mpl::identity</* detail:: */ free_loader<Archive, T> >
-    >::type typex;
-    typex::invoke(ar, t, file_version);
-}
-
-} // namespace serialization
-} // namespace boost
-
-#define BOOST_SERIALIZATION_SPLIT_FREE(T)       \
-namespace boost { namespace serialization {     \
-template<class Archive>                         \
-inline void serialize(                          \
-        Archive & ar,                               \
-        T & t,                                      \
-        const unsigned int file_version             \
-){                                              \
-        split_free(ar, t, file_version);            \
-}                                               \
-}}
-/**/
-
-#endif // BOOST_SERIALIZATION_SPLIT_FREE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/split_member.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/split_member.hpp
deleted file mode 100644
index 5f32520559e..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/split_member.hpp
+++ /dev/null
@@ -1,86 +0,0 @@
-#ifndef BOOST_SERIALIZATION_SPLIT_MEMBER_HPP
-#define BOOST_SERIALIZATION_SPLIT_MEMBER_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// split_member.hpp:
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/config.hpp>
-#include <boost/mpl/eval_if.hpp>
-#include <boost/mpl/identity.hpp>
-
-#include <boost/serialization/access.hpp>
-
-namespace boost {
-namespace archive {
-    namespace detail {
-        template<class Archive> class interface_oarchive;
-        template<class Archive> class interface_iarchive;
-    } // namespace detail
-} // namespace archive
-
-namespace serialization {
-namespace detail {
-
-    template<class Archive, class T>
-    struct member_saver {
-        static void invoke(
-            Archive & ar, 
-            const T & t,
-            const unsigned int file_version
-        ){
-            access::member_save(ar, t, file_version);
-        }
-    };
-
-    template<class Archive, class T>
-    struct member_loader {
-        static void invoke(
-            Archive & ar, 
-            T & t,
-            const unsigned int file_version
-        ){
-            access::member_load(ar, t, file_version);
-        }
-    };
-
-} // detail
-
-template<class Archive, class T>
-inline void split_member(
-    Archive & ar, T & t, const unsigned int file_version
-){
-    typedef typename mpl::eval_if<
-        typename Archive::is_saving,
-        mpl::identity<detail::member_saver<Archive, T> >, 
-        mpl::identity<detail::member_loader<Archive, T> >
-    >::type typex;
-    typex::invoke(ar, t, file_version);
-}
-
-} // namespace serialization
-} // namespace boost
-
-// split member function serialize funcition into save/load
-#define BOOST_SERIALIZATION_SPLIT_MEMBER()                       \
-template<class Archive>                                          \
-void serialize(                                                  \
-    Archive &ar,                                                 \
-    const unsigned int file_version                              \
-){                                                               \
-    boost::serialization::split_member(ar, *this, file_version); \
-}                                                                \
-/**/
-
-#endif // BOOST_SERIALIZATION_SPLIT_MEMBER_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/stack.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/stack.hpp
deleted file mode 100644
index 96f90fe8767..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/stack.hpp
+++ /dev/null
@@ -1,76 +0,0 @@
-#ifndef  BOOST_SERIALIZATION_STACK_HPP
-#define BOOST_SERIALIZATION_STACK_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// stack.hpp
-
-// (C) Copyright 2014 Robert Ramey - http://www.rrsd.com .
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <stack>
-#include <boost/config.hpp>
-#include <boost/mpl/eval_if.hpp>
-#include <boost/mpl/identity.hpp>
-
-// function specializations must be defined in the appropriate
-// namespace - boost::serialization
-#if defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION)
-#define STD _STLP_STD
-#else
-#define STD std
-#endif
-
-namespace boost { 
-namespace serialization {
-namespace detail{
-
-template <typename U, typename C>
-struct stack_save : public STD::stack<U, C> {
-    template<class Archive>
-    void operator()(Archive & ar, const unsigned int file_version) const {
-        save(ar, STD::stack<U, C>::c, file_version);
-    }
-};
-template <typename U, typename C>
-struct stack_load : public STD::stack<U, C> {
-    template<class Archive>
-    void operator()(Archive & ar, const unsigned int file_version) {
-        load(ar, STD::stack<U, C>::c, file_version);
-    }
-};
-
-} // detail
-
-template<class Archive, class T, class C>
-inline void serialize(
-    Archive & ar,
-    std::stack< T, C> & t,
-    const unsigned int file_version 
-){
-    typedef typename mpl::eval_if<
-        typename Archive::is_saving,
-        mpl::identity<detail::stack_save<T, C> >,
-        mpl::identity<detail::stack_load<T, C> >
-    >::type typex;
-    static_cast<typex &>(t)(ar, file_version);
-}
-
-} // namespace serialization
-} // namespace boost
-
-#include <boost/serialization/collection_traits.hpp>
-
-BOOST_SERIALIZATION_COLLECTION_TRAITS(STD::stack)
-
-#undef STD
-
-#endif // BOOST_SERIALIZATION_DEQUE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/state_saver.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/state_saver.hpp
deleted file mode 100644
index 248b8d91556..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/state_saver.hpp
+++ /dev/null
@@ -1,96 +0,0 @@
-#ifndef BOOST_SERIALIZATION_STATE_SAVER_HPP
-#define BOOST_SERIALIZATION_STATE_SAVER_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// state_saver.hpp:
-
-// (C) Copyright 2003-4 Pavel Vozenilek and Robert Ramey - http://www.rrsd.com.
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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/serialization for updates, documentation, and revision history.
-
-// Inspired by Daryle Walker's iostate_saver concept.  This saves the original
-// value of a variable when a state_saver is constructed and restores
-// upon destruction.  Useful for being sure that state is restored to
-// variables upon exit from scope.
-
-
-#include <boost/config.hpp>
-#ifndef BOOST_NO_EXCEPTIONS
-    #include <exception>
-#endif
-
-#include <boost/call_traits.hpp>
-#include <boost/noncopyable.hpp>
-#include <boost/type_traits/has_nothrow_copy.hpp>
-#include <boost/core/no_exceptions_support.hpp>
-
-#include <boost/mpl/eval_if.hpp>
-#include <boost/mpl/identity.hpp>
-
-namespace boost {
-namespace serialization {
-
-template<class T>
-// T requirements:
-//  - POD or object semantic (cannot be reference, function, ...)
-//  - copy constructor
-//  - operator = (no-throw one preferred)
-class state_saver : private boost::noncopyable
-{
-private:
-    const T previous_value;
-    T & previous_ref;
-
-    struct restore {
-        static void invoke(T & previous_ref, const T & previous_value){
-            previous_ref = previous_value; // won't throw
-        }
-    };
-
-    struct restore_with_exception {
-        static void invoke(T & previous_ref, const T & previous_value){
-            BOOST_TRY{
-                previous_ref = previous_value;
-            } 
-            BOOST_CATCH(::std::exception &) { 
-                // we must ignore it - we are in destructor
-            }
-            BOOST_CATCH_END
-        }
-    };
-
-public:
-    state_saver(
-        T & object
-    ) : 
-        previous_value(object),
-        previous_ref(object) 
-    {}
-    
-    ~state_saver() {
-        #ifndef BOOST_NO_EXCEPTIONS
-            typedef typename mpl::eval_if<
-                has_nothrow_copy< T >,
-                mpl::identity<restore>,
-                mpl::identity<restore_with_exception>
-            >::type typex;
-            typex::invoke(previous_ref, previous_value);
-        #else
-            previous_ref = previous_value;
-        #endif
-    }
-
-}; // state_saver<>
-
-} // serialization
-} // boost
-
-#endif //BOOST_SERIALIZATION_STATE_SAVER_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/static_warning.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/static_warning.hpp
deleted file mode 100644
index 1d9238fc4d9..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/static_warning.hpp
+++ /dev/null
@@ -1,103 +0,0 @@
-#ifndef BOOST_SERIALIZATION_STATIC_WARNING_HPP
-#define BOOST_SERIALIZATION_STATIC_WARNING_HPP
-
-//  (C) Copyright Robert Ramey 2003. Jonathan Turkanis 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
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-// http://www.boost.org/LICENSE_1_0.txt)
-
-//  See http://www.boost.org/libs/static_assert for documentation.
-
-/*
- Revision history:
-   15 June  2003 - Initial version.
-   31 March 2004 - improved diagnostic messages and portability 
-                   (Jonathan Turkanis)
-   03 April 2004 - works on VC6 at class and namespace scope
-                 - ported to DigitalMars
-                 - static warnings disabled by default; when enabled,
-                   uses pragmas to enable required compiler warnings
-                   on MSVC, Intel, Metrowerks and Borland 5.x.
-                   (Jonathan Turkanis)
-   30 May 2004   - tweaked for msvc 7.1 and gcc 3.3
-                 - static warnings ENabled by default; when enabled,
-                   (Robert Ramey)
-*/
-
-#include <boost/config.hpp>
-
-//
-// Implementation
-// Makes use of the following warnings:
-//  1. GCC prior to 3.3: division by zero.
-//  2. BCC 6.0 preview: unreferenced local variable.
-//  3. DigitalMars: returning address of local automatic variable.
-//  4. VC6: class previously seen as struct (as in 'boost/mpl/print.hpp')
-//  5. All others: deletion of pointer to incomplete type.
-//
-// The trick is to find code which produces warnings containing the name of
-// a structure or variable. Details, with same numbering as above:
-// 1. static_warning_impl<B>::value is zero iff B is false, so diving an int
-//    by this value generates a warning iff B is false.
-// 2. static_warning_impl<B>::type has a constructor iff B is true, so an
-//    unreferenced variable of this type generates a warning iff B is false.
-// 3. static_warning_impl<B>::type overloads operator& to return a dynamically
-//    allocated int pointer only is B is true, so  returning the address of an
-//    automatic variable of this type generates a warning iff B is fasle.
-// 4. static_warning_impl<B>::STATIC_WARNING is decalred as a struct iff B is 
-//    false. 
-// 5. static_warning_impl<B>::type is incomplete iff B is false, so deleting a
-//    pointer to this type generates a warning iff B is false.
-//
-
-//------------------Enable selected warnings----------------------------------//
-
-// Enable the warnings relied on by BOOST_STATIC_WARNING, where possible.
-
-// 6. replaced implementation with one which depends solely on
-//    mpl::print<>.  The previous one was found to fail for functions
-//    under recent versions of gcc and intel compilers - Robert Ramey
-
-#include <boost/mpl/bool.hpp>
-#include <boost/mpl/print.hpp>
-#include <boost/mpl/eval_if.hpp>
-#include <boost/mpl/bool_fwd.hpp>
-#include <boost/static_assert.hpp>
-
-namespace boost {
-namespace serialization {
-
-template<int L> 
-struct BOOST_SERIALIZATION_STATIC_WARNING_LINE{};
-
-template<bool B, int L>
-struct static_warning_test{
-    typename boost::mpl::eval_if_c<
-        B,
-        boost::mpl::true_,
-        typename boost::mpl::identity<
-            boost::mpl::print<
-                BOOST_SERIALIZATION_STATIC_WARNING_LINE<L>
-            >
-        >
-    >::type type;
-};
-
-template<int i>
-struct BOOST_SERIALIZATION_SS {};
-
-} // serialization
-} // boost
-
-#define BOOST_SERIALIZATION_BSW(B, L) \
-    typedef boost::serialization::BOOST_SERIALIZATION_SS< \
-        sizeof( boost::serialization::static_warning_test< B, L > ) \
-    > BOOST_JOIN(STATIC_WARNING_LINE, L) BOOST_ATTRIBUTE_UNUSED; 
-#define BOOST_STATIC_WARNING(B) BOOST_SERIALIZATION_BSW(B, __LINE__)
-
-#endif // BOOST_SERIALIZATION_STATIC_WARNING_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/string.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/string.hpp
deleted file mode 100644
index 76e695d4f3c..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/string.hpp
+++ /dev/null
@@ -1,30 +0,0 @@
-#ifndef  BOOST_SERIALIZATION_STRING_HPP
-#define BOOST_SERIALIZATION_STRING_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// serialization/string.hpp:
-// serialization for stl string templates
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <string>
-
-#include <boost/config.hpp>
-#include <boost/serialization/level.hpp>
-
-BOOST_CLASS_IMPLEMENTATION(std::string, boost::serialization::primitive_type)
-#ifndef BOOST_NO_STD_WSTRING
-BOOST_CLASS_IMPLEMENTATION(std::wstring, boost::serialization::primitive_type)
-#endif
-
-#endif // BOOST_SERIALIZATION_STRING_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/strong_typedef.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/strong_typedef.hpp
deleted file mode 100644
index fdd1b24c9cb..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/strong_typedef.hpp
+++ /dev/null
@@ -1,50 +0,0 @@
-#ifndef BOOST_SERIALIZATION_STRONG_TYPEDEF_HPP
-#define BOOST_SERIALIZATION_STRONG_TYPEDEF_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// strong_typedef.hpp:
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// (C) Copyright 2016 Ashish Sadanandan
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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/serialization for updates, documentation, and revision history.
-
-// macro used to implement a strong typedef.  strong typedef
-// guarentees that two types are distinguised even though the
-// share the same underlying implementation.  typedef does not create
-// a new type.  BOOST_STRONG_TYPEDEF(T, D) creates a new type named D
-// that operates as a type T.
-
-#include <boost/config.hpp>
-#include <boost/operators.hpp>
-#include <boost/type_traits/has_nothrow_assign.hpp>
-#include <boost/type_traits/has_nothrow_constructor.hpp>
-#include <boost/type_traits/has_nothrow_copy.hpp>
-
-#define BOOST_STRONG_TYPEDEF(T, D)                                                                               \
-struct D                                                                                                         \
-    : boost::totally_ordered1< D                                                                                 \
-    , boost::totally_ordered2< D, T                                                                              \
-    > >                                                                                                          \
-{                                                                                                                \
-    T t;                                                                                                         \
-    explicit D(const T& t_) BOOST_NOEXCEPT_IF(boost::has_nothrow_copy_constructor<T>::value) : t(t_) {}          \
-    D() BOOST_NOEXCEPT_IF(boost::has_nothrow_default_constructor<T>::value) : t() {}                             \
-    D(const D & t_) BOOST_NOEXCEPT_IF(boost::has_nothrow_copy_constructor<T>::value) : t(t_.t) {}                \
-    D& operator=(const D& rhs) BOOST_NOEXCEPT_IF(boost::has_nothrow_assign<T>::value) {t = rhs.t; return *this;} \
-    D& operator=(const T& rhs) BOOST_NOEXCEPT_IF(boost::has_nothrow_assign<T>::value) {t = rhs; return *this;}   \
-    operator const T&() const {return t;}                                                                        \
-    operator T&() {return t;}                                                                                    \
-    bool operator==(const D& rhs) const {return t == rhs.t;}                                                     \
-    bool operator<(const D& rhs) const {return t < rhs.t;}                                                       \
-};
-
-#endif // BOOST_SERIALIZATION_STRONG_TYPEDEF_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/throw_exception.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/throw_exception.hpp
deleted file mode 100644
index b67618adc92..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/throw_exception.hpp
+++ /dev/null
@@ -1,44 +0,0 @@
-#ifndef BOOST_SERIALIZATION_THROW_EXCEPTION_HPP_INCLUDED
-#define BOOST_SERIALIZATION_THROW_EXCEPTION_HPP_INCLUDED
-
-// MS compatible compilers support #pragma once
-
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-//  boost/throw_exception.hpp
-//
-//  Copyright (c) 2002 Peter Dimov and Multi Media Ltd.
-//
-// Distributed under the 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>
-
-#ifndef BOOST_NO_EXCEPTIONS
-#include <exception>
-#endif
-
-namespace boost {
-namespace serialization {
-
-#ifdef BOOST_NO_EXCEPTIONS
-
-inline void throw_exception(std::exception const & e) {
-    ::boost::throw_exception(e);
-}
-
-#else
-
-template<class E> inline void throw_exception(E const & e){
-    throw e;
-}
-
-#endif
-
-} // namespace serialization
-} // namespace boost
-
-#endif // #ifndef BOOST_SERIALIZATION_THROW_EXCEPTION_HPP_INCLUDED
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/tracking.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/tracking.hpp
deleted file mode 100644
index d5c79b8409d..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/tracking.hpp
+++ /dev/null
@@ -1,118 +0,0 @@
-#ifndef BOOST_SERIALIZATION_TRACKING_HPP
-#define BOOST_SERIALIZATION_TRACKING_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// tracking.hpp:
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/config.hpp>
-#include <boost/static_assert.hpp>
-#include <boost/mpl/eval_if.hpp>
-#include <boost/mpl/identity.hpp>
-#include <boost/mpl/int.hpp>
-#include <boost/mpl/equal_to.hpp>
-#include <boost/mpl/greater.hpp>
-#include <boost/mpl/integral_c_tag.hpp>
-
-#include <boost/type_traits/is_base_and_derived.hpp>
-#include <boost/type_traits/is_pointer.hpp>
-#include <boost/serialization/level.hpp>
-#include <boost/serialization/tracking_enum.hpp>
-#include <boost/serialization/type_info_implementation.hpp>
-
-namespace boost {
-namespace serialization {
-
-struct basic_traits;
-
-// default tracking level
-template<class T>
-struct tracking_level_impl {
-    template<class U>
-    struct traits_class_tracking {
-        typedef typename U::tracking type;
-    };
-    typedef mpl::integral_c_tag tag;
-    // note: at least one compiler complained w/o the full qualification
-    // on basic traits below
-    typedef
-        typename mpl::eval_if<
-            is_base_and_derived<boost::serialization::basic_traits, T>,
-            traits_class_tracking< T >,
-        //else
-        typename mpl::eval_if<
-            is_pointer< T >,
-            // pointers are not tracked by default
-            mpl::int_<track_never>,
-        //else
-        typename mpl::eval_if<
-            // for primitives
-            typename mpl::equal_to<
-                implementation_level< T >,
-                mpl::int_<primitive_type> 
-            >,
-            // is never
-            mpl::int_<track_never>,
-            // otherwise its selective
-            mpl::int_<track_selectively>
-    >  > >::type type;
-    BOOST_STATIC_CONSTANT(int, value = type::value);
-};
-
-template<class T>
-struct tracking_level : 
-    public tracking_level_impl<const T>
-{
-};
-
-template<class T, enum tracking_type L>
-inline bool operator>=(tracking_level< T > t, enum tracking_type l)
-{
-    return t.value >= (int)l;
-}
-
-} // namespace serialization
-} // namespace boost
-
-
-// The STATIC_ASSERT is prevents one from setting tracking for a primitive type.  
-// This almost HAS to be an error.  Doing this will effect serialization of all 
-// char's in your program which is almost certainly what you don't want to do.  
-// If you want to track all instances of a given primitive type, You'll have to 
-// wrap it in your own type so its not a primitive anymore.  Then it will compile
-// without problem.
-#define BOOST_CLASS_TRACKING(T, E)           \
-namespace boost {                            \
-namespace serialization {                    \
-template<>                                   \
-struct tracking_level< T >                   \
-{                                            \
-    typedef mpl::integral_c_tag tag;         \
-    typedef mpl::int_< E> type;              \
-    BOOST_STATIC_CONSTANT(                   \
-        int,                                 \
-        value = tracking_level::type::value  \
-    );                                       \
-    /* tracking for a class  */              \
-    BOOST_STATIC_ASSERT((                    \
-        mpl::greater<                        \
-            /* that is a prmitive */         \
-            implementation_level< T >,       \
-            mpl::int_<primitive_type>        \
-        >::value                             \
-    ));                                      \
-};                                           \
-}}
-
-#endif // BOOST_SERIALIZATION_TRACKING_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/tracking_enum.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/tracking_enum.hpp
deleted file mode 100644
index 278051e1baf..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/tracking_enum.hpp
+++ /dev/null
@@ -1,41 +0,0 @@
-#ifndef BOOST_SERIALIZATION_TRACKING_ENUM_HPP
-#define BOOST_SERIALIZATION_TRACKING_ENUM_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// tracking_enum.hpp:
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-namespace boost {
-namespace serialization {
-
-// addresses of serialized objects may be tracked to avoid saving/loading
-// redundant copies.  This header defines a class trait that can be used
-// to specify when objects should be tracked
-
-// names for each tracking level
-enum tracking_type
-{
-    // never track this type
-    track_never = 0,
-    // track objects of this type if the object is serialized through a 
-    // pointer.
-    track_selectively = 1,
-    // always track this type
-    track_always = 2
-};
-
-} // namespace serialization
-} // namespace boost
-
-#endif // BOOST_SERIALIZATION_TRACKING_ENUM_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/traits.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/traits.hpp
deleted file mode 100644
index 9e114fdd3df..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/traits.hpp
+++ /dev/null
@@ -1,65 +0,0 @@
-#ifndef BOOST_SERIALIZATION_TRAITS_HPP
-#define BOOST_SERIALIZATION_TRAITS_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// traits.hpp:
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-// This header is used to apply serialization traits to templates.  The
-// standard system can't be used for platforms which don't support
-// Partial Templlate Specialization.  
-
-// The motivation for this is the Name-Value Pair (NVP) template.
-// it has to work the same on all platforms in order for archives
-// to be portable accross platforms.
-
-#include <boost/config.hpp>
-#include <boost/static_assert.hpp>
-
-#include <boost/mpl/int.hpp>
-#include <boost/mpl/bool_fwd.hpp>
-#include <boost/serialization/level_enum.hpp>
-#include <boost/serialization/tracking_enum.hpp>
-
-namespace boost {
-namespace serialization {
-
-// common base class used to detect appended traits class
-struct basic_traits {};
-
-template <class T>
-struct extended_type_info_impl;
-
-template<
-    class T, 
-    int Level, 
-    int Tracking,
-    unsigned int Version = 0,
-    class ETII = extended_type_info_impl< T >,
-    class Wrapper = mpl::false_
->
-struct traits : public basic_traits {
-    BOOST_STATIC_ASSERT(Version == 0 || Level >= object_class_info);
-    BOOST_STATIC_ASSERT(Tracking == track_never || Level >= object_serializable);
-    typedef typename mpl::int_<Level> level;
-    typedef typename mpl::int_<Tracking> tracking;
-    typedef typename mpl::int_<Version> version;
-    typedef ETII type_info_implementation;
-    typedef Wrapper is_wrapper;
-};
-
-} // namespace serialization
-} // namespace boost
-
-#endif // BOOST_SERIALIZATION_TRAITS_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/type_info_implementation.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/type_info_implementation.hpp
deleted file mode 100644
index 24637a8dbb3..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/type_info_implementation.hpp
+++ /dev/null
@@ -1,73 +0,0 @@
-#ifndef BOOST_SERIALIZATION_TYPE_INFO_IMPLEMENTATION_HPP
-#define BOOST_SERIALIZATION_TYPE_INFO_IMPLEMENTATION_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// type_info_implementation.hpp: interface for portable version of type_info
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-
-#include <boost/config.hpp>
-#include <boost/detail/workaround.hpp>
-
-#include <boost/static_assert.hpp>
-#include <boost/mpl/eval_if.hpp>
-#include <boost/mpl/identity.hpp>
-#include <boost/type_traits/is_base_and_derived.hpp>
-#include <boost/serialization/traits.hpp>
-
-namespace boost {
-namespace serialization {
-
-// note that T and const T are folded into const T so that
-// there is only one table entry per type
-template<class T>
-struct type_info_implementation {
-    template<class U>
-    struct traits_class_typeinfo_implementation {
-      typedef typename U::type_info_implementation::type type;
-    };
-    // note: at least one compiler complained w/o the full qualification
-    // on basic traits below
-    typedef 
-        typename mpl::eval_if<
-            is_base_and_derived<boost::serialization::basic_traits, T>,
-            traits_class_typeinfo_implementation< T >,
-        //else
-            mpl::identity<
-                typename extended_type_info_impl< T >::type
-            >
-        >::type type;
-};
-
-} // namespace serialization
-} // namespace boost
-
-// define a macro to assign a particular derivation of extended_type_info
-// to a specified a class. 
-#define BOOST_CLASS_TYPE_INFO(T, ETI)              \
-namespace boost {                                  \
-namespace serialization {                          \
-template<>                                         \
-struct type_info_implementation< T > {             \
-    typedef ETI type;                              \
-};                                                 \
-template<>                                         \
-struct type_info_implementation< const T > {       \
-    typedef ETI type;                              \
-};                                                 \
-}                                                  \
-}                                                  \
-/**/
-
-#endif /// BOOST_SERIALIZATION_TYPE_INFO_IMPLEMENTATION_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/unique_ptr.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/unique_ptr.hpp
deleted file mode 100644
index 8d8703ef4f7..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/unique_ptr.hpp
+++ /dev/null
@@ -1,68 +0,0 @@
-#ifndef  BOOST_SERIALIZATION_UNIQUE_PTR_HPP
-#define BOOST_SERIALIZATION_UNIQUE_PTR_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// unique_ptr.hpp:
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-#include <memory>
-#include <boost/serialization/split_free.hpp>
-#include <boost/serialization/nvp.hpp>
-
-namespace boost {
-namespace serialization {
-
-/////////////////////////////////////////////////////////////
-// implement serialization for unique_ptr< T >
-// note: this must be added to the boost namespace in order to
-// be called by the library
-template<class Archive, class T>
-inline void save(
-    Archive & ar,
-    const std::unique_ptr< T > &t,
-    const unsigned int /*file_version*/
-){
-    // only the raw pointer has to be saved
-    // the ref count is rebuilt automatically on load
-    const T * const tx = t.get();
-    ar << BOOST_SERIALIZATION_NVP(tx);
-}
-
-template<class Archive, class T>
-inline void load(
-    Archive & ar,
-    std::unique_ptr< T > &t,
-    const unsigned int /*file_version*/
-){
-    T *tx;
-    ar >> BOOST_SERIALIZATION_NVP(tx);
-    // note that the reset automagically maintains the reference count
-    t.reset(tx);
-}
-
-// split non-intrusive serialization function member into separate
-// non intrusive save/load member functions
-template<class Archive, class T>
-inline void serialize(
-    Archive & ar,
-    std::unique_ptr< T > &t,
-    const unsigned int file_version
-){
-    boost::serialization::split_free(ar, t, file_version);
-}
-
-} // namespace serialization
-} // namespace boost
-
-
-#endif // BOOST_SERIALIZATION_UNIQUE_PTR_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/unordered_collections_load_imp.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/unordered_collections_load_imp.hpp
deleted file mode 100644
index d56a423d180..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/unordered_collections_load_imp.hpp
+++ /dev/null
@@ -1,73 +0,0 @@
-#ifndef BOOST_SERIALIZATION_UNORDERED_COLLECTIONS_LOAD_IMP_HPP
-#define BOOST_SERIALIZATION_UNORDERED_COLLECTIONS_LOAD_IMP_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-# pragma warning (disable : 4786) // too long name, harmless warning
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// unordered_collections_load_imp.hpp: serialization for loading stl collections
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// (C) Copyright 2014 Jim Bell
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-// helper function templates for serialization of collections
-
-#include <boost/assert.hpp>
-#include <cstddef> // size_t
-#include <boost/config.hpp> // msvc 6.0 needs this for warning suppression
-#if defined(BOOST_NO_STDC_NAMESPACE)
-namespace std{ 
-    using ::size_t; 
-} // namespace std
-#endif
-#include <boost/detail/workaround.hpp>
-
-#include <boost/archive/detail/basic_iarchive.hpp>
-#include <boost/serialization/access.hpp>
-#include <boost/serialization/nvp.hpp>
-#include <boost/serialization/collection_size_type.hpp>
-#include <boost/serialization/item_version_type.hpp>
-
-namespace boost{
-namespace serialization {
-namespace stl {
-
-//////////////////////////////////////////////////////////////////////
-// implementation of serialization for STL containers
-//
-template<class Archive, class Container, class InputFunction>
-inline void load_unordered_collection(Archive & ar, Container &s)
-{
-    collection_size_type count;
-    collection_size_type bucket_count;
-    boost::serialization::item_version_type item_version(0);
-    boost::archive::library_version_type library_version(
-        ar.get_library_version()
-    );
-    // retrieve number of elements
-    ar >> BOOST_SERIALIZATION_NVP(count);
-    ar >> BOOST_SERIALIZATION_NVP(bucket_count);
-    if(boost::archive::library_version_type(3) < library_version){
-        ar >> BOOST_SERIALIZATION_NVP(item_version);
-    }
-    s.clear();
-    s.rehash(bucket_count);
-    InputFunction ifunc;
-    while(count-- > 0){
-        ifunc(ar, s, item_version);
-    }
-}
-
-} // namespace stl 
-} // namespace serialization
-} // namespace boost
-
-#endif //BOOST_SERIALIZATION_UNORDERED_COLLECTIONS_LOAD_IMP_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/unordered_collections_save_imp.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/unordered_collections_save_imp.hpp
deleted file mode 100644
index 56746ebeaa3..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/unordered_collections_save_imp.hpp
+++ /dev/null
@@ -1,86 +0,0 @@
-#ifndef BOOST_SERIALIZATION_UNORDERED_COLLECTIONS_SAVE_IMP_HPP
-#define BOOST_SERIALIZATION_UNORDERED_COLLECTIONS_SAVE_IMP_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// hash_collections_save_imp.hpp: serialization for stl collections
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// (C) Copyright 2014 Jim Bell
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-// helper function templates for serialization of collections
-
-#include <boost/config.hpp>
-#include <boost/serialization/nvp.hpp>
-#include <boost/serialization/serialization.hpp>
-#include <boost/serialization/version.hpp>
-#include <boost/serialization/collection_size_type.hpp>
-#include <boost/serialization/item_version_type.hpp>
-
-namespace boost{
-namespace serialization {
-namespace stl {
-
-//////////////////////////////////////////////////////////////////////
-// implementation of serialization for STL containers
-//
-
-template<class Archive, class Container>
-inline void save_unordered_collection(Archive & ar, const Container &s)
-{
-    collection_size_type count(s.size());
-    const collection_size_type bucket_count(s.bucket_count());
-    const item_version_type item_version(
-        version<typename Container::value_type>::value
-    );
-
-    #if 0
-    /* should only be necessary to create archives of previous versions
-     * which is not currently supported.  So for now comment this out
-     */
-    boost::archive::library_version_type library_version(
-        ar.get_library_version()
-    );
-    // retrieve number of elements
-	ar << BOOST_SERIALIZATION_NVP(count);
-	ar << BOOST_SERIALIZATION_NVP(bucket_count);
-    if(boost::archive::library_version_type(3) < library_version){
-        // record number of elements
-        // make sure the target type is registered so we can retrieve
-        // the version when we load
-        ar << BOOST_SERIALIZATION_NVP(item_version);
-    }
-    #else
-        ar << BOOST_SERIALIZATION_NVP(count);
-        ar << BOOST_SERIALIZATION_NVP(bucket_count);
-        ar << BOOST_SERIALIZATION_NVP(item_version);
-    #endif
-
-    typename Container::const_iterator it = s.begin();
-    while(count-- > 0){
-        // note borland emits a no-op without the explicit namespace
-        boost::serialization::save_construct_data_adl(
-            ar, 
-            &(*it), 
-            boost::serialization::version<
-                typename Container::value_type
-            >::value
-        );
-        ar << boost::serialization::make_nvp("item", *it++);
-    }
-}
-
-} // namespace stl 
-} // namespace serialization
-} // namespace boost
-
-#endif //BOOST_SERIALIZATION_UNORDERED_COLLECTIONS_SAVE_IMP_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/unordered_map.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/unordered_map.hpp
deleted file mode 100644
index 4fdbddd7b65..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/unordered_map.hpp
+++ /dev/null
@@ -1,160 +0,0 @@
-#ifndef  BOOST_SERIALIZATION_UNORDERED_MAP_HPP
-#define BOOST_SERIALIZATION_UNORDERED_MAP_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// serialization/unordered_map.hpp:
-// serialization for stl unordered_map templates
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// (C) Copyright 2014 Jim Bell
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/config.hpp>
-
-#include <unordered_map>
-
-#include <boost/serialization/utility.hpp>
-#include <boost/serialization/unordered_collections_save_imp.hpp>
-#include <boost/serialization/unordered_collections_load_imp.hpp>
-#include <boost/serialization/archive_input_unordered_map.hpp>
-#include <boost/serialization/split_free.hpp>
-
-namespace boost { 
-namespace serialization {
-
-template<
-    class Archive, 
-    class Key, 
-    class HashFcn, 
-    class EqualKey,
-    class Allocator
->
-inline void save(
-    Archive & ar,
-    const std::unordered_map<Key, HashFcn, EqualKey, Allocator> &t,
-    const unsigned int /*file_version*/
-){
-    boost::serialization::stl::save_unordered_collection<
-        Archive, 
-        std::unordered_map<Key, HashFcn, EqualKey, Allocator>
-    >(ar, t);
-}
-
-template<
-    class Archive, 
-    class Key, 
-    class HashFcn, 
-    class EqualKey,
-    class Allocator
->
-inline void load(
-    Archive & ar,
-    std::unordered_map<Key, HashFcn, EqualKey, Allocator> &t,
-    const unsigned int /*file_version*/
-){
-    boost::serialization::stl::load_unordered_collection<
-        Archive,
-        std::unordered_map<Key, HashFcn, EqualKey, Allocator>,
-        boost::serialization::stl::archive_input_unordered_map<
-            Archive, 
-            std::unordered_map<Key, HashFcn, EqualKey, Allocator>
-        >
-    >(ar, t);
-}
-
-// split non-intrusive serialization function member into separate
-// non intrusive save/load member functions
-template<
-    class Archive, 
-    class Key, 
-    class HashFcn, 
-    class EqualKey,
-    class Allocator
->
-inline void serialize(
-    Archive & ar,
-    std::unordered_map<Key, HashFcn, EqualKey, Allocator> &t,
-    const unsigned int file_version
-){
-    boost::serialization::split_free(ar, t, file_version);
-}
-
-// unordered_multimap
-template<
-    class Archive, 
-    class Key, 
-    class HashFcn, 
-    class EqualKey,
-    class Allocator
->
-inline void save(
-    Archive & ar,
-    const std::unordered_multimap<
-        Key, HashFcn, EqualKey, Allocator
-    > &t,
-    const unsigned int /*file_version*/
-){
-    boost::serialization::stl::save_unordered_collection<
-        Archive, 
-        std::unordered_multimap<Key, HashFcn, EqualKey, Allocator>
-    >(ar, t);
-}
-
-template<
-    class Archive, 
-    class Key, 
-    class HashFcn, 
-    class EqualKey,
-    class Allocator
->
-inline void load(
-    Archive & ar,
-    std::unordered_multimap<
-        Key, HashFcn, EqualKey, Allocator
-    > &t,
-    const unsigned int /*file_version*/
-){
-    boost::serialization::stl::load_unordered_collection<
-        Archive,
-        std::unordered_multimap<
-            Key, HashFcn, EqualKey, Allocator
-        >,
-        boost::serialization::stl::archive_input_unordered_multimap<
-            Archive, 
-            std::unordered_multimap<Key, HashFcn, EqualKey, Allocator>
-        >
-    >(ar, t);
-}
-
-// split non-intrusive serialization function member into separate
-// non intrusive save/load member functions
-template<
-    class Archive, 
-    class Key, 
-    class HashFcn, 
-    class EqualKey,
-    class Allocator
->
-inline void serialize(
-    Archive & ar,
-    std::unordered_multimap<
-        Key, HashFcn, EqualKey, Allocator
-    > &t,
-    const unsigned int file_version
-){
-    boost::serialization::split_free(ar, t, file_version);
-}
-
-} // namespace serialization
-} // namespace boost
-
-#endif // BOOST_SERIALIZATION_UNORDERED_MAP_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/unordered_set.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/unordered_set.hpp
deleted file mode 100644
index adfee609cbe..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/unordered_set.hpp
+++ /dev/null
@@ -1,162 +0,0 @@
-#ifndef  BOOST_SERIALIZATION_UNORDERED_SET_HPP
-#define BOOST_SERIALIZATION_UNORDERED_SET_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// unordered_set.hpp: serialization for stl unordered_set templates
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// (C) Copyright 2014 Jim Bell
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/config.hpp>
-
-#include <unordered_set>
-
-#include <boost/serialization/unordered_collections_save_imp.hpp>
-#include <boost/serialization/unordered_collections_load_imp.hpp>
-#include <boost/serialization/archive_input_unordered_set.hpp>
-#include <boost/serialization/split_free.hpp>
-
-namespace boost { 
-namespace serialization {
-
-template<
-    class Archive, 
-    class Key, 
-    class HashFcn, 
-    class EqualKey,
-    class Allocator
->
-inline void save(
-    Archive & ar,
-    const std::unordered_set<
-        Key, HashFcn, EqualKey, Allocator
-    > &t,
-    const unsigned int /*file_version*/
-){
-    boost::serialization::stl::save_unordered_collection<
-        Archive, 
-        std::unordered_set<Key, HashFcn, EqualKey, Allocator>
-    >(ar, t);
-}
-
-template<
-    class Archive, 
-    class Key, 
-    class HashFcn, 
-    class EqualKey,
-    class Allocator
->
-inline void load(
-    Archive & ar,
-    std::unordered_set<
-        Key, HashFcn, EqualKey, Allocator
-    > &t,
-    const unsigned int /*file_version*/
-){
-    boost::serialization::stl::load_unordered_collection<
-        Archive,
-        std::unordered_set<Key, HashFcn, EqualKey, Allocator>,
-        stl::archive_input_unordered_set<
-            Archive, 
-            std::unordered_set<
-                Key, HashFcn, EqualKey, Allocator
-            >
-        >
-    >(ar, t);
-}
-
-// split non-intrusive serialization function member into separate
-// non intrusive save/load member functions
-template<
-    class Archive, 
-    class Key, 
-    class HashFcn, 
-    class EqualKey,
-    class Allocator
->
-inline void serialize(
-    Archive & ar,
-    std::unordered_set<
-        Key, HashFcn, EqualKey, Allocator
-    > &t,
-    const unsigned int file_version
-){
-    split_free(ar, t, file_version);
-}
-
-// unordered_multiset
-template<
-    class Archive, 
-    class Key, 
-    class HashFcn, 
-    class EqualKey,
-    class Allocator
->
-inline void save(
-    Archive & ar,
-    const std::unordered_multiset<
-        Key, HashFcn, EqualKey, Allocator
-    > &t,
-    const unsigned int /*file_version*/
-){
-    stl::save_unordered_collection<
-        Archive, 
-        std::unordered_multiset<Key, HashFcn, EqualKey, Allocator>
-    >(ar, t);
-}
-
-template<
-    class Archive, 
-    class Key, 
-    class HashFcn, 
-    class EqualKey,
-    class Allocator
->
-inline void load(
-    Archive & ar,
-    std::unordered_multiset<
-        Key, HashFcn, EqualKey, Allocator
-    > &t,
-    const unsigned int /*file_version*/
-){
-    boost::serialization::stl::load_unordered_collection<
-        Archive,
-        std::unordered_multiset<Key, HashFcn, EqualKey, Allocator>,
-        boost::serialization::stl::archive_input_unordered_multiset<
-            Archive,
-            std::unordered_multiset<Key, HashFcn, EqualKey, Allocator>
-        >
-    >(ar, t);
-}
-
-// split non-intrusive serialization function member into separate
-// non intrusive save/load member functions
-template<
-    class Archive, 
-    class Key, 
-    class HashFcn, 
-    class EqualKey,
-    class Allocator
->
-inline void serialize(
-    Archive & ar,
-    std::unordered_multiset<Key, HashFcn, EqualKey, Allocator> &t,
-    const unsigned int file_version
-){
-    boost::serialization::split_free(ar, t, file_version);
-}
-
-} // namespace serialization
-} // namespace boost
-
-#endif // BOOST_SERIALIZATION_UNORDERED_SET_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/utility.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/utility.hpp
deleted file mode 100644
index 4867a4a12d2..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/utility.hpp
+++ /dev/null
@@ -1,56 +0,0 @@
-#ifndef  BOOST_SERIALIZATION_UTILITY_HPP
-#define BOOST_SERIALIZATION_UTILITY_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// serialization/utility.hpp:
-// serialization for stl utility templates
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <utility>
-#include <boost/config.hpp>
-
-#include <boost/type_traits/remove_const.hpp>
-#include <boost/serialization/nvp.hpp>
-#include <boost/serialization/is_bitwise_serializable.hpp>
-#include <boost/mpl/and.hpp>
-
-namespace boost { 
-namespace serialization {
-
-// pair
-template<class Archive, class F, class S>
-inline void serialize(
-    Archive & ar,
-    std::pair<F, S> & p,
-    const unsigned int /* file_version */
-){
-    // note: we remove any const-ness on the first argument.  The reason is that 
-    // for stl maps, the type saved is pair<const key, T).  We remove
-    // the const-ness in order to be able to load it.
-    typedef typename boost::remove_const<F>::type typef;
-    ar & boost::serialization::make_nvp("first", const_cast<typef &>(p.first));
-    ar & boost::serialization::make_nvp("second", p.second);
-}
-
-/// specialization of is_bitwise_serializable for pairs
-template <class T, class U>
-struct is_bitwise_serializable<std::pair<T,U> >
- : public mpl::and_<is_bitwise_serializable< T >,is_bitwise_serializable<U> >
-{
-};
-
-} // serialization
-} // namespace boost
-
-#endif // BOOST_SERIALIZATION_UTILITY_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/valarray.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/valarray.hpp
deleted file mode 100644
index 9eece5c1737..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/valarray.hpp
+++ /dev/null
@@ -1,86 +0,0 @@
-#ifndef BOOST_SERIALIZATION_VALARAY_HPP
-#define BOOST_SERIALIZATION_VALARAY_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// valarray.hpp: serialization for stl vector templates
-
-// (C) Copyright 2005 Matthias Troyer . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <valarray>
-#include <boost/config.hpp>
-
-#include <boost/serialization/collections_save_imp.hpp>
-#include <boost/serialization/collections_load_imp.hpp>
-#include <boost/serialization/split_free.hpp>
-#include <boost/serialization/collection_size_type.hpp>
-#include <boost/serialization/array_wrapper.hpp>
-
-// function specializations must be defined in the appropriate
-// namespace - boost::serialization
-#if defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION)
-#define STD _STLP_STD
-#else
-#define STD std
-#endif
-
-namespace boost { 
-namespace serialization {
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// valarray< T >
-
-template<class Archive, class U>
-void save( Archive & ar, const STD::valarray<U> &t, const unsigned int /*file_version*/ )
-{
-    const collection_size_type count(t.size());
-    ar << BOOST_SERIALIZATION_NVP(count);
-    if (t.size()){
-        // explict template arguments to pass intel C++ compiler
-        ar << serialization::make_array<const U, collection_size_type>(
-            static_cast<const U *>(&t[0]),
-            count
-        );
-    }
-}
-
-template<class Archive, class U>
-void load( Archive & ar, STD::valarray<U> &t,  const unsigned int /*file_version*/ )
-{
-    collection_size_type count;
-    ar >> BOOST_SERIALIZATION_NVP(count);
-    t.resize(count);
-    if (t.size()){
-        // explict template arguments to pass intel C++ compiler
-        ar >> serialization::make_array<U, collection_size_type>(
-            static_cast<U *>(&t[0]),
-            count
-        );
-    }
-}
-
-// split non-intrusive serialization function member into separate
-// non intrusive save/load member functions
-template<class Archive, class U>
-inline void serialize( Archive & ar, STD::valarray<U> & t, const unsigned int file_version)
-{
-    boost::serialization::split_free(ar, t, file_version);
-}
-
-} } // end namespace boost::serialization
-
-#include <boost/serialization/collection_traits.hpp>
-
-BOOST_SERIALIZATION_COLLECTION_TRAITS(STD::valarray)
-#undef STD
-
-#endif // BOOST_SERIALIZATION_VALARAY_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/variant.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/variant.hpp
deleted file mode 100644
index dce6f3d49e7..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/variant.hpp
+++ /dev/null
@@ -1,158 +0,0 @@
-#ifndef BOOST_SERIALIZATION_VARIANT_HPP
-#define BOOST_SERIALIZATION_VARIANT_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// variant.hpp - non-intrusive serialization of variant types
-//
-// copyright (c) 2005   
-// troy d. straszheim <troy@resophonic.com>
-// http://www.resophonic.com
-//
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-//
-// thanks to Robert Ramey, Peter Dimov, and Richard Crossley.
-//
-
-#include <boost/mpl/front.hpp>
-#include <boost/mpl/pop_front.hpp>
-#include <boost/mpl/eval_if.hpp>
-#include <boost/mpl/identity.hpp>
-#include <boost/mpl/size.hpp>
-#include <boost/mpl/empty.hpp>
-
-#include <boost/serialization/throw_exception.hpp>
-
-#include <boost/variant.hpp>
-
-#include <boost/archive/archive_exception.hpp>
-
-#include <boost/serialization/split_free.hpp>
-#include <boost/serialization/serialization.hpp>
-#include <boost/serialization/nvp.hpp>
-
-namespace boost {
-namespace serialization {
-
-template<class Archive>
-struct variant_save_visitor : 
-    boost::static_visitor<> 
-{
-    variant_save_visitor(Archive& ar) :
-        m_ar(ar)
-    {}
-    template<class T>
-    void operator()(T const & value) const
-    {
-        m_ar << BOOST_SERIALIZATION_NVP(value);
-    }
-private:
-    Archive & m_ar;
-};
-
-template<class Archive, BOOST_VARIANT_ENUM_PARAMS(/* typename */ class T)>
-void save(
-    Archive & ar,
-    boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> const & v,
-    unsigned int /*version*/
-){
-    int which = v.which();
-    ar << BOOST_SERIALIZATION_NVP(which);
-    variant_save_visitor<Archive> visitor(ar);
-    v.apply_visitor(visitor);
-}
-
-template<class S>
-struct variant_impl {
-
-    struct load_null {
-        template<class Archive, class V>
-        static void invoke(
-            Archive & /*ar*/,
-            int /*which*/,
-            V & /*v*/,
-            const unsigned int /*version*/
-        ){}
-    };
-
-    struct load_impl {
-        template<class Archive, class V>
-        static void invoke(
-            Archive & ar,
-            int which,
-            V & v,
-            const unsigned int version
-        ){
-            if(which == 0){
-                // note: A non-intrusive implementation (such as this one)
-                // necessary has to copy the value.  This wouldn't be necessary
-                // with an implementation that de-serialized to the address of the
-                // aligned storage included in the variant.
-                typedef typename mpl::front<S>::type head_type;
-                head_type value;
-                ar >> BOOST_SERIALIZATION_NVP(value);
-                v = value;
-                ar.reset_object_address(& boost::get<head_type>(v), & value);
-                return;
-            }
-            typedef typename mpl::pop_front<S>::type type;
-            variant_impl<type>::load(ar, which - 1, v, version);
-        }
-    };
-
-    template<class Archive, class V>
-    static void load(
-        Archive & ar,
-        int which,
-        V & v,
-        const unsigned int version
-    ){
-        typedef typename mpl::eval_if<mpl::empty<S>,
-            mpl::identity<load_null>,
-            mpl::identity<load_impl>
-        >::type typex;
-        typex::invoke(ar, which, v, version);
-    }
-
-};
-
-template<class Archive, BOOST_VARIANT_ENUM_PARAMS(/* typename */ class T)>
-void load(
-    Archive & ar, 
-    boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)>& v,
-    const unsigned int version
-){
-    int which;
-    typedef typename boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)>::types types;
-    ar >> BOOST_SERIALIZATION_NVP(which);
-    if(which >=  mpl::size<types>::value)
-        // this might happen if a type was removed from the list of variant types
-        boost::serialization::throw_exception(
-            boost::archive::archive_exception(
-                boost::archive::archive_exception::unsupported_version
-            )
-        );
-    variant_impl<types>::load(ar, which, v, version);
-}
-
-template<class Archive,BOOST_VARIANT_ENUM_PARAMS(/* typename */ class T)>
-inline void serialize(
-    Archive & ar,
-    boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> & v,
-    const unsigned int file_version
-){
-    split_free(ar,v,file_version);
-}
-
-} // namespace serialization
-} // namespace boost
-
-#endif //BOOST_SERIALIZATION_VARIANT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/vector.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/vector.hpp
deleted file mode 100644
index 9a114c00e20..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/vector.hpp
+++ /dev/null
@@ -1,233 +0,0 @@
-#ifndef  BOOST_SERIALIZATION_VECTOR_HPP
-#define BOOST_SERIALIZATION_VECTOR_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// vector.hpp: serialization for stl vector templates
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// fast array serialization (C) Copyright 2005 Matthias Troyer 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <vector>
-
-#include <boost/config.hpp>
-#include <boost/detail/workaround.hpp>
-
-#include <boost/archive/detail/basic_iarchive.hpp>
-#include <boost/serialization/access.hpp>
-#include <boost/serialization/nvp.hpp>
-#include <boost/serialization/collection_size_type.hpp>
-#include <boost/serialization/item_version_type.hpp>
-
-#include <boost/serialization/collections_save_imp.hpp>
-#include <boost/serialization/collections_load_imp.hpp>
-#include <boost/serialization/split_free.hpp>
-#include <boost/serialization/array_wrapper.hpp>
-#include <boost/mpl/bool_fwd.hpp>
-#include <boost/mpl/if.hpp>
-
-// default is being compatible with version 1.34.1 files, not 1.35 files
-#ifndef BOOST_SERIALIZATION_VECTOR_VERSIONED
-#define BOOST_SERIALIZATION_VECTOR_VERSIONED(V) (V==4 || V==5)
-#endif
-
-// function specializations must be defined in the appropriate
-// namespace - boost::serialization
-#if defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION)
-#define STD _STLP_STD
-#else
-#define STD std
-#endif
-
-namespace boost { 
-namespace serialization {
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// vector< T >
-
-// the default versions
-
-template<class Archive, class U, class Allocator>
-inline void save(
-    Archive & ar,
-    const std::vector<U, Allocator> &t,
-    const unsigned int /* file_version */,
-    mpl::false_
-){
-    boost::serialization::stl::save_collection<Archive, STD::vector<U, Allocator> >(
-        ar, t
-    );
-}
-
-template<class Archive, class U, class Allocator>
-inline void load(
-    Archive & ar,
-    std::vector<U, Allocator> &t,
-    const unsigned int /* file_version */,
-    mpl::false_
-){
-    const boost::archive::library_version_type library_version(
-        ar.get_library_version()
-    );
-    // retrieve number of elements
-    item_version_type item_version(0);
-    collection_size_type count;
-    ar >> BOOST_SERIALIZATION_NVP(count);
-    if(boost::archive::library_version_type(3) < library_version){
-        ar >> BOOST_SERIALIZATION_NVP(item_version);
-    }
-    t.reserve(count);
-    stl::collection_load_impl(ar, t, count, item_version);
-}
-
-// the optimized versions
-
-template<class Archive, class U, class Allocator>
-inline void save(
-    Archive & ar,
-    const std::vector<U, Allocator> &t,
-    const unsigned int /* file_version */,
-    mpl::true_
-){
-    const collection_size_type count(t.size());
-    ar << BOOST_SERIALIZATION_NVP(count);
-    if (!t.empty())
-        // explict template arguments to pass intel C++ compiler
-        ar << serialization::make_array<const U, collection_size_type>(
-            static_cast<const U *>(&t[0]),
-            count
-        );
-}
-
-template<class Archive, class U, class Allocator>
-inline void load(
-    Archive & ar,
-    std::vector<U, Allocator> &t,
-    const unsigned int /* file_version */,
-    mpl::true_
-){
-    collection_size_type count(t.size());
-    ar >> BOOST_SERIALIZATION_NVP(count);
-    t.resize(count);
-    unsigned int item_version=0;
-    if(BOOST_SERIALIZATION_VECTOR_VERSIONED(ar.get_library_version())) {
-        ar >> BOOST_SERIALIZATION_NVP(item_version);
-    }
-    if (!t.empty())
-        // explict template arguments to pass intel C++ compiler
-        ar >> serialization::make_array<U, collection_size_type>(
-            static_cast<U *>(&t[0]),
-            count
-        );
-  }
-
-// dispatch to either default or optimized versions
-
-template<class Archive, class U, class Allocator>
-inline void save(
-    Archive & ar,
-    const std::vector<U, Allocator> &t,
-    const unsigned int file_version
-){
-    typedef typename 
-    boost::serialization::use_array_optimization<Archive>::template apply<
-        typename remove_const<U>::type 
-    >::type use_optimized;
-    save(ar,t,file_version, use_optimized());
-}
-
-template<class Archive, class U, class Allocator>
-inline void load(
-    Archive & ar,
-    std::vector<U, Allocator> &t,
-    const unsigned int file_version
-){
-#ifdef BOOST_SERIALIZATION_VECTOR_135_HPP
-    if (ar.get_library_version()==boost::archive::library_version_type(5))
-    {
-      load(ar,t,file_version, boost::is_arithmetic<U>());
-      return;
-    }
-#endif
-    typedef typename 
-    boost::serialization::use_array_optimization<Archive>::template apply<
-        typename remove_const<U>::type 
-    >::type use_optimized;
-    load(ar,t,file_version, use_optimized());
-}
-
-// split non-intrusive serialization function member into separate
-// non intrusive save/load member functions
-template<class Archive, class U, class Allocator>
-inline void serialize(
-    Archive & ar,
-    std::vector<U, Allocator> & t,
-    const unsigned int file_version
-){
-    boost::serialization::split_free(ar, t, file_version);
-}
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// vector<bool>
-template<class Archive, class Allocator>
-inline void save(
-    Archive & ar,
-    const std::vector<bool, Allocator> &t,
-    const unsigned int /* file_version */
-){
-    // record number of elements
-    collection_size_type count (t.size());
-    ar << BOOST_SERIALIZATION_NVP(count);
-    std::vector<bool>::const_iterator it = t.begin();
-    while(count-- > 0){
-        bool tb = *it++;
-        ar << boost::serialization::make_nvp("item", tb);
-    }
-}
-
-template<class Archive, class Allocator>
-inline void load(
-    Archive & ar,
-    std::vector<bool, Allocator> &t,
-    const unsigned int /* file_version */
-){
-    // retrieve number of elements
-    collection_size_type count;
-    ar >> BOOST_SERIALIZATION_NVP(count);
-    t.resize(count);
-    for(collection_size_type i = collection_size_type(0); i < count; ++i){
-        bool b;
-        ar >> boost::serialization::make_nvp("item", b);
-        t[i] = b;
-    }
-}
-
-// split non-intrusive serialization function member into separate
-// non intrusive save/load member functions
-template<class Archive, class Allocator>
-inline void serialize(
-    Archive & ar,
-    std::vector<bool, Allocator> & t,
-    const unsigned int file_version
-){
-    boost::serialization::split_free(ar, t, file_version);
-}
-
-} // serialization
-} // namespace boost
-
-#include <boost/serialization/collection_traits.hpp>
-
-BOOST_SERIALIZATION_COLLECTION_TRAITS(std::vector)
-#undef STD
-
-#endif // BOOST_SERIALIZATION_VECTOR_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/vector_135.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/vector_135.hpp
deleted file mode 100644
index fd1a7393d1b..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/vector_135.hpp
+++ /dev/null
@@ -1,26 +0,0 @@
-////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// vector_135.hpp: serialization for stl vector templates for compatibility
-//                 with release 1.35, which had a bug
-
-// (C) Copyright 2008 Matthias Troyer
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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_SERIALIZATION_VECTOR_135_HPP
-#define BOOST_SERIALIZATION_VECTOR_135_HPP
-
-#ifdef BOOST_SERIALIZATION_VECTOR_VERSIONED
-#if BOOST_SERIALIZATION_VECTOR_VERSION != 4
-#error "Boost.Serialization cannot be compatible with both 1.35 and 1.36-1.40 files"
-#endif
-#else
-#define BOOST_SERIALIZATION_VECTOR_VERSIONED(V) (V>4)
-#endif
-
-#include <boost/serialization/vector.hpp>
-
-#endif // BOOST_SERIALIZATION_VECTOR_135_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/version.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/version.hpp
deleted file mode 100644
index 21a74d73daa..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/version.hpp
+++ /dev/null
@@ -1,107 +0,0 @@
-#ifndef BOOST_SERIALIZATION_VERSION_HPP
-#define BOOST_SERIALIZATION_VERSION_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// version.hpp:
-
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/config.hpp>
-#include <boost/mpl/assert.hpp>
-#include <boost/mpl/int.hpp>
-#include <boost/mpl/eval_if.hpp>
-#include <boost/mpl/identity.hpp>
-#include <boost/mpl/integral_c_tag.hpp>
-
-#include <boost/type_traits/is_base_and_derived.hpp>
-
-namespace boost { 
-namespace serialization {
-
-struct basic_traits;
-
-// default version number is 0. Override with higher version
-// when class definition changes.
-template<class T>
-struct version
-{
-    template<class U>
-    struct traits_class_version {
-        typedef typename U::version type;
-    };
-
-    typedef mpl::integral_c_tag tag;
-    // note: at least one compiler complained w/o the full qualification
-    // on basic traits below
-    typedef
-        typename mpl::eval_if<
-            is_base_and_derived<boost::serialization::basic_traits,T>,
-            traits_class_version< T >,
-            mpl::int_<0>
-        >::type type;
-    BOOST_STATIC_CONSTANT(int, value = version::type::value);
-};
-
-#ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
-template<class T>
-const int version<T>::value;
-#endif
-
-} // namespace serialization
-} // namespace boost
-
-/* note: at first it seemed that this would be a good place to trap
- * as an error an attempt to set a version # for a class which doesn't
- * save its class information (including version #) in the archive.
- * However, this imposes a requirement that the version be set after
- * the implemention level which would be pretty confusing.  If this
- * is to be done, do this check in the input or output operators when
- * ALL the serialization traits are available.  Included the implementation
- * here with this comment as a reminder not to do this!
- */
-//#include <boost/serialization/level.hpp>
-//#include <boost/mpl/equal_to.hpp>
-
-#include <boost/mpl/less.hpp>
-#include <boost/mpl/comparison.hpp>
-
-// specify the current version number for the class
-// version numbers limited to 8 bits !!!
-#define BOOST_CLASS_VERSION(T, N)                                      \
-namespace boost {                                                      \
-namespace serialization {                                              \
-template<>                                                             \
-struct version<T >                                                     \
-{                                                                      \
-    typedef mpl::int_<N> type;                                         \
-    typedef mpl::integral_c_tag tag;                                   \
-    BOOST_STATIC_CONSTANT(int, value = version::type::value);          \
-    BOOST_MPL_ASSERT((                                                 \
-        boost::mpl::less<                                              \
-            boost::mpl::int_<N>,                                       \
-            boost::mpl::int_<256>                                      \
-        >                                                              \
-    ));                                                                \
-    /*                                                                 \
-    BOOST_MPL_ASSERT((                                                 \
-        mpl::equal_to<                                                 \
-            :implementation_level<T >,                                 \
-            mpl::int_<object_class_info>                               \
-        >::value                                                       \
-    ));                                                                \
-    */                                                                 \
-};                                                                     \
-}                                                                      \
-}
-
-#endif // BOOST_SERIALIZATION_VERSION_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/void_cast.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/void_cast.hpp
deleted file mode 100644
index f1b38286115..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/void_cast.hpp
+++ /dev/null
@@ -1,298 +0,0 @@
-#ifndef  BOOST_SERIALIZATION_VOID_CAST_HPP
-#define BOOST_SERIALIZATION_VOID_CAST_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// void_cast.hpp:   interface for run-time casting of void pointers.
-
-// (C) Copyright 2002-2009 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-// gennadiy.rozental@tfn.com
-
-//  See http://www.boost.org for updates, documentation, and revision history.
-
-#include <cstddef> // for ptrdiff_t
-#include <boost/config.hpp>
-#include <boost/noncopyable.hpp>
-
-#include <boost/serialization/smart_cast.hpp>
-#include <boost/serialization/singleton.hpp>
-#include <boost/serialization/force_include.hpp>
-#include <boost/serialization/type_info_implementation.hpp>
-#include <boost/serialization/extended_type_info.hpp>
-#include <boost/type_traits/is_virtual_base_of.hpp>
-#include <boost/serialization/void_cast_fwd.hpp>
-
-#include <boost/serialization/config.hpp>
-#include <boost/config/abi_prefix.hpp> // must be the last header
-
-#ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable : 4251 4231 4660 4275)
-#endif
-
-namespace boost { 
-namespace serialization { 
-
-class extended_type_info;
-
-// Given a void *, assume that it really points to an instance of one type
-// and alter it so that it would point to an instance of a related type.
-// Return the altered pointer. If there exists no sequence of casts that
-// can transform from_type to to_type, return a NULL.  
-
-BOOST_SERIALIZATION_DECL void const *
-void_upcast(
-    extended_type_info const & derived,  
-    extended_type_info const & base, 
-    void const * const t
-);
-
-inline void *
-void_upcast(
-    extended_type_info const & derived,
-    extended_type_info const & base,
-    void * const t 
-){
-    return const_cast<void*>(void_upcast(
-        derived, 
-        base, 
-        const_cast<void const *>(t)
-    ));
-}
-
-BOOST_SERIALIZATION_DECL void const *
-void_downcast(
-    extended_type_info const & derived,  
-    extended_type_info const & base, 
-    void const * const t
-);
-
-inline void *
-void_downcast(
-    extended_type_info const & derived,
-    extended_type_info const & base,
-    void * const t 
-){
-    return const_cast<void*>(void_downcast(
-        derived, 
-        base, 
-        const_cast<void const *>(t)
-    ));
-}
-
-namespace void_cast_detail {
-
-class BOOST_SYMBOL_VISIBLE void_caster :
-    private boost::noncopyable
-{
-    friend 
-    BOOST_SERIALIZATION_DECL void const *
-    boost::serialization::void_upcast(
-        extended_type_info const & derived,
-        extended_type_info const & base,
-        void const * const
-    );
-    friend 
-    BOOST_SERIALIZATION_DECL void const *
-    boost::serialization::void_downcast(
-        extended_type_info const & derived,
-        extended_type_info const & base,
-        void const * const
-    );
-protected:
-    BOOST_SERIALIZATION_DECL void recursive_register(bool includes_virtual_base = false) const;
-    BOOST_SERIALIZATION_DECL void recursive_unregister() const;
-    virtual bool has_virtual_base() const = 0;
-public:
-    // Data members
-    const extended_type_info * m_derived;
-    const extended_type_info * m_base;
-    /*const*/ std::ptrdiff_t m_difference;
-    void_caster const * const m_parent;
-
-    // note that void_casters are keyed on value of
-    // member extended type info records - NOT their
-    // addresses.  This is necessary in order for the
-    // void cast operations to work across dll and exe
-    // module boundries.
-    bool operator<(const void_caster & rhs) const;
-
-    const void_caster & operator*(){
-        return *this;
-    }
-    // each derived class must re-implement these;
-    virtual void const * upcast(void const * const t) const = 0;
-    virtual void const * downcast(void const * const t) const = 0;
-    // Constructor
-    void_caster(
-        extended_type_info const * derived,
-        extended_type_info const * base,
-        std::ptrdiff_t difference = 0,
-        void_caster const * const parent = 0
-    ) :
-        m_derived(derived),
-        m_base(base),
-        m_difference(difference),
-        m_parent(parent)
-    {}
-    virtual ~void_caster(){}
-};
-
-#ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable : 4251 4231 4660 4275 4511 4512)
-#endif
-
-template <class Derived, class Base>
-class BOOST_SYMBOL_VISIBLE void_caster_primitive :
-    public void_caster
-{
-    virtual void const * downcast(void const * const t) const {
-        const Derived * d = 
-            boost::serialization::smart_cast<const Derived *, const Base *>(
-                static_cast<const Base *>(t)
-            );
-        return d;
-    }
-    virtual void const * upcast(void const * const t) const {
-        const Base * b = 
-            boost::serialization::smart_cast<const Base *, const Derived *>(
-                static_cast<const Derived *>(t)
-            );
-        return b;
-    }
-    virtual bool has_virtual_base() const {
-        return false;
-    }
-public:
-    void_caster_primitive();
-    virtual ~void_caster_primitive();
-};
-
-template <class Derived, class Base>
-void_caster_primitive<Derived, Base>::void_caster_primitive() :
-    void_caster( 
-        & type_info_implementation<Derived>::type::get_const_instance(), 
-        & type_info_implementation<Base>::type::get_const_instance(),
-        // note:I wanted to displace from 0 here, but at least one compiler
-        // treated 0 by not shifting it at all.
-        reinterpret_cast<std::ptrdiff_t>(
-            static_cast<Derived *>(
-                reinterpret_cast<Base *>(8)
-            )
-        ) - 8
-    )
-{
-    recursive_register();
-}
-
-template <class Derived, class Base>
-void_caster_primitive<Derived, Base>::~void_caster_primitive(){
-    recursive_unregister();
-}
-
-template <class Derived, class Base>
-class BOOST_SYMBOL_VISIBLE void_caster_virtual_base :
-    public void_caster
-{
-    virtual bool has_virtual_base() const {
-        return true;
-    }
-public:
-    virtual void const * downcast(void const * const t) const {
-        const Derived * d = 
-            dynamic_cast<const Derived *>(
-                static_cast<const Base *>(t)
-            );
-        return d;
-    }
-    virtual void const * upcast(void const * const t) const {
-        const Base * b = 
-            dynamic_cast<const Base *>(
-                static_cast<const Derived *>(t)
-            );
-        return b;
-    }
-    void_caster_virtual_base();
-    virtual ~void_caster_virtual_base();
-};
-
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
-
-template <class Derived, class Base>
-void_caster_virtual_base<Derived,Base>::void_caster_virtual_base() :
-    void_caster( 
-        & (type_info_implementation<Derived>::type::get_const_instance()), 
-        & (type_info_implementation<Base>::type::get_const_instance())
-    )
-{
-    recursive_register(true);
-}
-
-template <class Derived, class Base>
-void_caster_virtual_base<Derived,Base>::~void_caster_virtual_base(){
-    recursive_unregister();
-}
-
-template <class Derived, class Base>
-struct BOOST_SYMBOL_VISIBLE void_caster_base :
-    public void_caster
-{
-    typedef
-        typename mpl::eval_if<boost::is_virtual_base_of<Base,Derived>,
-            mpl::identity<
-                void_cast_detail::void_caster_virtual_base<Derived, Base>
-            >
-        ,// else
-            mpl::identity<
-                void_cast_detail::void_caster_primitive<Derived, Base>
-            >
-        >::type type;
-};
-
-} // void_cast_detail 
-
-template<class Derived, class Base>
-BOOST_DLLEXPORT 
-inline const void_cast_detail::void_caster & void_cast_register(
-    Derived const * /* dnull = NULL */, 
-    Base const * /* bnull = NULL */
-){
-    typedef
-        typename mpl::eval_if<boost::is_virtual_base_of<Base,Derived>,
-            mpl::identity<
-                void_cast_detail::void_caster_virtual_base<Derived, Base>
-            >
-        ,// else
-            mpl::identity<
-                void_cast_detail::void_caster_primitive<Derived, Base>
-            >
-        >::type typex;
-    return singleton<typex>::get_const_instance();
-}
-
-template<class Derived, class Base>
-class BOOST_SYMBOL_VISIBLE void_caster :
-    public void_cast_detail::void_caster_base<Derived, Base>::type
-{
-};
-
-} // namespace serialization
-} // namespace boost
-
-#ifdef BOOST_MSVC  
-#  pragma warning(pop)  
-#endif
-
-#include <boost/config/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
-
-#endif // BOOST_SERIALIZATION_VOID_CAST_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/void_cast_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/void_cast_fwd.hpp
deleted file mode 100644
index def61d52bb7..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/void_cast_fwd.hpp
+++ /dev/null
@@ -1,37 +0,0 @@
-#ifndef  BOOST_SERIALIZATION_VOID_CAST_FWD_HPP
-#define BOOST_SERIALIZATION_VOID_CAST_FWD_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// void_cast_fwd.hpp:   interface for run-time casting of void pointers.
-
-// (C) Copyright 2005 Robert Ramey - http://www.rrsd.com . 
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-// gennadiy.rozental@tfn.com
-
-//  See http://www.boost.org for updates, documentation, and revision history.
-
-#include <cstddef> // NULL
-#include <boost/serialization/force_include.hpp>
-
-namespace boost {
-namespace serialization {
-namespace void_cast_detail{
-class void_caster;
-} // namespace void_cast_detail
-template<class Derived, class Base>
-BOOST_DLLEXPORT 
-inline const void_cast_detail::void_caster & void_cast_register(
-    const Derived * dnull = NULL, 
-    const Base * bnull = NULL
-) BOOST_USED;
-} // namespace serialization
-} // namespace boost
-
-#endif // BOOST_SERIALIZATION_VOID_CAST_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/weak_ptr.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/weak_ptr.hpp
deleted file mode 100644
index 6952d24cb37..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/weak_ptr.hpp
+++ /dev/null
@@ -1,99 +0,0 @@
-#ifndef BOOST_SERIALIZATION_WEAK_PTR_HPP
-#define BOOST_SERIALIZATION_WEAK_PTR_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// weak_ptr.hpp: serialization for boost weak pointer
-
-// (C) Copyright 2004 Robert Ramey and Martin Ecker
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.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.
-
-#include <boost/weak_ptr.hpp>
-#include <boost/serialization/shared_ptr.hpp>
-
-namespace boost {
-namespace serialization{
-
-template<class Archive, class T>
-inline void save(
-    Archive & ar,
-    const boost::weak_ptr< T > &t,
-    const unsigned int /* file_version */
-){
-    const boost::shared_ptr< T > sp = t.lock();
-    ar << boost::serialization::make_nvp("weak_ptr", sp);
-}
-
-template<class Archive, class T>
-inline void load(
-    Archive & ar,
-    boost::weak_ptr< T > &t,
-    const unsigned int /* file_version */
-){
-    boost::shared_ptr< T > sp;
-    ar >> boost::serialization::make_nvp("weak_ptr", sp);
-    t = sp;
-}
-
-template<class Archive, class T>
-inline void serialize(
-    Archive & ar,
-    boost::weak_ptr< T > &t,
-    const unsigned int file_version
-){
-    boost::serialization::split_free(ar, t, file_version);
-}
-
-} // namespace serialization
-} // namespace boost
-
-#ifndef BOOST_NO_CXX11_SMART_PTR
-#include <memory>
-
-namespace boost {
-namespace serialization{
-
-template<class Archive, class T>
-inline void save(
-    Archive & ar,
-    const std::weak_ptr< T > &t,
-    const unsigned int /* file_version */
-){
-    const std::shared_ptr< T > sp = t.lock();
-    ar << boost::serialization::make_nvp("weak_ptr", sp);
-}
-
-template<class Archive, class T>
-inline void load(
-    Archive & ar,
-    std::weak_ptr< T > &t,
-    const unsigned int /* file_version */
-){
-    std::shared_ptr< T > sp;
-    ar >> boost::serialization::make_nvp("weak_ptr", sp);
-    t = sp;
-}
-
-template<class Archive, class T>
-inline void serialize(
-    Archive & ar,
-    std::weak_ptr< T > &t,
-    const unsigned int file_version
-){
-    boost::serialization::split_free(ar, t, file_version);
-}
-
-} // namespace serialization
-} // namespace boost
-
-#endif // BOOST_NO_CXX11_SMART_PTR
-
-#endif // BOOST_SERIALIZATION_WEAK_PTR_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/serialization/wrapper.hpp b/contrib/libboost/boost_1_65_0/boost/serialization/wrapper.hpp
deleted file mode 100644
index 60d7910b17a..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/serialization/wrapper.hpp
+++ /dev/null
@@ -1,60 +0,0 @@
-#ifndef BOOST_SERIALIZATION_WRAPPER_HPP
-#define BOOST_SERIALIZATION_WRAPPER_HPP
-
-// (C) Copyright 2005-2006 Matthias Troyer
-// Use, modification and distribution is subject to the 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/serialization/traits.hpp>
-#include <boost/type_traits/is_base_and_derived.hpp>
-#include <boost/mpl/eval_if.hpp>
-#include <boost/mpl/bool_fwd.hpp>
-
-namespace boost { namespace serialization {
-
-/// the base class for serialization wrappers
-///
-/// wrappers need to be treated differently at various places in the serialization library,
-/// e.g. saving of non-const wrappers has to be possible. Since partial specialization
-// is not supported by all compilers, we derive all wrappers from wrapper_traits. 
-
-template<
-    class T, 
-    int Level = object_serializable, 
-    int Tracking = track_never,
-    unsigned int Version = 0,
-    class ETII = extended_type_info_impl< T >
->
-struct wrapper_traits : 
-    public traits<T,Level,Tracking,Version,ETII,mpl::true_> 
-{};
-
-template<class T>
-struct is_wrapper_impl :
-    boost::mpl::eval_if<
-      boost::is_base_and_derived<basic_traits,T>,
-      boost::mpl::true_,
-      boost::mpl::false_
-    >::type
-{};
-
-template<class T>
-struct is_wrapper {
-    typedef typename is_wrapper_impl<const T>::type type;
-};
-
-} // serialization
-} // boost
-
-// A macro to define that a class is a wrapper
-#define BOOST_CLASS_IS_WRAPPER(T)                       \
-namespace boost {                                       \
-namespace serialization {                               \
-template<>                                              \
-struct is_wrapper_impl<const T> : boost::mpl::true_ {}; \
-}                                                       \
-}                                                       \
-/**/
-
-#endif //BOOST_SERIALIZATION_WRAPPER_HPP
diff --git a/contrib/poco b/contrib/poco
new file mode 160000
index 00000000000..29439cf7fa3
--- /dev/null
+++ b/contrib/poco
@@ -0,0 +1 @@
+Subproject commit 29439cf7fa32c1a2d62d925bb6d6a3f14668a4a2
diff --git a/contrib/zlib-ng b/contrib/zlib-ng
new file mode 160000
index 00000000000..9173b89d467
--- /dev/null
+++ b/contrib/zlib-ng
@@ -0,0 +1 @@
+Subproject commit 9173b89d46799582d20a30578e0aa9788bc7d6e1
diff --git a/dbms/src/Storages/MergeTree/MergeTreeData.cpp b/dbms/src/Storages/MergeTree/MergeTreeData.cpp
index b7ad890b47c..07b95dbb91a 100644
--- a/dbms/src/Storages/MergeTree/MergeTreeData.cpp
+++ b/dbms/src/Storages/MergeTree/MergeTreeData.cpp
@@ -2266,8 +2266,6 @@ MergeTreeData::DataPartPtr MergeTreeData::getActiveContainingPart(
 {
     auto committed_parts_range = getDataPartsStateRange(state);
 
-    auto committed_parts_range = getDataPartsStateRange(DataPartState::Committed);
-
     /// The part can be covered only by the previous or the next one in data_parts.
     auto it = data_parts_by_state_and_info.lower_bound(DataPartStateAndInfo{state, part_info});
 
@@ -2600,7 +2598,6 @@ MergeTreeData::getDetachedParts() const
 
         part.prefix = dir_name.substr(0, first_separator);
     }
-
     return res;
 }
 

From 03d659ea1abd57f8c908f3a2d3c83332f3cdd519 Mon Sep 17 00:00:00 2001
From: Vitaliy Zakaznikov <vzakaznikov@protonmail.com>
Date: Thu, 13 Jun 2019 12:41:40 -0400
Subject: [PATCH 045/107] * Sync with yandex/master so that the git diff
 yandex/master is empty

---
 .gitmodules | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/.gitmodules b/.gitmodules
index 336c2a892e2..0fda654f07c 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -1,3 +1,6 @@
+[submodule "contrib/poco"]
+	path = contrib/poco
+	url = https://github.com/ClickHouse-Extras/poco
 [submodule "contrib/zstd"]
 	path = contrib/zstd
 	url = https://github.com/facebook/zstd.git
@@ -10,6 +13,12 @@
 [submodule "contrib/cctz"]
 	path = contrib/cctz
 	url = https://github.com/google/cctz.git
+[submodule "contrib/zlib-ng"]
+	path = contrib/zlib-ng
+	url = https://github.com/ClickHouse-Extras/zlib-ng.git
+[submodule "contrib/googletest"]
+	path = contrib/googletest
+	url = https://github.com/google/googletest.git
 [submodule "contrib/capnproto"]
 	path = contrib/capnproto
 	url = https://github.com/capnproto/capnproto.git

From 6cca6d359dcb410ee30e9d30cf52e92819e2c265 Mon Sep 17 00:00:00 2001
From: Vitaliy Zakaznikov <vzakaznikov@protonmail.com>
Date: Thu, 13 Jun 2019 21:02:15 -0400
Subject: [PATCH 046/107] * Reverting changes to clickhouse-test as it seems to
 cause some tests to fail * Updating client.py to use CLICKHOUSE_BINARY env
 variable instead of CLICKHOUSE_CLIENT

---
 dbms/tests/clickhouse-test                       | 2 +-
 dbms/tests/queries/0_stateless/helpers/client.py | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/dbms/tests/clickhouse-test b/dbms/tests/clickhouse-test
index 4ca549889d6..e64b04f2db5 100755
--- a/dbms/tests/clickhouse-test
+++ b/dbms/tests/clickhouse-test
@@ -258,7 +258,7 @@ def main(args):
 
     # Keep same default values as in queries/shell_config.sh
     os.environ.setdefault("CLICKHOUSE_BINARY", args.binary)
-    os.environ.setdefault("CLICKHOUSE_CLIENT", args.client)
+    #os.environ.setdefault("CLICKHOUSE_CLIENT", args.client)
     os.environ.setdefault("CLICKHOUSE_CONFIG", args.configserver)
     if args.configclient:
         os.environ.setdefault("CLICKHOUSE_CONFIG_CLIENT", args.configclient)
diff --git a/dbms/tests/queries/0_stateless/helpers/client.py b/dbms/tests/queries/0_stateless/helpers/client.py
index 59ea3d898ea..dec7eca7d78 100644
--- a/dbms/tests/queries/0_stateless/helpers/client.py
+++ b/dbms/tests/queries/0_stateless/helpers/client.py
@@ -12,7 +12,7 @@ end_of_block = r'.*\r\n.*\r\n'
 
 def client(command=None, name='', log=None):
     if command is None:
-        client = uexpect.spawn(os.environ.get('CLICKHOUSE_CLIENT'))
+        client = uexpect.spawn(os.environ.get('CLICKHOUSE_BINARY', 'clickhouse') + '-client')
     else:
         client = uexpect.spawn(command)
     client.eol('\r')

From 13978c03f382ce44e404ecfe830bb62490aca02c Mon Sep 17 00:00:00 2001
From: Vitaliy Zakaznikov <vzakaznikov@protonmail.com>
Date: Fri, 14 Jun 2019 10:06:15 -0400
Subject: [PATCH 047/107] * Fixing a bug in StorageLiveView.cpp in the
 getHeader() method   when header block would not match blocks in the stream  
 when Const column is present. * Updating
 00963_temporary_live_view_watch_live_timeout.py   and removed timeout=5 after
 WATCH query is aborted with Ctrl-C   so that the default timeout of 20sec is
 used * Small style fixes in tests

---
 dbms/src/Storages/StorageLiveView.cpp         | 25 ++++++++++++++-----
 .../0_stateless/00958_live_view_watch_live.py |  2 +-
 .../00960_live_view_watch_events_live.py      |  2 +-
 .../00962_temporary_live_view_watch_live.py   |  2 +-
 ..._temporary_live_view_watch_live_timeout.py |  4 +--
 .../00964_live_view_watch_events_heartbeat.py |  2 +-
 .../00965_live_view_watch_heartbeat.py        |  2 +-
 7 files changed, 26 insertions(+), 13 deletions(-)

diff --git a/dbms/src/Storages/StorageLiveView.cpp b/dbms/src/Storages/StorageLiveView.cpp
index 77e95ac2e48..917d62baaa4 100644
--- a/dbms/src/Storages/StorageLiveView.cpp
+++ b/dbms/src/Storages/StorageLiveView.cpp
@@ -159,12 +159,25 @@ Block StorageLiveView::getHeader() const
 {
     if (!sample_block)
     {
-        auto storage = global_context.getTable(select_database_name, select_table_name);
-        sample_block = InterpreterSelectQuery(inner_query, global_context, storage).getSampleBlock();
-        sample_block.insert({DataTypeUInt64().createColumnConst(
-            sample_block.rows(), 0)->convertToFullColumnIfConst(),
-            std::make_shared<DataTypeUInt64>(),
-            "_version"});
+        if (!(*blocks_ptr) || (*blocks_ptr)->empty())
+        {
+            auto storage = global_context.getTable(select_database_name, select_table_name);
+            sample_block = InterpreterSelectQuery(inner_query, global_context, storage, SelectQueryOptions(QueryProcessingStage::Complete)).getSampleBlock();
+            sample_block.insert({DataTypeUInt64().createColumnConst(
+                sample_block.rows(), 0)->convertToFullColumnIfConst(),
+                std::make_shared<DataTypeUInt64>(),
+                "_version"});
+            /// convert all columns to full columns
+            /// in case some of them are constant
+            for (size_t i = 0; i < sample_block.columns(); ++i)
+            {
+                sample_block.safeGetByPosition(i).column = sample_block.safeGetByPosition(i).column->convertToFullColumnIfConst();
+            }
+        }
+        else
+        {
+            sample_block = (*blocks_ptr)->front().cloneEmpty();
+        }
     }
 
     return sample_block;
diff --git a/dbms/tests/queries/0_stateless/00958_live_view_watch_live.py b/dbms/tests/queries/0_stateless/00958_live_view_watch_live.py
index cb6f1e95f7e..7cbea5fbff6 100755
--- a/dbms/tests/queries/0_stateless/00958_live_view_watch_live.py
+++ b/dbms/tests/queries/0_stateless/00958_live_view_watch_live.py
@@ -31,7 +31,7 @@ with client(name='client1>', log=log) as client1, client(name='client2>', log=lo
     client2.send('INSERT INTO test.mt VALUES (4),(5),(6)')
     client1.expect(r'21.*3' + end_of_block)
     # send Ctrl-C
-    os.kill(client1.process.pid,signal.SIGINT)
+    os.kill(client1.process.pid, signal.SIGINT)
     client1.expect(prompt)
     client1.send('DROP TABLE test.lv')
     client1.expect(prompt)
diff --git a/dbms/tests/queries/0_stateless/00960_live_view_watch_events_live.py b/dbms/tests/queries/0_stateless/00960_live_view_watch_events_live.py
index 414f9c1ad96..becf0335600 100755
--- a/dbms/tests/queries/0_stateless/00960_live_view_watch_events_live.py
+++ b/dbms/tests/queries/0_stateless/00960_live_view_watch_events_live.py
@@ -31,7 +31,7 @@ with client(name='client1>', log=log) as client1, client(name='client2>', log=lo
     client2.send('INSERT INTO test.mt VALUES (4),(5),(6)')
     client1.expect('3.*2186dbea325ee4c56b67e9b792e993a3' + end_of_block)
     # send Ctrl-C
-    os.kill(client1.process.pid,signal.SIGINT)
+    os.kill(client1.process.pid, signal.SIGINT)
     client1.expect(prompt)
     client1.send('DROP TABLE test.lv')
     client1.expect(prompt)
diff --git a/dbms/tests/queries/0_stateless/00962_temporary_live_view_watch_live.py b/dbms/tests/queries/0_stateless/00962_temporary_live_view_watch_live.py
index 1967284c38b..d4d35548d68 100755
--- a/dbms/tests/queries/0_stateless/00962_temporary_live_view_watch_live.py
+++ b/dbms/tests/queries/0_stateless/00962_temporary_live_view_watch_live.py
@@ -31,7 +31,7 @@ with client(name='client1>', log=log) as client1, client(name='client2>', log=lo
     client2.send('INSERT INTO test.mt VALUES (4),(5),(6)')
     client1.expect(r'21.*3' + end_of_block)
     # send Ctrl-C
-    os.kill(client1.process.pid,signal.SIGINT)
+    os.kill(client1.process.pid, signal.SIGINT)
     client1.expect(prompt)
     client1.send('DROP TABLE test.lv')
     client1.expect(prompt)
diff --git a/dbms/tests/queries/0_stateless/00963_temporary_live_view_watch_live_timeout.py b/dbms/tests/queries/0_stateless/00963_temporary_live_view_watch_live_timeout.py
index 581363cd796..2008368f12e 100755
--- a/dbms/tests/queries/0_stateless/00963_temporary_live_view_watch_live_timeout.py
+++ b/dbms/tests/queries/0_stateless/00963_temporary_live_view_watch_live_timeout.py
@@ -35,8 +35,8 @@ with client(name='client1>', log=log) as client1, client(name='client2>', log=lo
     client2.expect(prompt)
     client1.expect(r'21.*3' + end_of_block)
     # send Ctrl-C
-    os.kill(client1.process.pid,signal.SIGINT)
-    client1.expect(prompt, timeout=5)
+    os.kill(client1.process.pid, signal.SIGINT)
+    client1.expect(prompt)
     client1.send('SELECT sleep(1)')
     client1.expect(prompt)
     client1.send('DROP TABLE test.lv')
diff --git a/dbms/tests/queries/0_stateless/00964_live_view_watch_events_heartbeat.py b/dbms/tests/queries/0_stateless/00964_live_view_watch_events_heartbeat.py
index b624e0b7080..3ced5f6f315 100755
--- a/dbms/tests/queries/0_stateless/00964_live_view_watch_events_heartbeat.py
+++ b/dbms/tests/queries/0_stateless/00964_live_view_watch_events_heartbeat.py
@@ -33,7 +33,7 @@ with client(name='client1>', log=log) as client1, client(name='client2>', log=lo
     # wait for heartbeat
     client1.expect('Progress: 2.00 rows.*\)')
     # send Ctrl-C
-    os.kill(client1.process.pid,signal.SIGINT)
+    os.kill(client1.process.pid, signal.SIGINT)
     client1.expect(prompt)
     client1.send('DROP TABLE test.lv')
     client1.expect(prompt)
diff --git a/dbms/tests/queries/0_stateless/00965_live_view_watch_heartbeat.py b/dbms/tests/queries/0_stateless/00965_live_view_watch_heartbeat.py
index dfb46273f7c..b2bd84e0742 100755
--- a/dbms/tests/queries/0_stateless/00965_live_view_watch_heartbeat.py
+++ b/dbms/tests/queries/0_stateless/00965_live_view_watch_heartbeat.py
@@ -34,7 +34,7 @@ with client(name='client1>', log=log) as client1, client(name='client2>', log=lo
     # wait for heartbeat
     client1.expect('Progress: 2.00 rows.*\)')
     # send Ctrl-C
-    os.kill(client1.process.pid,signal.SIGINT)
+    os.kill(client1.process.pid, signal.SIGINT)
     client1.expect(prompt)
     client1.send('DROP TABLE test.lv')
     client1.expect(prompt)

From d6d0404c48af9cf56441a8def682e9fc47b3349b Mon Sep 17 00:00:00 2001
From: Vitaliy Zakaznikov <vzakaznikov@protonmail.com>
Date: Fri, 14 Jun 2019 16:27:43 -0400
Subject: [PATCH 048/107] * Fixing bug in StorageLiveView.cpp getHeader()
 method   that sometimes addressed invalid pointer when getHeader()   method
 was called without holding the mutex

---
 dbms/src/Storages/StorageLiveView.cpp | 28 +++++++++++----------------
 1 file changed, 11 insertions(+), 17 deletions(-)

diff --git a/dbms/src/Storages/StorageLiveView.cpp b/dbms/src/Storages/StorageLiveView.cpp
index 917d62baaa4..eecc7f6d1dc 100644
--- a/dbms/src/Storages/StorageLiveView.cpp
+++ b/dbms/src/Storages/StorageLiveView.cpp
@@ -159,24 +159,18 @@ Block StorageLiveView::getHeader() const
 {
     if (!sample_block)
     {
-        if (!(*blocks_ptr) || (*blocks_ptr)->empty())
+        auto storage = global_context.getTable(select_database_name, select_table_name);
+        sample_block = InterpreterSelectQuery(inner_query, global_context, storage,
+            SelectQueryOptions(QueryProcessingStage::Complete)).getSampleBlock();
+        sample_block.insert({DataTypeUInt64().createColumnConst(
+            sample_block.rows(), 0)->convertToFullColumnIfConst(),
+            std::make_shared<DataTypeUInt64>(),
+            "_version"});
+        /// convert all columns to full columns
+        /// in case some of them are constant
+        for (size_t i = 0; i < sample_block.columns(); ++i)
         {
-            auto storage = global_context.getTable(select_database_name, select_table_name);
-            sample_block = InterpreterSelectQuery(inner_query, global_context, storage, SelectQueryOptions(QueryProcessingStage::Complete)).getSampleBlock();
-            sample_block.insert({DataTypeUInt64().createColumnConst(
-                sample_block.rows(), 0)->convertToFullColumnIfConst(),
-                std::make_shared<DataTypeUInt64>(),
-                "_version"});
-            /// convert all columns to full columns
-            /// in case some of them are constant
-            for (size_t i = 0; i < sample_block.columns(); ++i)
-            {
-                sample_block.safeGetByPosition(i).column = sample_block.safeGetByPosition(i).column->convertToFullColumnIfConst();
-            }
-        }
-        else
-        {
-            sample_block = (*blocks_ptr)->front().cloneEmpty();
+            sample_block.safeGetByPosition(i).column = sample_block.safeGetByPosition(i).column->convertToFullColumnIfConst();
         }
     }
 

From 282ff6bfda42c949b9d1a4921ad7f42435436526 Mon Sep 17 00:00:00 2001
From: Vitaliy Zakaznikov <vzakaznikov@protonmail.com>
Date: Fri, 14 Jun 2019 21:08:46 -0400
Subject: [PATCH 049/107] * Fixing a bug in writeIntoLiveView method where
 blocks->front()   is called before checking if blocks vector is empty.

---
 dbms/src/Storages/StorageLiveView.h | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/dbms/src/Storages/StorageLiveView.h b/dbms/src/Storages/StorageLiveView.h
index 01dd82ff1fd..69410ec4e8b 100644
--- a/dbms/src/Storages/StorageLiveView.h
+++ b/dbms/src/Storages/StorageLiveView.h
@@ -202,7 +202,7 @@ public:
             }
 
             /// Need make new mergeable block structure match the other mergeable blocks
-            if (!mergeable_blocks->front()->empty() && !new_mergeable_blocks->empty())
+            if (!mergeable_blocks->front()->empty())
             {
                 auto sample_block = mergeable_blocks->front()->front();
                 auto sample_new_block = new_mergeable_blocks->front();
@@ -237,6 +237,9 @@ public:
             blocks->push_back(this_block);
         }
 
+        if (blocks->empty())
+            return;
+
         auto sample_block = blocks->front().cloneEmpty();
         BlockInputStreamPtr new_data = std::make_shared<BlocksBlockInputStream>(std::make_shared<BlocksPtr>(blocks), sample_block);
 

From 103bf9d068eb047d2f1dc789401265b18fdbd13f Mon Sep 17 00:00:00 2001
From: Vitaliy Zakaznikov <vzakaznikov@protonmail.com>
Date: Sat, 15 Jun 2019 23:34:28 -0400
Subject: [PATCH 050/107] * Updating tests as SHOW TABLES 'lv' does not return
 any tables   as test database is not selected by default.

---
 .../queries/0_stateless/00952_live_view_create.reference      | 1 -
 dbms/tests/queries/0_stateless/00952_live_view_create.sql     | 2 --
 .../0_stateless/00954_live_view_select_version.reference      | 1 -
 .../queries/0_stateless/00954_live_view_select_version.sql    | 2 --
 .../00955_live_view_select_with_aggregation.reference         | 1 -
 .../0_stateless/00955_live_view_select_with_aggregation.sql   | 2 --
 .../0_stateless/00956_live_view_watch_events.reference        | 1 -
 .../queries/0_stateless/00956_live_view_watch_events.sql      | 2 --
 .../tests/queries/0_stateless/00957_live_view_watch.reference | 1 -
 dbms/tests/queries/0_stateless/00957_live_view_watch.sql      | 2 --
 .../0_stateless/00959_create_temporary_live_view.reference    | 1 -
 .../0_stateless/00961_temporary_live_view_watch.reference     | 1 -
 .../queries/0_stateless/00961_temporary_live_view_watch.sql   | 2 --
 ..._live_view_select_format_jsoneachrowwithprogress.reference | 1 -
 .../00968_live_view_select_format_jsoneachrowwithprogress.sql | 2 --
 ...9_live_view_watch_format_jsoneachrowwithprogress.reference | 1 -
 .../00969_live_view_watch_format_jsoneachrowwithprogress.sql  | 2 --
 .../queries/0_stateless/00972_live_view_select_1.reference    | 1 -
 dbms/tests/queries/0_stateless/00972_live_view_select_1.sql   | 4 +++-
 .../queries/0_stateless/00973_live_view_select.reference      | 1 -
 dbms/tests/queries/0_stateless/00973_live_view_select.sql     | 2 --
 21 files changed, 3 insertions(+), 30 deletions(-)

diff --git a/dbms/tests/queries/0_stateless/00952_live_view_create.reference b/dbms/tests/queries/0_stateless/00952_live_view_create.reference
index c39f21eaf5e..e69de29bb2d 100644
--- a/dbms/tests/queries/0_stateless/00952_live_view_create.reference
+++ b/dbms/tests/queries/0_stateless/00952_live_view_create.reference
@@ -1 +0,0 @@
-lv
diff --git a/dbms/tests/queries/0_stateless/00952_live_view_create.sql b/dbms/tests/queries/0_stateless/00952_live_view_create.sql
index 0b64ed3a876..1c929b15b00 100644
--- a/dbms/tests/queries/0_stateless/00952_live_view_create.sql
+++ b/dbms/tests/queries/0_stateless/00952_live_view_create.sql
@@ -3,7 +3,5 @@ DROP TABLE IF EXISTS test.mt;
 CREATE TABLE test.mt (a Int32) Engine=MergeTree order by tuple();
 CREATE LIVE VIEW test.lv AS SELECT * FROM test.mt;
 
-SHOW TABLES LIKE 'lv';
-
 DROP TABLE test.lv;
 DROP TABLE test.mt;
diff --git a/dbms/tests/queries/0_stateless/00954_live_view_select_version.reference b/dbms/tests/queries/0_stateless/00954_live_view_select_version.reference
index 07b5ce41af1..453bd800469 100644
--- a/dbms/tests/queries/0_stateless/00954_live_view_select_version.reference
+++ b/dbms/tests/queries/0_stateless/00954_live_view_select_version.reference
@@ -1,4 +1,3 @@
-lv
 1	1
 2	1
 3	1
diff --git a/dbms/tests/queries/0_stateless/00954_live_view_select_version.sql b/dbms/tests/queries/0_stateless/00954_live_view_select_version.sql
index 569cf5b0ab2..5f3ab1f7546 100644
--- a/dbms/tests/queries/0_stateless/00954_live_view_select_version.sql
+++ b/dbms/tests/queries/0_stateless/00954_live_view_select_version.sql
@@ -4,8 +4,6 @@ DROP TABLE IF EXISTS test.mt;
 CREATE TABLE test.mt (a Int32) Engine=MergeTree order by tuple();
 CREATE LIVE VIEW test.lv AS SELECT * FROM test.mt;
 
-SHOW TABLES LIKE 'lv';
-
 INSERT INTO test.mt VALUES (1),(2),(3);
 
 SELECT *,_version FROM test.lv;
diff --git a/dbms/tests/queries/0_stateless/00955_live_view_select_with_aggregation.reference b/dbms/tests/queries/0_stateless/00955_live_view_select_with_aggregation.reference
index cb865431ffd..6d50f0e9c3a 100644
--- a/dbms/tests/queries/0_stateless/00955_live_view_select_with_aggregation.reference
+++ b/dbms/tests/queries/0_stateless/00955_live_view_select_with_aggregation.reference
@@ -1,3 +1,2 @@
-lv
 6
 21
diff --git a/dbms/tests/queries/0_stateless/00955_live_view_select_with_aggregation.sql b/dbms/tests/queries/0_stateless/00955_live_view_select_with_aggregation.sql
index cdac382cae2..3c11f855c9d 100644
--- a/dbms/tests/queries/0_stateless/00955_live_view_select_with_aggregation.sql
+++ b/dbms/tests/queries/0_stateless/00955_live_view_select_with_aggregation.sql
@@ -4,8 +4,6 @@ DROP TABLE IF EXISTS test.mt;
 CREATE TABLE test.mt (a Int32) Engine=MergeTree order by tuple();
 CREATE LIVE VIEW test.lv AS SELECT * FROM test.mt;
 
-SHOW TABLES LIKE 'lv';
-
 INSERT INTO test.mt VALUES (1),(2),(3);
 
 SELECT sum(a) FROM test.lv;
diff --git a/dbms/tests/queries/0_stateless/00956_live_view_watch_events.reference b/dbms/tests/queries/0_stateless/00956_live_view_watch_events.reference
index b67c49182e9..57e3d59ecad 100644
--- a/dbms/tests/queries/0_stateless/00956_live_view_watch_events.reference
+++ b/dbms/tests/queries/0_stateless/00956_live_view_watch_events.reference
@@ -1,4 +1,3 @@
-lv
 1	c9d39b11cce79112219a73aaa319b475
 2	4cd0592103888d4682de9a32a23602e3
 3	2186dbea325ee4c56b67e9b792e993a3
diff --git a/dbms/tests/queries/0_stateless/00956_live_view_watch_events.sql b/dbms/tests/queries/0_stateless/00956_live_view_watch_events.sql
index 1dbc201bdca..a3b84e8d4c1 100644
--- a/dbms/tests/queries/0_stateless/00956_live_view_watch_events.sql
+++ b/dbms/tests/queries/0_stateless/00956_live_view_watch_events.sql
@@ -4,8 +4,6 @@ DROP TABLE IF EXISTS test.mt;
 CREATE TABLE test.mt (a Int32) Engine=MergeTree order by tuple();
 CREATE LIVE VIEW test.lv AS SELECT sum(a) FROM test.mt;
 
-SHOW TABLES LIKE 'lv';
-
 WATCH test.lv EVENTS LIMIT 0;
 
 INSERT INTO test.mt VALUES (1),(2),(3);
diff --git a/dbms/tests/queries/0_stateless/00957_live_view_watch.reference b/dbms/tests/queries/0_stateless/00957_live_view_watch.reference
index 65500578a69..6fbbedf1b21 100644
--- a/dbms/tests/queries/0_stateless/00957_live_view_watch.reference
+++ b/dbms/tests/queries/0_stateless/00957_live_view_watch.reference
@@ -1,4 +1,3 @@
-lv
 0	1
 6	2
 21	3
diff --git a/dbms/tests/queries/0_stateless/00957_live_view_watch.sql b/dbms/tests/queries/0_stateless/00957_live_view_watch.sql
index ac304fec0b9..abe4a6c32ae 100644
--- a/dbms/tests/queries/0_stateless/00957_live_view_watch.sql
+++ b/dbms/tests/queries/0_stateless/00957_live_view_watch.sql
@@ -4,8 +4,6 @@ DROP TABLE IF EXISTS test.mt;
 CREATE TABLE test.mt (a Int32) Engine=MergeTree order by tuple();
 CREATE LIVE VIEW test.lv AS SELECT sum(a) FROM test.mt;
 
-SHOW TABLES LIKE 'lv';
-
 WATCH test.lv LIMIT 0;
 
 INSERT INTO test.mt VALUES (1),(2),(3);
diff --git a/dbms/tests/queries/0_stateless/00959_create_temporary_live_view.reference b/dbms/tests/queries/0_stateless/00959_create_temporary_live_view.reference
index 49d86fc2fbf..7f9fcbb2e9c 100644
--- a/dbms/tests/queries/0_stateless/00959_create_temporary_live_view.reference
+++ b/dbms/tests/queries/0_stateless/00959_create_temporary_live_view.reference
@@ -1,4 +1,3 @@
 temporary_live_view_timeout	5
 live_view_heartbeat_interval	15
-lv
 0
diff --git a/dbms/tests/queries/0_stateless/00961_temporary_live_view_watch.reference b/dbms/tests/queries/0_stateless/00961_temporary_live_view_watch.reference
index 65500578a69..6fbbedf1b21 100644
--- a/dbms/tests/queries/0_stateless/00961_temporary_live_view_watch.reference
+++ b/dbms/tests/queries/0_stateless/00961_temporary_live_view_watch.reference
@@ -1,4 +1,3 @@
-lv
 0	1
 6	2
 21	3
diff --git a/dbms/tests/queries/0_stateless/00961_temporary_live_view_watch.sql b/dbms/tests/queries/0_stateless/00961_temporary_live_view_watch.sql
index eb99e054514..c3e2ab8d102 100644
--- a/dbms/tests/queries/0_stateless/00961_temporary_live_view_watch.sql
+++ b/dbms/tests/queries/0_stateless/00961_temporary_live_view_watch.sql
@@ -4,8 +4,6 @@ DROP TABLE IF EXISTS test.mt;
 CREATE TABLE test.mt (a Int32) Engine=MergeTree order by tuple();
 CREATE TEMPORARY LIVE VIEW test.lv AS SELECT sum(a) FROM test.mt;
 
-SHOW TABLES LIKE 'lv';
-
 WATCH test.lv LIMIT 0;
 
 INSERT INTO test.mt VALUES (1),(2),(3);
diff --git a/dbms/tests/queries/0_stateless/00968_live_view_select_format_jsoneachrowwithprogress.reference b/dbms/tests/queries/0_stateless/00968_live_view_select_format_jsoneachrowwithprogress.reference
index 0f6a0405cda..5ae423d90d1 100644
--- a/dbms/tests/queries/0_stateless/00968_live_view_select_format_jsoneachrowwithprogress.reference
+++ b/dbms/tests/queries/0_stateless/00968_live_view_select_format_jsoneachrowwithprogress.reference
@@ -1,4 +1,3 @@
-lv
 {"row":{"a":1}}
 {"row":{"a":2}}
 {"row":{"a":3}}
diff --git a/dbms/tests/queries/0_stateless/00968_live_view_select_format_jsoneachrowwithprogress.sql b/dbms/tests/queries/0_stateless/00968_live_view_select_format_jsoneachrowwithprogress.sql
index 748d901b3bf..8c6f4197d54 100644
--- a/dbms/tests/queries/0_stateless/00968_live_view_select_format_jsoneachrowwithprogress.sql
+++ b/dbms/tests/queries/0_stateless/00968_live_view_select_format_jsoneachrowwithprogress.sql
@@ -4,8 +4,6 @@ DROP TABLE IF EXISTS test.mt;
 CREATE TABLE test.mt (a Int32) Engine=MergeTree order by tuple();
 CREATE LIVE VIEW test.lv AS SELECT * FROM test.mt;
 
-SHOW TABLES LIKE 'lv';
-
 INSERT INTO test.mt VALUES (1),(2),(3);
 
 SELECT * FROM test.lv FORMAT JSONEachRowWithProgress;
diff --git a/dbms/tests/queries/0_stateless/00969_live_view_watch_format_jsoneachrowwithprogress.reference b/dbms/tests/queries/0_stateless/00969_live_view_watch_format_jsoneachrowwithprogress.reference
index 8510bebad77..287a1ced92d 100644
--- a/dbms/tests/queries/0_stateless/00969_live_view_watch_format_jsoneachrowwithprogress.reference
+++ b/dbms/tests/queries/0_stateless/00969_live_view_watch_format_jsoneachrowwithprogress.reference
@@ -1,4 +1,3 @@
-lv
 {"row":{"sum(a)":"0","_version":"1"}}
 {"progress":{"read_rows":"1","read_bytes":"16","written_rows":"0","written_bytes":"0","total_rows_to_read":"0"}}
 {"row":{"sum(a)":"6","_version":"2"}}
diff --git a/dbms/tests/queries/0_stateless/00969_live_view_watch_format_jsoneachrowwithprogress.sql b/dbms/tests/queries/0_stateless/00969_live_view_watch_format_jsoneachrowwithprogress.sql
index 9f2e0384dd8..725a4ad00ed 100644
--- a/dbms/tests/queries/0_stateless/00969_live_view_watch_format_jsoneachrowwithprogress.sql
+++ b/dbms/tests/queries/0_stateless/00969_live_view_watch_format_jsoneachrowwithprogress.sql
@@ -4,8 +4,6 @@ DROP TABLE IF EXISTS test.mt;
 CREATE TABLE test.mt (a Int32) Engine=MergeTree order by tuple();
 CREATE LIVE VIEW test.lv AS SELECT sum(a) FROM test.mt;
 
-SHOW TABLES LIKE 'lv';
-
 WATCH test.lv LIMIT 0 FORMAT JSONEachRowWithProgress;
 
 INSERT INTO test.mt VALUES (1),(2),(3);
diff --git a/dbms/tests/queries/0_stateless/00972_live_view_select_1.reference b/dbms/tests/queries/0_stateless/00972_live_view_select_1.reference
index f2f8c69d020..d00491fd7e5 100644
--- a/dbms/tests/queries/0_stateless/00972_live_view_select_1.reference
+++ b/dbms/tests/queries/0_stateless/00972_live_view_select_1.reference
@@ -1,2 +1 @@
-lv
 1
diff --git a/dbms/tests/queries/0_stateless/00972_live_view_select_1.sql b/dbms/tests/queries/0_stateless/00972_live_view_select_1.sql
index 01bfeb08fd5..661080b577b 100644
--- a/dbms/tests/queries/0_stateless/00972_live_view_select_1.sql
+++ b/dbms/tests/queries/0_stateless/00972_live_view_select_1.sql
@@ -1,5 +1,7 @@
 DROP TABLE IF EXISTS test.lv;
+
 CREATE LIVE VIEW test.lv AS SELECT 1;
-SHOW TABLES LIKE 'lv';
+
 SELECT * FROM test.lv;
+
 DROP TABLE test.lv;
diff --git a/dbms/tests/queries/0_stateless/00973_live_view_select.reference b/dbms/tests/queries/0_stateless/00973_live_view_select.reference
index 7beda18cd83..75236c0daf7 100644
--- a/dbms/tests/queries/0_stateless/00973_live_view_select.reference
+++ b/dbms/tests/queries/0_stateless/00973_live_view_select.reference
@@ -1,4 +1,3 @@
-lv
 6	1
 6	1
 12	2
diff --git a/dbms/tests/queries/0_stateless/00973_live_view_select.sql b/dbms/tests/queries/0_stateless/00973_live_view_select.sql
index 492fa265b7d..ff4a45ffcc1 100644
--- a/dbms/tests/queries/0_stateless/00973_live_view_select.sql
+++ b/dbms/tests/queries/0_stateless/00973_live_view_select.sql
@@ -4,8 +4,6 @@ DROP TABLE IF EXISTS test.mt;
 CREATE TABLE test.mt (a Int32) Engine=MergeTree order by tuple();
 CREATE LIVE VIEW test.lv AS SELECT sum(a) FROM test.mt;
 
-SHOW TABLES LIKE 'lv';
-
 INSERT INTO test.mt VALUES (1),(2),(3);
 
 SELECT *,_version FROM test.lv;

From ea83a4cafa7199f6473db6b7fd35407af54e9cd0 Mon Sep 17 00:00:00 2001
From: Vitaliy Zakaznikov <vzakaznikov@protonmail.com>
Date: Sun, 16 Jun 2019 07:09:43 -0400
Subject: [PATCH 051/107] * Removing 'hash' column from WATCH [db.live_view]
 EVENTS query result   as hash of the result are not usually provided in
 ClickHouse.   This is also done to match the implementation of the SELECT
 query that only   returns '_version' virtual column when using LIVE VIEW
 tables.

---
 dbms/src/DataStreams/LiveViewEventsBlockInputStream.h  |  9 ++-------
 .../0_stateless/00956_live_view_watch_events.reference |  6 +++---
 .../0_stateless/00960_live_view_watch_events_live.py   |  4 ++--
 .../00964_live_view_watch_events_heartbeat.py          |  2 +-
 .../0_stateless/00966_live_view_watch_events_http.py   |  4 ++--
 .../00970_live_view_watch_events_http_heartbeat.py     | 10 +++++-----
 6 files changed, 15 insertions(+), 20 deletions(-)

diff --git a/dbms/src/DataStreams/LiveViewEventsBlockInputStream.h b/dbms/src/DataStreams/LiveViewEventsBlockInputStream.h
index c7911074176..75e68b15d92 100644
--- a/dbms/src/DataStreams/LiveViewEventsBlockInputStream.h
+++ b/dbms/src/DataStreams/LiveViewEventsBlockInputStream.h
@@ -66,7 +66,7 @@ public:
 
     Block getHeader() const override
     {
-        return {ColumnWithTypeAndName(ColumnUInt64::create(), std::make_shared<DataTypeUInt64>(), "version"), ColumnWithTypeAndName(ColumnString::create(), std::make_shared<DataTypeString>(), "hash")};
+        return {ColumnWithTypeAndName(ColumnUInt64::create(), std::make_shared<DataTypeUInt64>(), "version")};
     }
 
     void refresh()
@@ -106,12 +106,7 @@ public:
             ColumnWithTypeAndName(
                 DataTypeUInt64().createColumnConst(1, blocks_metadata->version)->convertToFullColumnIfConst(),
                 std::make_shared<DataTypeUInt64>(),
-                "version"),
-            ColumnWithTypeAndName(
-                DataTypeString().createColumnConst(1, blocks_metadata->hash)->convertToFullColumnIfConst(),
-                std::make_shared<DataTypeString>(),
-                "hash"),
-
+                "version")
         };
         return res;
     }
diff --git a/dbms/tests/queries/0_stateless/00956_live_view_watch_events.reference b/dbms/tests/queries/0_stateless/00956_live_view_watch_events.reference
index 57e3d59ecad..01e79c32a8c 100644
--- a/dbms/tests/queries/0_stateless/00956_live_view_watch_events.reference
+++ b/dbms/tests/queries/0_stateless/00956_live_view_watch_events.reference
@@ -1,3 +1,3 @@
-1	c9d39b11cce79112219a73aaa319b475
-2	4cd0592103888d4682de9a32a23602e3
-3	2186dbea325ee4c56b67e9b792e993a3
+1
+2
+3
diff --git a/dbms/tests/queries/0_stateless/00960_live_view_watch_events_live.py b/dbms/tests/queries/0_stateless/00960_live_view_watch_events_live.py
index becf0335600..44b8df185b1 100755
--- a/dbms/tests/queries/0_stateless/00960_live_view_watch_events_live.py
+++ b/dbms/tests/queries/0_stateless/00960_live_view_watch_events_live.py
@@ -27,9 +27,9 @@ with client(name='client1>', log=log) as client1, client(name='client2>', log=lo
     client1.send('WATCH test.lv EVENTS')
     client1.expect('1.*' + end_of_block)
     client2.send('INSERT INTO test.mt VALUES (1),(2),(3)')
-    client1.expect('2.*4cd0592103888d4682de9a32a23602e3' + end_of_block)
+    client1.expect('2.*' + end_of_block)
     client2.send('INSERT INTO test.mt VALUES (4),(5),(6)')
-    client1.expect('3.*2186dbea325ee4c56b67e9b792e993a3' + end_of_block)
+    client1.expect('3.*' + end_of_block)
     # send Ctrl-C
     os.kill(client1.process.pid, signal.SIGINT)
     client1.expect(prompt)
diff --git a/dbms/tests/queries/0_stateless/00964_live_view_watch_events_heartbeat.py b/dbms/tests/queries/0_stateless/00964_live_view_watch_events_heartbeat.py
index 3ced5f6f315..cecae7c5a72 100755
--- a/dbms/tests/queries/0_stateless/00964_live_view_watch_events_heartbeat.py
+++ b/dbms/tests/queries/0_stateless/00964_live_view_watch_events_heartbeat.py
@@ -28,7 +28,7 @@ with client(name='client1>', log=log) as client1, client(name='client2>', log=lo
     client1.expect(prompt)
     client1.send('WATCH test.lv EVENTS')
     client2.send('INSERT INTO test.mt VALUES (1),(2),(3)')
-    client1.expect('2.*4cd0592103888d4682de9a32a23602e3' + end_of_block)
+    client1.expect('2.*' + end_of_block)
     client1.expect('Progress: 2.00 rows.*\)')
     # wait for heartbeat
     client1.expect('Progress: 2.00 rows.*\)')
diff --git a/dbms/tests/queries/0_stateless/00966_live_view_watch_events_http.py b/dbms/tests/queries/0_stateless/00966_live_view_watch_events_http.py
index a1b6f2418ea..bb9d6152200 100755
--- a/dbms/tests/queries/0_stateless/00966_live_view_watch_events_http.py
+++ b/dbms/tests/queries/0_stateless/00966_live_view_watch_events_http.py
@@ -26,10 +26,10 @@ with client(name='client1>', log=log) as client1:
 
 
     with http_client({'method':'GET', 'url': '/?query=WATCH%20test.lv%20EVENTS'}, name='client2>', log=log) as client2:
-        client2.expect('.*1\tc9d39b11cce79112219a73aaa319b475\n')
+        client2.expect('.*1\n')
         client1.send('INSERT INTO test.mt VALUES (1),(2),(3)')
         client1.expect(prompt)
-        client2.expect('.*2\t.*\n')
+        client2.expect('.*2\n')
 
     client1.send('DROP TABLE test.lv')
     client1.expect(prompt)
diff --git a/dbms/tests/queries/0_stateless/00970_live_view_watch_events_http_heartbeat.py b/dbms/tests/queries/0_stateless/00970_live_view_watch_events_http_heartbeat.py
index 29ea2142d5c..63628c4a76f 100755
--- a/dbms/tests/queries/0_stateless/00970_live_view_watch_events_http_heartbeat.py
+++ b/dbms/tests/queries/0_stateless/00970_live_view_watch_events_http_heartbeat.py
@@ -26,16 +26,16 @@ with client(name='client1>', log=log) as client1:
 
 
     with http_client({'method':'GET', 'url': '/?live_view_heartbeat_interval=1&query=WATCH%20test.lv%20EVENTS%20FORMAT%20JSONEachRowWithProgress'}, name='client2>', log=log) as client2:
-        client2.expect('{"progress":{"read_rows":"1","read_bytes":"49","written_rows":"0","written_bytes":"0","total_rows_to_read":"0"}}\n', escape=True)
-        client2.expect('{"row":{"version":"1","hash":"c9d39b11cce79112219a73aaa319b475"}}', escape=True)
-        client2.expect('{"progress":{"read_rows":"1","read_bytes":"49","written_rows":"0","written_bytes":"0","total_rows_to_read":"0"}}', escape=True)
+        client2.expect('{"progress":{"read_rows":"1","read_bytes":"8","written_rows":"0","written_bytes":"0","total_rows_to_read":"0"}}\n', escape=True)
+        client2.expect('{"row":{"version":"1"}', escape=True)
+        client2.expect('{"progress":{"read_rows":"1","read_bytes":"8","written_rows":"0","written_bytes":"0","total_rows_to_read":"0"}}', escape=True)
         # heartbeat is provided by progress message
-        client2.expect('{"progress":{"read_rows":"1","read_bytes":"49","written_rows":"0","written_bytes":"0","total_rows_to_read":"0"}}', escape=True)
+        client2.expect('{"progress":{"read_rows":"1","read_bytes":"8","written_rows":"0","written_bytes":"0","total_rows_to_read":"0"}}', escape=True)
 
         client1.send('INSERT INTO test.mt VALUES (1),(2),(3)')
         client1.expect(prompt)
 
-        client2.expect('{"row":{"version":"2","hash":"4cd0592103888d4682de9a32a23602e3"}}\n', escape=True)
+        client2.expect('{"row":{"version":"2"}}\n', escape=True)
 
     client1.send('DROP TABLE test.lv')
     client1.expect(prompt)

From 8df3e48a7b997f423840af6ec1642f2699272ccd Mon Sep 17 00:00:00 2001
From: Vitaliy Zakaznikov <vzakaznikov@protonmail.com>
Date: Mon, 17 Jun 2019 12:39:01 -0400
Subject: [PATCH 052/107] * Fixing bug in writeIntoLiveView method where
 mergeable blocks   would always be reobtained after 64 inserts

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

diff --git a/dbms/src/Storages/StorageLiveView.h b/dbms/src/Storages/StorageLiveView.h
index 69410ec4e8b..84a7ea80bca 100644
--- a/dbms/src/Storages/StorageLiveView.h
+++ b/dbms/src/Storages/StorageLiveView.h
@@ -141,6 +141,7 @@ public:
 
     std::shared_ptr<BlocksPtr> getBlocksPtr() { return blocks_ptr; }
     BlocksPtrs getMergeableBlocks() { return mergeable_blocks; }
+    void setMergeableBlocks(BlocksPtrs blocks) { mergeable_blocks = blocks; }
     std::shared_ptr<bool> getActivePtr() { return active_ptr; }
 
     /// Read new data blocks that store query result
@@ -193,12 +194,13 @@ public:
             {
                 mergeable_blocks = std::make_shared<std::vector<BlocksPtr>>();
                 BlocksPtr base_mergeable_blocks = std::make_shared<Blocks>();
-                InterpreterSelectQuery interpreter(live_view.getInnerQuery(), context, SelectQueryOptions(QueryProcessingStage::WithMergeableState), Names{});
+                InterpreterSelectQuery interpreter(live_view.getInnerQuery(), context, SelectQueryOptions(QueryProcessingStage::WithMergeableState), Names());
                 auto view_mergeable_stream = std::make_shared<MaterializingBlockInputStream>(
                     interpreter.execute().in);
                 while (Block this_block = view_mergeable_stream->read())
                     base_mergeable_blocks->push_back(this_block);
                 mergeable_blocks->push_back(base_mergeable_blocks);
+                live_view.setMergeableBlocks(mergeable_blocks);
             }
 
             /// Need make new mergeable block structure match the other mergeable blocks

From d87ed7f267becec342366b432613ef31932fb082 Mon Sep 17 00:00:00 2001
From: Vitaliy Zakaznikov <vzakaznikov@protonmail.com>
Date: Sun, 23 Jun 2019 09:51:29 -0400
Subject: [PATCH 053/107] * Adding max_live_view_insert_blocks_before_refresh
 setting   with default value of 64 * Updating writeIntoLiveView method to use
 max_live_view_insert_blocks_before_refresh   from global context instead of
 hard coded number * Adding squashing of the result blocks similar how it is
 done in materialized views * Fixing bug in writeIntoLiveView that caused
 incoming block to be processed twice   when maximum number of insert blocks
 was reached

---
 dbms/src/Core/Settings.h                      |   3 +-
 dbms/src/Storages/StorageLiveView.cpp         |   7 ++
 dbms/src/Storages/StorageLiveView.h           | 104 +++++++++---------
 .../0_stateless/00958_live_view_watch_live.py |   6 +
 4 files changed, 68 insertions(+), 52 deletions(-)

diff --git a/dbms/src/Core/Settings.h b/dbms/src/Core/Settings.h
index 5d29c50a9ac..0196e1e35ce 100644
--- a/dbms/src/Core/Settings.h
+++ b/dbms/src/Core/Settings.h
@@ -330,7 +330,8 @@ struct Settings : public SettingsCollection<Settings>
     M(SettingSeconds, live_view_heartbeat_interval, DEFAULT_LIVE_VIEW_HEARTBEAT_INTERVAL_SEC, "The heartbeat interval in seconds to indicate live query is alive.") \
     M(SettingSeconds, temporary_live_view_timeout, DEFAULT_TEMPORARY_LIVE_VIEW_TIMEOUT_SEC, "Timeout after which temporary live view is deleted.") \
     M(SettingSeconds, temporary_live_channel_timeout, DEFAULT_TEMPORARY_LIVE_CHANNEL_TIMEOUT_SEC, "Timeout after which temporary live channel is deleted.") \
-    M(SettingMilliseconds, alter_channel_wait_ms, DEFAULT_ALTER_LIVE_CHANNEL_WAIT_MS, "The wait time for alter channel request.")
+    M(SettingMilliseconds, alter_channel_wait_ms, DEFAULT_ALTER_LIVE_CHANNEL_WAIT_MS, "The wait time for alter channel request.") \
+    M(SettingUInt64, max_live_view_insert_blocks_before_refresh, 64, "Limit maximum number of inserted blocks after which mergeable blocks are dropped and query is re-executed.")
 
     DECLARE_SETTINGS_COLLECTION(LIST_OF_SETTINGS)
 
diff --git a/dbms/src/Storages/StorageLiveView.cpp b/dbms/src/Storages/StorageLiveView.cpp
index eecc7f6d1dc..0eb31acf1ae 100644
--- a/dbms/src/Storages/StorageLiveView.cpp
+++ b/dbms/src/Storages/StorageLiveView.cpp
@@ -197,6 +197,13 @@ bool StorageLiveView::getNewBlocks()
     auto proxy_storage = ProxyStorage::createProxyStorage(global_context.getTable(select_database_name, select_table_name), {from}, QueryProcessingStage::WithMergeableState);
     InterpreterSelectQuery select(inner_query->clone(), global_context, proxy_storage, SelectQueryOptions(QueryProcessingStage::Complete));
     BlockInputStreamPtr data = std::make_shared<MaterializingBlockInputStream>(select.execute().in);
+
+    /// Squashing is needed here because the view query can generate a lot of blocks
+    /// even when only one block is inserted into the parent table (e.g. if the query is a GROUP BY
+    /// and two-level aggregation is triggered).
+    data = std::make_shared<SquashingBlockInputStream>(
+        data, global_context.getSettingsRef().min_insert_block_size_rows, global_context.getSettingsRef().min_insert_block_size_bytes);
+
     while (Block block = data->read())
     {
         /// calculate hash before virtual column is added
diff --git a/dbms/src/Storages/StorageLiveView.h b/dbms/src/Storages/StorageLiveView.h
index 84a7ea80bca..3f2732647b3 100644
--- a/dbms/src/Storages/StorageLiveView.h
+++ b/dbms/src/Storages/StorageLiveView.h
@@ -17,6 +17,7 @@ limitations under the License. */
 #include <DataStreams/OneBlockInputStream.h>
 #include <DataStreams/BlocksBlockInputStream.h>
 #include <DataStreams/MaterializingBlockInputStream.h>
+#include <DataStreams/SquashingBlockInputStream.h>
 #include <DataStreams/copyData.h>
 #include <DataTypes/DataTypesNumber.h>
 #include <ext/shared_ptr_helper.h>
@@ -166,10 +167,42 @@ public:
             }
         }
 
+        bool is_block_processed = false;
         BlockInputStreams from;
-        BlocksPtr blocks = std::make_shared<Blocks>();
         BlocksPtrs mergeable_blocks;
         BlocksPtr new_mergeable_blocks = std::make_shared<Blocks>();
+
+        {
+            Poco::FastMutex::ScopedLock lock(live_view.mutex);
+
+            mergeable_blocks = live_view.getMergeableBlocks();
+            if (!mergeable_blocks || mergeable_blocks->size() >= context.getGlobalContext().getSettingsRef().max_live_view_insert_blocks_before_refresh)
+            {
+                mergeable_blocks = std::make_shared<std::vector<BlocksPtr>>();
+                BlocksPtr base_mergeable_blocks = std::make_shared<Blocks>();
+                InterpreterSelectQuery interpreter(live_view.getInnerQuery(), context, SelectQueryOptions(QueryProcessingStage::WithMergeableState), Names());
+                auto view_mergeable_stream = std::make_shared<MaterializingBlockInputStream>(
+                    interpreter.execute().in);
+                while (Block this_block = view_mergeable_stream->read())
+                    base_mergeable_blocks->push_back(this_block);
+                mergeable_blocks->push_back(base_mergeable_blocks);
+                live_view.setMergeableBlocks(mergeable_blocks);
+
+                /// Create from streams
+                for (auto & blocks_ : *mergeable_blocks)
+                {
+                    if (blocks_->empty())
+                        continue;
+                    auto sample_block = blocks_->front().cloneEmpty();
+                    BlockInputStreamPtr stream = std::make_shared<BlocksBlockInputStream>(std::make_shared<BlocksPtr>(blocks_), sample_block);
+                    from.push_back(std::move(stream));
+                }
+
+                is_block_processed = true;
+            }
+        }
+
+        if (!is_block_processed)
         {
             auto parent_storage = context.getTable(live_view.getSelectDatabaseName(), live_view.getSelectTableName());
             BlockInputStreams streams = {std::make_shared<OneBlockInputStream>(block)};
@@ -181,52 +214,26 @@ public:
                 select_block.execute().in);
             while (Block this_block = data_mergeable_stream->read())
                 new_mergeable_blocks->push_back(this_block);
-        }
 
-        if (new_mergeable_blocks->empty())
-            return;
+            if (new_mergeable_blocks->empty())
+                return;
 
-        {
-            Poco::FastMutex::ScopedLock lock(live_view.mutex);
-
-            mergeable_blocks = live_view.getMergeableBlocks();
-            if (!mergeable_blocks || mergeable_blocks->size() >= 64)
             {
-                mergeable_blocks = std::make_shared<std::vector<BlocksPtr>>();
-                BlocksPtr base_mergeable_blocks = std::make_shared<Blocks>();
-                InterpreterSelectQuery interpreter(live_view.getInnerQuery(), context, SelectQueryOptions(QueryProcessingStage::WithMergeableState), Names());
-                auto view_mergeable_stream = std::make_shared<MaterializingBlockInputStream>(
-                    interpreter.execute().in);
-                while (Block this_block = view_mergeable_stream->read())
-                    base_mergeable_blocks->push_back(this_block);
-                mergeable_blocks->push_back(base_mergeable_blocks);
-                live_view.setMergeableBlocks(mergeable_blocks);
-            }
+                Poco::FastMutex::ScopedLock lock(live_view.mutex);
 
-            /// Need make new mergeable block structure match the other mergeable blocks
-            if (!mergeable_blocks->front()->empty())
-            {
-                auto sample_block = mergeable_blocks->front()->front();
-                auto sample_new_block = new_mergeable_blocks->front();
-                for (auto col : sample_new_block)
+                mergeable_blocks = live_view.getMergeableBlocks();
+                mergeable_blocks->push_back(new_mergeable_blocks);
+
+                /// Create from streams
+                for (auto & blocks_ : *mergeable_blocks)
                 {
-                    for (auto & new_block : *new_mergeable_blocks)
-                    {
-                        if (!sample_block.has(col.name))
-                            new_block.erase(col.name);
-                    }
+                    if (blocks_->empty())
+                        continue;
+                    auto sample_block = blocks_->front().cloneEmpty();
+                    BlockInputStreamPtr stream = std::make_shared<BlocksBlockInputStream>(std::make_shared<BlocksPtr>(blocks_), sample_block);
+                    from.push_back(std::move(stream));
                 }
             }
-
-            mergeable_blocks->push_back(new_mergeable_blocks);
-
-            /// Create from blocks streams
-            for (auto & blocks_ : *mergeable_blocks)
-            {
-                auto sample_block = mergeable_blocks->front()->front().cloneEmpty();
-                BlockInputStreamPtr stream = std::make_shared<BlocksBlockInputStream>(std::make_shared<BlocksPtr>(blocks_), sample_block);
-                from.push_back(std::move(stream));
-            }
         }
 
         auto parent_storage = context.getTable(live_view.getSelectDatabaseName(), live_view.getSelectTableName());
@@ -234,18 +241,13 @@ public:
         InterpreterSelectQuery select(live_view.getInnerQuery(), context, proxy_storage, QueryProcessingStage::Complete);
         BlockInputStreamPtr data = std::make_shared<MaterializingBlockInputStream>(select.execute().in);
 
-        while (Block this_block = data->read())
-        {
-            blocks->push_back(this_block);
-        }
+        /// Squashing is needed here because the view query can generate a lot of blocks
+        /// even when only one block is inserted into the parent table (e.g. if the query is a GROUP BY
+        /// and two-level aggregation is triggered).
+        data = std::make_shared<SquashingBlockInputStream>(
+            data, context.getGlobalContext().getSettingsRef().min_insert_block_size_rows, context.getGlobalContext().getSettingsRef().min_insert_block_size_bytes);
 
-        if (blocks->empty())
-            return;
-
-        auto sample_block = blocks->front().cloneEmpty();
-        BlockInputStreamPtr new_data = std::make_shared<BlocksBlockInputStream>(std::make_shared<BlocksPtr>(blocks), sample_block);
-
-        copyData(*new_data, *output);
+        copyData(*data, *output);
     }
 
 private:
diff --git a/dbms/tests/queries/0_stateless/00958_live_view_watch_live.py b/dbms/tests/queries/0_stateless/00958_live_view_watch_live.py
index 7cbea5fbff6..33cc9db3ccc 100755
--- a/dbms/tests/queries/0_stateless/00958_live_view_watch_live.py
+++ b/dbms/tests/queries/0_stateless/00958_live_view_watch_live.py
@@ -28,8 +28,14 @@ with client(name='client1>', log=log) as client1, client(name='client2>', log=lo
     client1.expect(r'0.*1' + end_of_block)
     client2.send('INSERT INTO test.mt VALUES (1),(2),(3)')
     client1.expect(r'6.*2' + end_of_block)
+    client2.expect(prompt)
     client2.send('INSERT INTO test.mt VALUES (4),(5),(6)')
     client1.expect(r'21.*3' + end_of_block)
+    client2.expect(prompt)
+    for i in range(1,129):
+       client2.send('INSERT INTO test.mt VALUES (1)')
+       client1.expect(r'%d.*%d' % (21+i, 3+i) + end_of_block)
+       client2.expect(prompt)
     # send Ctrl-C
     os.kill(client1.process.pid, signal.SIGINT)
     client1.expect(prompt)

From 259a95a3da5ca6ad05d0cbc11f82682258f00576 Mon Sep 17 00:00:00 2001
From: Vitaliy Zakaznikov <vzakaznikov@protonmail.com>
Date: Sun, 7 Jul 2019 19:57:58 -0400
Subject: [PATCH 054/107] * Updates to fix issues after the merge

---
 dbms/src/Interpreters/ExternalLoader.cpp | 7 +++++++
 dbms/src/Storages/IStorage.h             | 4 ++--
 2 files changed, 9 insertions(+), 2 deletions(-)

diff --git a/dbms/src/Interpreters/ExternalLoader.cpp b/dbms/src/Interpreters/ExternalLoader.cpp
index 018565e0a2c..f00fa2bfa90 100644
--- a/dbms/src/Interpreters/ExternalLoader.cpp
+++ b/dbms/src/Interpreters/ExternalLoader.cpp
@@ -400,6 +400,10 @@ public:
         return count;
     }
 
+#if !__clang__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wunused-variable"
+#endif
     bool hasCurrentlyLoadedObjects() const
     {
         std::lock_guard lock{mutex};
@@ -408,6 +412,9 @@ public:
                 return true;
         return false;
     }
+#if !__clang__
+#pragma GCC diagnostic pop
+#endif
 
     /// Starts loading of a specified object.
     void load(const String & name)
diff --git a/dbms/src/Storages/IStorage.h b/dbms/src/Storages/IStorage.h
index 8541def8753..b7358c3fc6e 100644
--- a/dbms/src/Storages/IStorage.h
+++ b/dbms/src/Storages/IStorage.h
@@ -84,7 +84,8 @@ public:
 
 public: /// thread-unsafe part. lockStructure must be acquired
     virtual const ColumnsDescription & getColumns() const; /// returns combined set of columns
-
+    virtual void setColumns(ColumnsDescription columns_); /// sets only real columns, possibly overwrites virtual ones.
+    
     const IndicesDescription & getIndices() const;
 
     /// NOTE: these methods should include virtual columns,
@@ -113,7 +114,6 @@ public: /// thread-unsafe part. lockStructure must be acquired
     void check(const Block & block, bool need_all = false) const;
 
 protected: /// still thread-unsafe part.
-    virtual void setColumns(ColumnsDescription columns_); /// sets only real columns, possibly overwrites virtual ones.
     void setIndices(IndicesDescription indices_);
 
     /// Returns whether the column is virtual - by default all columns are real.

From a80af666adbcbeb173b5dd125a72439b55b92c25 Mon Sep 17 00:00:00 2001
From: Vitaliy Zakaznikov <vzakaznikov@protonmail.com>
Date: Tue, 9 Jul 2019 08:41:55 -0400
Subject: [PATCH 055/107] * Updates that incorporate comments from the review

---
 dbms/src/DataStreams/BlocksBlockInputStream.h |  6 +--
 .../DataStreams/LiveViewBlockInputStream.h    | 47 +++++++++----------
 .../LiveViewEventsBlockInputStream.h          | 46 ++++++++++--------
 dbms/src/Storages/IStorage.h                  |  2 +-
 dbms/src/Storages/StorageLiveView.cpp         | 13 +++--
 dbms/src/Storages/StorageLiveView.h           |  2 +-
 6 files changed, 62 insertions(+), 54 deletions(-)

diff --git a/dbms/src/DataStreams/BlocksBlockInputStream.h b/dbms/src/DataStreams/BlocksBlockInputStream.h
index ad0d37da622..58a63e5b85e 100644
--- a/dbms/src/DataStreams/BlocksBlockInputStream.h
+++ b/dbms/src/DataStreams/BlocksBlockInputStream.h
@@ -23,8 +23,8 @@ class BlocksBlockInputStream : public IBlockInputStream
 {
 public:
     /// Acquires shared ownership of the blocks vector
-    BlocksBlockInputStream(std::shared_ptr<BlocksPtr> blocks_ptr_, Block header)
-        : blocks_ptr(blocks_ptr_), it((*blocks_ptr_)->begin()), end((*blocks_ptr_)->end()), header(header) {}
+    BlocksBlockInputStream(const std::shared_ptr<BlocksPtr> & blocks_ptr_, Block header)
+        : blocks(*blocks_ptr_), it((*blocks_ptr_)->begin()), end((*blocks_ptr_)->end()), header(std::move(header)) {}
 
     String getName() const override { return "Blocks"; }
 
@@ -42,7 +42,7 @@ protected:
     }
 
 private:
-    std::shared_ptr<BlocksPtr> blocks_ptr;
+    BlocksPtr blocks;
     Blocks::iterator it;
     const Blocks::iterator end;
     Block header;
diff --git a/dbms/src/DataStreams/LiveViewBlockInputStream.h b/dbms/src/DataStreams/LiveViewBlockInputStream.h
index e9bb599a1d6..89ac5e4f9f3 100644
--- a/dbms/src/DataStreams/LiveViewBlockInputStream.h
+++ b/dbms/src/DataStreams/LiveViewBlockInputStream.h
@@ -23,9 +23,10 @@ limitations under the License. */
 namespace DB
 {
 
-/**
-  */
-
+/** Implements LIVE VIEW table WATCH input stream.
+ *  Keeps stream alive by outputing blocks with no rows
+ *  based on period specified by the heartbeat interval.
+ */
 class LiveViewBlockInputStream : public IBlockInputStream
 {
 
@@ -37,18 +38,17 @@ public:
         /// Start storage no users thread
         /// if we are the last active user
         if (!storage->is_dropped && blocks_ptr.use_count() < 3)
-            storage->startNoUsersThread(temporary_live_view_timeout);
+            storage->startNoUsersThread(temporary_live_view_timeout_sec);
     }
-    /// length default -2 because we want LIMIT to specify number of updates so that LIMIT 1 waits for 1 update
-    /// and LIMIT 0 just returns data without waiting for any updates
+
     LiveViewBlockInputStream(std::shared_ptr<StorageLiveView> storage_,
         std::shared_ptr<BlocksPtr> blocks_ptr_,
         std::shared_ptr<BlocksMetadataPtr> blocks_metadata_ptr_,
         std::shared_ptr<bool> active_ptr_,
-        int64_t length_, const UInt64 & heartbeat_interval_,
-        const UInt64 & temporary_live_view_timeout_)
-        : storage(storage_), blocks_ptr(blocks_ptr_), blocks_metadata_ptr(blocks_metadata_ptr_), active_ptr(active_ptr_), length(length_ + 1), heartbeat_interval(heartbeat_interval_ * 1000000), temporary_live_view_timeout(temporary_live_view_timeout_),
-        blocks_hash("")
+        const bool has_limit_, const UInt64 limit_,
+        const UInt64 heartbeat_interval_sec_,
+        const UInt64 temporary_live_view_timeout_sec_)
+        : storage(std::move(storage_)), blocks_ptr(std::move(blocks_ptr_)), blocks_metadata_ptr(std::move(blocks_metadata_ptr_)), active_ptr(std::move(active_ptr_)), has_limit(has_limit_), limit(limit_), heartbeat_interval_usec(heartbeat_interval_sec_ * 1000000), temporary_live_view_timeout_sec(temporary_live_view_timeout_sec_)
     {
         /// grab active pointer
         active = active_ptr.lock();
@@ -70,7 +70,7 @@ public:
     void refresh()
     {
         if (active && blocks && it == end)
-            it =  blocks->begin();
+            it = blocks->begin();
     }
 
     void suspend()
@@ -111,7 +111,7 @@ protected:
     {
         Block res;
 
-        if (length == 0)
+        if (has_limit && num_updates == (Int64)limit)
         {
             return { Block(), true };
         }
@@ -162,7 +162,7 @@ protected:
                     while (true)
                     {
                         UInt64 timestamp_usec = static_cast<UInt64>(timestamp.epochMicroseconds());
-                        bool signaled = storage->condition.tryWait(storage->mutex, std::max(static_cast<UInt64>(0), heartbeat_interval - (timestamp_usec - last_event_timestamp)) / 1000);
+                        bool signaled = storage->condition.tryWait(storage->mutex, std::max(static_cast<UInt64>(0), heartbeat_interval_usec - (timestamp_usec - last_event_timestamp_usec)) / 1000);
 
                         if (isCancelled() || storage->is_dropped)
                         {
@@ -175,7 +175,7 @@ protected:
                         else
                         {
                             // heartbeat
-                            last_event_timestamp = static_cast<UInt64>(timestamp.epochMicroseconds());
+                            last_event_timestamp_usec = static_cast<UInt64>(timestamp.epochMicroseconds());
                             return { getHeader(), true };
                         }
                     }
@@ -191,11 +191,10 @@ protected:
         if (it == end)
         {
             end_of_blocks = false;
-            if (length > 0)
-                --length;
+            num_updates += 1;
         }
 
-        last_event_timestamp = static_cast<UInt64>(timestamp.epochMicroseconds());
+        last_event_timestamp_usec = static_cast<UInt64>(timestamp.epochMicroseconds());
         return { res, true };
     }
 
@@ -210,13 +209,13 @@ private:
     Blocks::iterator it;
     Blocks::iterator end;
     Blocks::iterator begin;
-    /// Length specifies number of updates to send, default -1 (no limit)
-    int64_t length;
-    bool end_of_blocks{0};
-    UInt64 heartbeat_interval;
-    UInt64 temporary_live_view_timeout;
-    String blocks_hash;
-    UInt64 last_event_timestamp{0};
+    const bool has_limit;
+    const UInt64 limit;
+    Int64 num_updates = -1;
+    bool end_of_blocks = false;
+    UInt64 heartbeat_interval_usec;
+    UInt64 temporary_live_view_timeout_sec;
+    UInt64 last_event_timestamp_usec = 0;
     Poco::Timestamp timestamp;
 };
 
diff --git a/dbms/src/DataStreams/LiveViewEventsBlockInputStream.h b/dbms/src/DataStreams/LiveViewEventsBlockInputStream.h
index 75e68b15d92..fa97ae2e7f5 100644
--- a/dbms/src/DataStreams/LiveViewEventsBlockInputStream.h
+++ b/dbms/src/DataStreams/LiveViewEventsBlockInputStream.h
@@ -27,9 +27,10 @@ limitations under the License. */
 namespace DB
 {
 
-/**
-  */
-
+/** Implements LIVE VIEW table WATCH EVENTS input stream.
+ *  Keeps stream alive by outputing blocks with no rows
+ *  based on period specified by the heartbeat interval.
+ */
 class LiveViewEventsBlockInputStream : public IBlockInputStream
 {
 
@@ -41,13 +42,18 @@ public:
         /// Start storage no users thread
         /// if we are the last active user
         if (!storage->is_dropped && blocks_ptr.use_count() < 3)
-            storage->startNoUsersThread(temporary_live_view_timeout);
+            storage->startNoUsersThread(temporary_live_view_timeout_sec);
     }
     /// length default -2 because we want LIMIT to specify number of updates so that LIMIT 1 waits for 1 update
     /// and LIMIT 0 just returns data without waiting for any updates
-    LiveViewEventsBlockInputStream(std::shared_ptr<StorageLiveView> storage_, std::shared_ptr<BlocksPtr> blocks_ptr_, std::shared_ptr<BlocksMetadataPtr> blocks_metadata_ptr_, std::shared_ptr<bool> active_ptr_,
-        int64_t length_, const UInt64 & heartbeat_interval_, const UInt64 & temporary_live_view_timeout_)
-        : storage(storage_), blocks_ptr(blocks_ptr_), blocks_metadata_ptr(blocks_metadata_ptr_), active_ptr(active_ptr_), length(length_ + 1), heartbeat_interval(heartbeat_interval_ * 1000000), temporary_live_view_timeout(temporary_live_view_timeout_)
+    LiveViewEventsBlockInputStream(std::shared_ptr<StorageLiveView> storage_,
+        std::shared_ptr<BlocksPtr> blocks_ptr_,
+        std::shared_ptr<BlocksMetadataPtr> blocks_metadata_ptr_,
+        std::shared_ptr<bool> active_ptr_,
+        const bool has_limit_, const UInt64 limit_,
+        const UInt64 heartbeat_interval_sec_,
+        const UInt64 temporary_live_view_timeout_sec_)
+        : storage(std::move(storage_)), blocks_ptr(std::move(blocks_ptr_)), blocks_metadata_ptr(std::move(blocks_metadata_ptr_)), active_ptr(std::move(active_ptr_)), has_limit(has_limit_), limit(limit_), heartbeat_interval_usec(heartbeat_interval_sec_ * 1000000), temporary_live_view_timeout_sec(temporary_live_view_timeout_sec_)
     {
         /// grab active pointer
         active = active_ptr.lock();
@@ -72,7 +78,7 @@ public:
     void refresh()
     {
         if (active && blocks && it == end)
-            it =  blocks->begin();
+            it = blocks->begin();
     }
 
     void suspend()
@@ -124,7 +130,7 @@ protected:
      */
     NonBlockingResult tryRead_(bool blocking)
     {
-        if (length == 0)
+        if (has_limit && num_updates == (Int64)limit)
         {
             return { Block(), true };
         }
@@ -177,7 +183,7 @@ protected:
                     while (true)
                     {
                         UInt64 timestamp_usec = static_cast<UInt64>(timestamp.epochMicroseconds());
-                        bool signaled = storage->condition.tryWait(storage->mutex, std::max(static_cast<UInt64>(0), heartbeat_interval - (timestamp_usec - last_event_timestamp)) / 1000);
+                        bool signaled = storage->condition.tryWait(storage->mutex, std::max(static_cast<UInt64>(0), heartbeat_interval_usec - (timestamp_usec - last_event_timestamp_usec)) / 1000);
 
                         if (isCancelled() || storage->is_dropped)
                         {
@@ -190,7 +196,7 @@ protected:
                         else
                         {
                             // repeat the event block as a heartbeat
-                            last_event_timestamp = static_cast<UInt64>(timestamp.epochMicroseconds());
+                            last_event_timestamp_usec = static_cast<UInt64>(timestamp.epochMicroseconds());
                             return { getHeader(), true };
                         }
                     }
@@ -205,11 +211,10 @@ protected:
         if (it == end)
         {
             end_of_blocks = false;
-            if (length > 0)
-                --length;
+            num_updates += 1;
         }
 
-        last_event_timestamp = static_cast<UInt64>(timestamp.epochMicroseconds());
+        last_event_timestamp_usec = static_cast<UInt64>(timestamp.epochMicroseconds());
 
         return { getEventBlock(), true };
     }
@@ -225,12 +230,13 @@ private:
     Blocks::iterator it;
     Blocks::iterator end;
     Blocks::iterator begin;
-    /// Length specifies number of updates to send, default -1 (no limit)
-    int64_t length;
-    bool end_of_blocks{0};
-    UInt64 heartbeat_interval;
-    UInt64 temporary_live_view_timeout;
-    UInt64 last_event_timestamp{0};
+    const bool has_limit;
+    const UInt64 limit;
+    Int64 num_updates = -1;
+    bool end_of_blocks = false;
+    UInt64 heartbeat_interval_usec;
+    UInt64 temporary_live_view_timeout_sec;
+    UInt64 last_event_timestamp_usec = 0;
     Poco::Timestamp timestamp;
 };
 
diff --git a/dbms/src/Storages/IStorage.h b/dbms/src/Storages/IStorage.h
index b7358c3fc6e..0d13a63a214 100644
--- a/dbms/src/Storages/IStorage.h
+++ b/dbms/src/Storages/IStorage.h
@@ -85,7 +85,7 @@ public:
 public: /// thread-unsafe part. lockStructure must be acquired
     virtual const ColumnsDescription & getColumns() const; /// returns combined set of columns
     virtual void setColumns(ColumnsDescription columns_); /// sets only real columns, possibly overwrites virtual ones.
-    
+
     const IndicesDescription & getIndices() const;
 
     /// NOTE: these methods should include virtual columns,
diff --git a/dbms/src/Storages/StorageLiveView.cpp b/dbms/src/Storages/StorageLiveView.cpp
index 0eb31acf1ae..df7f8c896b3 100644
--- a/dbms/src/Storages/StorageLiveView.cpp
+++ b/dbms/src/Storages/StorageLiveView.cpp
@@ -407,15 +407,18 @@ BlockInputStreams StorageLiveView::watch(
 {
     ASTWatchQuery & query = typeid_cast<ASTWatchQuery &>(*query_info.query);
 
-    /// By default infinite stream of updates
-    int64_t length = -2;
+    bool has_limit = false;
+    UInt64 limit = 0;
 
     if (query.limit_length)
-        length = static_cast<int64_t>(safeGet<UInt64>(typeid_cast<ASTLiteral &>(*query.limit_length).value));
+    {
+        has_limit = true;
+        limit = safeGet<UInt64>(typeid_cast<ASTLiteral &>(*query.limit_length).value);
+    }
 
     if (query.is_watch_events)
     {
-        auto reader = std::make_shared<LiveViewEventsBlockInputStream>(std::static_pointer_cast<StorageLiveView>(shared_from_this()), blocks_ptr, blocks_metadata_ptr, active_ptr, length, context.getSettingsRef().live_view_heartbeat_interval.totalSeconds(),
+        auto reader = std::make_shared<LiveViewEventsBlockInputStream>(std::static_pointer_cast<StorageLiveView>(shared_from_this()), blocks_ptr, blocks_metadata_ptr, active_ptr, has_limit, limit, context.getSettingsRef().live_view_heartbeat_interval.totalSeconds(),
         context.getSettingsRef().temporary_live_view_timeout.totalSeconds());
 
         if (no_users_thread.joinable())
@@ -440,7 +443,7 @@ BlockInputStreams StorageLiveView::watch(
     }
     else
     {
-        auto reader = std::make_shared<LiveViewBlockInputStream>(std::static_pointer_cast<StorageLiveView>(shared_from_this()), blocks_ptr, blocks_metadata_ptr, active_ptr, length, context.getSettingsRef().live_view_heartbeat_interval.totalSeconds(),
+        auto reader = std::make_shared<LiveViewBlockInputStream>(std::static_pointer_cast<StorageLiveView>(shared_from_this()), blocks_ptr, blocks_metadata_ptr, active_ptr, has_limit, limit, context.getSettingsRef().live_view_heartbeat_interval.totalSeconds(),
         context.getSettingsRef().temporary_live_view_timeout.totalSeconds());
 
         if (no_users_thread.joinable())
diff --git a/dbms/src/Storages/StorageLiveView.h b/dbms/src/Storages/StorageLiveView.h
index 3f2732647b3..6bff9c2dc85 100644
--- a/dbms/src/Storages/StorageLiveView.h
+++ b/dbms/src/Storages/StorageLiveView.h
@@ -78,7 +78,7 @@ public:
         return blocks_ptr.use_count() > 1;
     }
 
-    /// Check we we have any active readers
+    /// Check we have any active readers
     /// must be called with mutex locked
     bool hasActiveUsers()
     {

From c84fd80345d76f648e9c8f1463c9b4210d08c5be Mon Sep 17 00:00:00 2001
From: Vitaliy Zakaznikov <vzakaznikov@protonmail.com>
Date: Tue, 9 Jul 2019 22:06:29 -0400
Subject: [PATCH 056/107] * Fixing clang build by converting old style cast
 (Int64) to static_cast<Int64>.

---
 dbms/src/DataStreams/LiveViewBlockInputStream.h       | 2 +-
 dbms/src/DataStreams/LiveViewEventsBlockInputStream.h | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/dbms/src/DataStreams/LiveViewBlockInputStream.h b/dbms/src/DataStreams/LiveViewBlockInputStream.h
index 89ac5e4f9f3..b3756c9ff6d 100644
--- a/dbms/src/DataStreams/LiveViewBlockInputStream.h
+++ b/dbms/src/DataStreams/LiveViewBlockInputStream.h
@@ -111,7 +111,7 @@ protected:
     {
         Block res;
 
-        if (has_limit && num_updates == (Int64)limit)
+        if (has_limit && num_updates == static_cast<Int64>(limit))
         {
             return { Block(), true };
         }
diff --git a/dbms/src/DataStreams/LiveViewEventsBlockInputStream.h b/dbms/src/DataStreams/LiveViewEventsBlockInputStream.h
index fa97ae2e7f5..93fb6a76372 100644
--- a/dbms/src/DataStreams/LiveViewEventsBlockInputStream.h
+++ b/dbms/src/DataStreams/LiveViewEventsBlockInputStream.h
@@ -130,7 +130,7 @@ protected:
      */
     NonBlockingResult tryRead_(bool blocking)
     {
-        if (has_limit && num_updates == (Int64)limit)
+        if (has_limit && num_updates == static_cast<Int64>(limit))
         {
             return { Block(), true };
         }

From 9c5514135d689c77036850afed38f48f81ad0134 Mon Sep 17 00:00:00 2001
From: Vitaliy Zakaznikov <vzakaznikov@protonmail.com>
Date: Tue, 9 Jul 2019 23:27:19 -0400
Subject: [PATCH 057/107] * Updating tests to send Ctrl-C instead of SIGINT
 signal to abort WATCH query * Updating client.py to start commands inside
 shell * Removing test code from uexpect.py

---
 .../00960_live_view_watch_events_live.py       |  2 +-
 .../00962_temporary_live_view_watch_live.py    |  2 +-
 ...3_temporary_live_view_watch_live_timeout.py |  2 +-
 .../00964_live_view_watch_events_heartbeat.py  |  2 +-
 .../00965_live_view_watch_heartbeat.py         |  2 +-
 .../0_stateless/00979_live_view_watch_live.py  |  2 +-
 .../queries/0_stateless/helpers/client.py      |  7 ++++---
 .../queries/0_stateless/helpers/uexpect.py     | 18 ------------------
 8 files changed, 10 insertions(+), 27 deletions(-)

diff --git a/dbms/tests/queries/0_stateless/00960_live_view_watch_events_live.py b/dbms/tests/queries/0_stateless/00960_live_view_watch_events_live.py
index 44b8df185b1..5f2d7c90da7 100755
--- a/dbms/tests/queries/0_stateless/00960_live_view_watch_events_live.py
+++ b/dbms/tests/queries/0_stateless/00960_live_view_watch_events_live.py
@@ -31,7 +31,7 @@ with client(name='client1>', log=log) as client1, client(name='client2>', log=lo
     client2.send('INSERT INTO test.mt VALUES (4),(5),(6)')
     client1.expect('3.*' + end_of_block)
     # send Ctrl-C
-    os.kill(client1.process.pid, signal.SIGINT)
+    client1.send('\x03', eol='')
     client1.expect(prompt)
     client1.send('DROP TABLE test.lv')
     client1.expect(prompt)
diff --git a/dbms/tests/queries/0_stateless/00962_temporary_live_view_watch_live.py b/dbms/tests/queries/0_stateless/00962_temporary_live_view_watch_live.py
index d4d35548d68..d3c6e4cb6cf 100755
--- a/dbms/tests/queries/0_stateless/00962_temporary_live_view_watch_live.py
+++ b/dbms/tests/queries/0_stateless/00962_temporary_live_view_watch_live.py
@@ -31,7 +31,7 @@ with client(name='client1>', log=log) as client1, client(name='client2>', log=lo
     client2.send('INSERT INTO test.mt VALUES (4),(5),(6)')
     client1.expect(r'21.*3' + end_of_block)
     # send Ctrl-C
-    os.kill(client1.process.pid, signal.SIGINT)
+    client1.send('\x03', eol='')
     client1.expect(prompt)
     client1.send('DROP TABLE test.lv')
     client1.expect(prompt)
diff --git a/dbms/tests/queries/0_stateless/00963_temporary_live_view_watch_live_timeout.py b/dbms/tests/queries/0_stateless/00963_temporary_live_view_watch_live_timeout.py
index 2008368f12e..28c1c027017 100755
--- a/dbms/tests/queries/0_stateless/00963_temporary_live_view_watch_live_timeout.py
+++ b/dbms/tests/queries/0_stateless/00963_temporary_live_view_watch_live_timeout.py
@@ -35,7 +35,7 @@ with client(name='client1>', log=log) as client1, client(name='client2>', log=lo
     client2.expect(prompt)
     client1.expect(r'21.*3' + end_of_block)
     # send Ctrl-C
-    os.kill(client1.process.pid, signal.SIGINT)
+    client1.send('\x03', eol='')
     client1.expect(prompt)
     client1.send('SELECT sleep(1)')
     client1.expect(prompt)
diff --git a/dbms/tests/queries/0_stateless/00964_live_view_watch_events_heartbeat.py b/dbms/tests/queries/0_stateless/00964_live_view_watch_events_heartbeat.py
index cecae7c5a72..5db6a6c13aa 100755
--- a/dbms/tests/queries/0_stateless/00964_live_view_watch_events_heartbeat.py
+++ b/dbms/tests/queries/0_stateless/00964_live_view_watch_events_heartbeat.py
@@ -33,7 +33,7 @@ with client(name='client1>', log=log) as client1, client(name='client2>', log=lo
     # wait for heartbeat
     client1.expect('Progress: 2.00 rows.*\)')
     # send Ctrl-C
-    os.kill(client1.process.pid, signal.SIGINT)
+    client1.send('\x03', eol='')
     client1.expect(prompt)
     client1.send('DROP TABLE test.lv')
     client1.expect(prompt)
diff --git a/dbms/tests/queries/0_stateless/00965_live_view_watch_heartbeat.py b/dbms/tests/queries/0_stateless/00965_live_view_watch_heartbeat.py
index b2bd84e0742..f024f3f1008 100755
--- a/dbms/tests/queries/0_stateless/00965_live_view_watch_heartbeat.py
+++ b/dbms/tests/queries/0_stateless/00965_live_view_watch_heartbeat.py
@@ -34,7 +34,7 @@ with client(name='client1>', log=log) as client1, client(name='client2>', log=lo
     # wait for heartbeat
     client1.expect('Progress: 2.00 rows.*\)')
     # send Ctrl-C
-    os.kill(client1.process.pid, signal.SIGINT)
+    client1.send('\x03', eol='')
     client1.expect(prompt)
     client1.send('DROP TABLE test.lv')
     client1.expect(prompt)
diff --git a/dbms/tests/queries/0_stateless/00979_live_view_watch_live.py b/dbms/tests/queries/0_stateless/00979_live_view_watch_live.py
index 33cc9db3ccc..e5e44284959 100755
--- a/dbms/tests/queries/0_stateless/00979_live_view_watch_live.py
+++ b/dbms/tests/queries/0_stateless/00979_live_view_watch_live.py
@@ -37,7 +37,7 @@ with client(name='client1>', log=log) as client1, client(name='client2>', log=lo
        client1.expect(r'%d.*%d' % (21+i, 3+i) + end_of_block)
        client2.expect(prompt)
     # send Ctrl-C
-    os.kill(client1.process.pid, signal.SIGINT)
+    client1.send('\x03', eol='')
     client1.expect(prompt)
     client1.send('DROP TABLE test.lv')
     client1.expect(prompt)
diff --git a/dbms/tests/queries/0_stateless/helpers/client.py b/dbms/tests/queries/0_stateless/helpers/client.py
index dec7eca7d78..b8f0dec46ad 100644
--- a/dbms/tests/queries/0_stateless/helpers/client.py
+++ b/dbms/tests/queries/0_stateless/helpers/client.py
@@ -11,11 +11,12 @@ prompt = ':\) '
 end_of_block = r'.*\r\n.*\r\n'
 
 def client(command=None, name='', log=None):
+    client = uexpect.spawn(['/bin/bash','--noediting'])
     if command is None:
-        client = uexpect.spawn(os.environ.get('CLICKHOUSE_BINARY', 'clickhouse') + '-client')
-    else:
-        client = uexpect.spawn(command)
+        command = os.environ.get('CLICKHOUSE_BINARY', 'clickhouse') + '-client'
     client.eol('\r')
     client.logger(log, prefix=name)
     client.timeout(20)
+    client.expect('[#\$] ', timeout=2)
+    client.send(command)
     return client
diff --git a/dbms/tests/queries/0_stateless/helpers/uexpect.py b/dbms/tests/queries/0_stateless/helpers/uexpect.py
index 2f323cf6ca6..d65190e2b29 100644
--- a/dbms/tests/queries/0_stateless/helpers/uexpect.py
+++ b/dbms/tests/queries/0_stateless/helpers/uexpect.py
@@ -202,21 +202,3 @@ def reader(process, out, queue, kill_event):
             if e.errno == 5 and kill_event.is_set():
                 break
             raise
-
-if __name__ == '__main__':
-   io = spawn(['/bin/bash','--noediting'])
-   prompt = '\$ '
-   io.logger(sys.stdout)
-   io.timeout(2)
-   io.eol('\r')
-
-   io.expect(prompt)
-   io.send('clickhouse-client')
-   prompt = ':\) '
-   io.expect(prompt)
-   io.send('SELECT 1')
-   io.expect(prompt)
-   io.send('SHOW TABLES')
-   io.expect('.*\r\n.*')
-   io.expect(prompt)
-   io.close()

From 280025d5b4931205d3186d055ed69c2ccfe9685e Mon Sep 17 00:00:00 2001
From: Vitaliy Zakaznikov <vzakaznikov@protonmail.com>
Date: Wed, 10 Jul 2019 08:22:31 -0400
Subject: [PATCH 058/107] * Updating live view tests to workaround an issue
 with clickhouse-client exiting when   Ctrl-C is pressed during WATCH query
 execution instead of going to the   client prompt.

---
 .../queries/0_stateless/00960_live_view_watch_events_live.py | 5 ++++-
 .../0_stateless/00962_temporary_live_view_watch_live.py      | 5 ++++-
 .../00963_temporary_live_view_watch_live_timeout.py          | 5 ++++-
 .../0_stateless/00964_live_view_watch_events_heartbeat.py    | 5 ++++-
 .../queries/0_stateless/00965_live_view_watch_heartbeat.py   | 5 ++++-
 dbms/tests/queries/0_stateless/00979_live_view_watch_live.py | 5 ++++-
 dbms/tests/queries/0_stateless/helpers/client.py             | 1 +
 7 files changed, 25 insertions(+), 6 deletions(-)

diff --git a/dbms/tests/queries/0_stateless/00960_live_view_watch_events_live.py b/dbms/tests/queries/0_stateless/00960_live_view_watch_events_live.py
index 5f2d7c90da7..b7fc3f4e3a6 100755
--- a/dbms/tests/queries/0_stateless/00960_live_view_watch_events_live.py
+++ b/dbms/tests/queries/0_stateless/00960_live_view_watch_events_live.py
@@ -32,7 +32,10 @@ with client(name='client1>', log=log) as client1, client(name='client2>', log=lo
     client1.expect('3.*' + end_of_block)
     # send Ctrl-C
     client1.send('\x03', eol='')
-    client1.expect(prompt)
+    match = client1.expect('(%s)|([#\$] )' % prompt)
+    if match.groups()[1]:
+        client1.send(client1.command)
+        client1.expect(prompt)
     client1.send('DROP TABLE test.lv')
     client1.expect(prompt)
     client1.send('DROP TABLE test.mt')
diff --git a/dbms/tests/queries/0_stateless/00962_temporary_live_view_watch_live.py b/dbms/tests/queries/0_stateless/00962_temporary_live_view_watch_live.py
index d3c6e4cb6cf..f27b1213c70 100755
--- a/dbms/tests/queries/0_stateless/00962_temporary_live_view_watch_live.py
+++ b/dbms/tests/queries/0_stateless/00962_temporary_live_view_watch_live.py
@@ -32,7 +32,10 @@ with client(name='client1>', log=log) as client1, client(name='client2>', log=lo
     client1.expect(r'21.*3' + end_of_block)
     # send Ctrl-C
     client1.send('\x03', eol='')
-    client1.expect(prompt)
+    match = client1.expect('(%s)|([#\$] )' % prompt)
+    if match.groups()[1]:
+        client1.send(client1.command)
+        client1.expect(prompt)
     client1.send('DROP TABLE test.lv')
     client1.expect(prompt)
     client1.send('DROP TABLE test.mt')
diff --git a/dbms/tests/queries/0_stateless/00963_temporary_live_view_watch_live_timeout.py b/dbms/tests/queries/0_stateless/00963_temporary_live_view_watch_live_timeout.py
index 28c1c027017..df627c84e49 100755
--- a/dbms/tests/queries/0_stateless/00963_temporary_live_view_watch_live_timeout.py
+++ b/dbms/tests/queries/0_stateless/00963_temporary_live_view_watch_live_timeout.py
@@ -36,7 +36,10 @@ with client(name='client1>', log=log) as client1, client(name='client2>', log=lo
     client1.expect(r'21.*3' + end_of_block)
     # send Ctrl-C
     client1.send('\x03', eol='')
-    client1.expect(prompt)
+    match = client1.expect('(%s)|([#\$] )' % prompt)
+    if match.groups()[1]:
+        client1.send(client1.command)
+        client1.expect(prompt)
     client1.send('SELECT sleep(1)')
     client1.expect(prompt)
     client1.send('DROP TABLE test.lv')
diff --git a/dbms/tests/queries/0_stateless/00964_live_view_watch_events_heartbeat.py b/dbms/tests/queries/0_stateless/00964_live_view_watch_events_heartbeat.py
index 5db6a6c13aa..5664c0e6c6d 100755
--- a/dbms/tests/queries/0_stateless/00964_live_view_watch_events_heartbeat.py
+++ b/dbms/tests/queries/0_stateless/00964_live_view_watch_events_heartbeat.py
@@ -34,7 +34,10 @@ with client(name='client1>', log=log) as client1, client(name='client2>', log=lo
     client1.expect('Progress: 2.00 rows.*\)')
     # send Ctrl-C
     client1.send('\x03', eol='')
-    client1.expect(prompt)
+    match = client1.expect('(%s)|([#\$] )' % prompt)
+    if match.groups()[1]:
+        client1.send(client1.command)
+        client1.expect(prompt)    
     client1.send('DROP TABLE test.lv')
     client1.expect(prompt)
     client1.send('DROP TABLE test.mt')
diff --git a/dbms/tests/queries/0_stateless/00965_live_view_watch_heartbeat.py b/dbms/tests/queries/0_stateless/00965_live_view_watch_heartbeat.py
index f024f3f1008..03e22175dff 100755
--- a/dbms/tests/queries/0_stateless/00965_live_view_watch_heartbeat.py
+++ b/dbms/tests/queries/0_stateless/00965_live_view_watch_heartbeat.py
@@ -35,7 +35,10 @@ with client(name='client1>', log=log) as client1, client(name='client2>', log=lo
     client1.expect('Progress: 2.00 rows.*\)')
     # send Ctrl-C
     client1.send('\x03', eol='')
-    client1.expect(prompt)
+    match = client1.expect('(%s)|([#\$] )' % prompt)
+    if match.groups()[1]:
+        client1.send(client1.command)
+        client1.expect(prompt)    
     client1.send('DROP TABLE test.lv')
     client1.expect(prompt)
     client1.send('DROP TABLE test.mt')
diff --git a/dbms/tests/queries/0_stateless/00979_live_view_watch_live.py b/dbms/tests/queries/0_stateless/00979_live_view_watch_live.py
index e5e44284959..948e4c93662 100755
--- a/dbms/tests/queries/0_stateless/00979_live_view_watch_live.py
+++ b/dbms/tests/queries/0_stateless/00979_live_view_watch_live.py
@@ -38,7 +38,10 @@ with client(name='client1>', log=log) as client1, client(name='client2>', log=lo
        client2.expect(prompt)
     # send Ctrl-C
     client1.send('\x03', eol='')
-    client1.expect(prompt)
+    match = client1.expect('(%s)|([#\$] )' % prompt)
+    if match.groups()[1]:
+        client1.send(client1.command)
+        client1.expect(prompt)    
     client1.send('DROP TABLE test.lv')
     client1.expect(prompt)
     client1.send('DROP TABLE test.mt')
diff --git a/dbms/tests/queries/0_stateless/helpers/client.py b/dbms/tests/queries/0_stateless/helpers/client.py
index b8f0dec46ad..de4da794805 100644
--- a/dbms/tests/queries/0_stateless/helpers/client.py
+++ b/dbms/tests/queries/0_stateless/helpers/client.py
@@ -14,6 +14,7 @@ def client(command=None, name='', log=None):
     client = uexpect.spawn(['/bin/bash','--noediting'])
     if command is None:
         command = os.environ.get('CLICKHOUSE_BINARY', 'clickhouse') + '-client'
+    client.command = command
     client.eol('\r')
     client.logger(log, prefix=name)
     client.timeout(20)

From 23e2d17d9dc18d2b039e7b0752eb162686179e17 Mon Sep 17 00:00:00 2001
From: Nikolai Kochetov <nik-kochetov@yandex-team.ru>
Date: Fri, 9 Aug 2019 18:58:07 +0300
Subject: [PATCH 059/107] Added JSONEachRowWithProgressRowOutputFormat.

---
 ...JSONEachRowWithProgressRowOutputStream.cpp | 47 -------------------
 .../JSONEachRowWithProgressRowOutputStream.h  | 27 -----------
 .../Formats/Impl/JSONEachRowRowOutputFormat.h |  3 +-
 ...JSONEachRowWithProgressRowOutputFormat.cpp | 43 +++++++++++++++++
 .../JSONEachRowWithProgressRowOutputFormat.h  | 20 ++++++++
 5 files changed, 65 insertions(+), 75 deletions(-)
 delete mode 100644 dbms/src/Formats/JSONEachRowWithProgressRowOutputStream.cpp
 delete mode 100644 dbms/src/Formats/JSONEachRowWithProgressRowOutputStream.h
 create mode 100644 dbms/src/Processors/Formats/Impl/JSONEachRowWithProgressRowOutputFormat.cpp
 create mode 100644 dbms/src/Processors/Formats/Impl/JSONEachRowWithProgressRowOutputFormat.h

diff --git a/dbms/src/Formats/JSONEachRowWithProgressRowOutputStream.cpp b/dbms/src/Formats/JSONEachRowWithProgressRowOutputStream.cpp
deleted file mode 100644
index 4f59e99ff6d..00000000000
--- a/dbms/src/Formats/JSONEachRowWithProgressRowOutputStream.cpp
+++ /dev/null
@@ -1,47 +0,0 @@
-#include <IO/WriteHelpers.h>
-#include <IO/WriteBufferValidUTF8.h>
-#include <Formats/JSONEachRowWithProgressRowOutputStream.h>
-#include <Formats/FormatFactory.h>
-#include <Formats/BlockOutputStreamFromRowOutputStream.h>
-
-
-namespace DB
-{
-
-
-void JSONEachRowWithProgressRowOutputStream::writeRowStartDelimiter()
-{
-    writeCString("{\"row\":{", ostr);
-}
-
-
-void JSONEachRowWithProgressRowOutputStream::writeRowEndDelimiter()
-{
-    writeCString("}}\n", ostr);
-    field_number = 0;
-}
-
-
-void JSONEachRowWithProgressRowOutputStream::onProgress(const Progress & value)
-{
-    progress.incrementPiecewiseAtomically(value);
-    writeCString("{\"progress\":", ostr);
-    progress.writeJSON(ostr);
-    writeCString("}\n", ostr);
-}
-
-
-void registerOutputFormatJSONEachRowWithProgress(FormatFactory & factory)
-{
-    factory.registerOutputFormat("JSONEachRowWithProgress", [](
-        WriteBuffer & buf,
-        const Block & sample,
-        const Context &,
-        const FormatSettings & format_settings)
-    {
-        return std::make_shared<BlockOutputStreamFromRowOutputStream>(
-            std::make_shared<JSONEachRowWithProgressRowOutputStream>(buf, sample, format_settings), sample);
-    });
-}
-
-}
diff --git a/dbms/src/Formats/JSONEachRowWithProgressRowOutputStream.h b/dbms/src/Formats/JSONEachRowWithProgressRowOutputStream.h
deleted file mode 100644
index e8cef8e147b..00000000000
--- a/dbms/src/Formats/JSONEachRowWithProgressRowOutputStream.h
+++ /dev/null
@@ -1,27 +0,0 @@
-#pragma once
-
-#include <IO/Progress.h>
-#include <Formats/JSONEachRowRowOutputStream.h>
-
-
-namespace DB
-{
-
-/** The stream for outputting data in JSON format, by object per line
-  * that includes progress rows. Does not validate UTF-8.
-  */
-class JSONEachRowWithProgressRowOutputStream : public JSONEachRowRowOutputStream
-{
-public:
-    using JSONEachRowRowOutputStream::JSONEachRowRowOutputStream;
-
-    void writeRowStartDelimiter() override;
-    void writeRowEndDelimiter() override;
-    void onProgress(const Progress & value) override;
-
-private:
-    Progress progress;
-};
-
-}
-
diff --git a/dbms/src/Processors/Formats/Impl/JSONEachRowRowOutputFormat.h b/dbms/src/Processors/Formats/Impl/JSONEachRowRowOutputFormat.h
index a45f193ea39..de93d012760 100644
--- a/dbms/src/Processors/Formats/Impl/JSONEachRowRowOutputFormat.h
+++ b/dbms/src/Processors/Formats/Impl/JSONEachRowRowOutputFormat.h
@@ -29,8 +29,9 @@ protected:
     void consumeTotals(Chunk) override {}
     void consumeExtremes(Chunk) override {}
 
-private:
     size_t field_number = 0;
+
+private:
     Names fields;
 
     FormatSettings settings;
diff --git a/dbms/src/Processors/Formats/Impl/JSONEachRowWithProgressRowOutputFormat.cpp b/dbms/src/Processors/Formats/Impl/JSONEachRowWithProgressRowOutputFormat.cpp
new file mode 100644
index 00000000000..d3d07f1dcb0
--- /dev/null
+++ b/dbms/src/Processors/Formats/Impl/JSONEachRowWithProgressRowOutputFormat.cpp
@@ -0,0 +1,43 @@
+#include <IO/WriteHelpers.h>
+#include <IO/WriteBufferValidUTF8.h>
+#include <Processors/Formats/Impl/JSONEachRowWithProgressRowOutputFormat.h>
+#include <Formats/FormatFactory.h>
+
+
+namespace DB
+{
+
+
+void JSONEachRowWithProgressRowOutputFormat::writeRowStartDelimiter()
+{
+    writeCString("{\"row\":{", out);
+}
+
+void JSONEachRowWithProgressRowOutputFormat::writeRowEndDelimiter()
+{
+    writeCString("}}\n", out);
+    field_number = 0;
+}
+
+void JSONEachRowWithProgressRowOutputFormat::onProgress(const Progress & value)
+{
+    progress.incrementPiecewiseAtomically(value);
+    writeCString("{\"progress\":", out);
+    progress.writeJSON(out);
+    writeCString("}\n", out);
+}
+
+
+void registerOutputFormatProcessorJSONEachRow(FormatFactory & factory)
+{
+    factory.registerOutputFormatProcessor("JSONEachRowWithProgress", [](
+            WriteBuffer & buf,
+            const Block & sample,
+            const Context &,
+            const FormatSettings & format_settings)
+    {
+        return std::make_shared<JSONEachRowWithProgressRowOutputFormat>(buf, sample, format_settings);
+    });
+}
+
+}
diff --git a/dbms/src/Processors/Formats/Impl/JSONEachRowWithProgressRowOutputFormat.h b/dbms/src/Processors/Formats/Impl/JSONEachRowWithProgressRowOutputFormat.h
new file mode 100644
index 00000000000..3062d664199
--- /dev/null
+++ b/dbms/src/Processors/Formats/Impl/JSONEachRowWithProgressRowOutputFormat.h
@@ -0,0 +1,20 @@
+#pragma once
+#include <Processors/Formats/Impl/JSONEachRowRowOutputFormat.h>
+
+namespace DB
+{
+
+class JSONEachRowWithProgressRowOutputFormat : public JSONEachRowRowOutputFormat
+{
+public:
+    using JSONEachRowRowOutputFormat::JSONEachRowRowOutputFormat;
+
+    void writeRowStartDelimiter() override;
+    void writeRowEndDelimiter() override;
+    void onProgress(const Progress & value) override;
+
+private:
+    Progress progress;
+};
+
+}

From f4aef770ffae118ba0a6058797a2ad9231edcd9e Mon Sep 17 00:00:00 2001
From: Nikolai Kochetov <nik-kochetov@yandex-team.ru>
Date: Fri, 9 Aug 2019 19:01:29 +0300
Subject: [PATCH 060/107] Added JSONEachRowWithProgressRowOutputFormat.

---
 dbms/src/Formats/FormatFactory.cpp | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/dbms/src/Formats/FormatFactory.cpp b/dbms/src/Formats/FormatFactory.cpp
index 4daa63448f2..515172bc3a9 100644
--- a/dbms/src/Formats/FormatFactory.cpp
+++ b/dbms/src/Formats/FormatFactory.cpp
@@ -202,8 +202,6 @@ void registerOutputFormatNative(FormatFactory & factory);
 void registerInputFormatTabSeparated(FormatFactory & factory);
 void registerInputFormatCSV(FormatFactory & factory);
 
-void registerOutputFormatJSONEachRowWithProgress(FormatFactory & factory);
-
 void registerInputFormatProcessorNative(FormatFactory & factory);
 void registerOutputFormatProcessorNative(FormatFactory & factory);
 void registerInputFormatProcessorRowBinary(FormatFactory & factory);
@@ -233,6 +231,7 @@ void registerOutputFormatProcessorPrettySpace(FormatFactory & factory);
 void registerOutputFormatProcessorVertical(FormatFactory & factory);
 void registerOutputFormatProcessorJSON(FormatFactory & factory);
 void registerOutputFormatProcessorJSONCompact(FormatFactory & factory);
+void registerOutputFormatProcessorJSONEachRow(FormatFactory & factory);
 void registerOutputFormatProcessorXML(FormatFactory & factory);
 void registerOutputFormatProcessorODBCDriver(FormatFactory & factory);
 void registerOutputFormatProcessorODBCDriver2(FormatFactory & factory);
@@ -249,7 +248,7 @@ FormatFactory::FormatFactory()
     registerInputFormatTabSeparated(*this);
     registerInputFormatCSV(*this);
 
-    registerOutputFormatJSONEachRowWithProgress(*this);
+    registerOutputFormatProcessorJSONEachRow(*this);
 
     registerInputFormatProcessorNative(*this);
     registerOutputFormatProcessorNative(*this);

From ed11432f6885abb4a3d0f5b2e56e899791d3e306 Mon Sep 17 00:00:00 2001
From: Nikolai Kochetov <nik-kochetov@yandex-team.ru>
Date: Fri, 9 Aug 2019 19:10:47 +0300
Subject: [PATCH 061/107] Added JSONEachRowWithProgressRowOutputFormat.

---
 dbms/src/Formats/FormatFactory.cpp                            | 4 ++--
 .../Formats/Impl/JSONEachRowWithProgressRowOutputFormat.cpp   | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/dbms/src/Formats/FormatFactory.cpp b/dbms/src/Formats/FormatFactory.cpp
index 515172bc3a9..6150484e6b4 100644
--- a/dbms/src/Formats/FormatFactory.cpp
+++ b/dbms/src/Formats/FormatFactory.cpp
@@ -231,7 +231,7 @@ void registerOutputFormatProcessorPrettySpace(FormatFactory & factory);
 void registerOutputFormatProcessorVertical(FormatFactory & factory);
 void registerOutputFormatProcessorJSON(FormatFactory & factory);
 void registerOutputFormatProcessorJSONCompact(FormatFactory & factory);
-void registerOutputFormatProcessorJSONEachRow(FormatFactory & factory);
+void registerOutputFormatProcessorJSONEachRowWithProgress(FormatFactory & factory);
 void registerOutputFormatProcessorXML(FormatFactory & factory);
 void registerOutputFormatProcessorODBCDriver(FormatFactory & factory);
 void registerOutputFormatProcessorODBCDriver2(FormatFactory & factory);
@@ -248,7 +248,7 @@ FormatFactory::FormatFactory()
     registerInputFormatTabSeparated(*this);
     registerInputFormatCSV(*this);
 
-    registerOutputFormatProcessorJSONEachRow(*this);
+    registerOutputFormatProcessorJSONEachRowWithProgress(*this);
 
     registerInputFormatProcessorNative(*this);
     registerOutputFormatProcessorNative(*this);
diff --git a/dbms/src/Processors/Formats/Impl/JSONEachRowWithProgressRowOutputFormat.cpp b/dbms/src/Processors/Formats/Impl/JSONEachRowWithProgressRowOutputFormat.cpp
index d3d07f1dcb0..6d448b00203 100644
--- a/dbms/src/Processors/Formats/Impl/JSONEachRowWithProgressRowOutputFormat.cpp
+++ b/dbms/src/Processors/Formats/Impl/JSONEachRowWithProgressRowOutputFormat.cpp
@@ -28,7 +28,7 @@ void JSONEachRowWithProgressRowOutputFormat::onProgress(const Progress & value)
 }
 
 
-void registerOutputFormatProcessorJSONEachRow(FormatFactory & factory)
+void registerOutputFormatProcessorJSONEachRowWithProgress(FormatFactory & factory)
 {
     factory.registerOutputFormatProcessor("JSONEachRowWithProgress", [](
             WriteBuffer & buf,

From 40cc3990372f331619946ffb05284b2dfee7e4bb Mon Sep 17 00:00:00 2001
From: Nikolai Kochetov <nik-kochetov@yandex-team.ru>
Date: Fri, 9 Aug 2019 20:15:01 +0300
Subject: [PATCH 062/107] Fix PushingToViewsBlockOutputStream.

---
 .../PushingToViewsBlockOutputStream.cpp            | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/dbms/src/DataStreams/PushingToViewsBlockOutputStream.cpp b/dbms/src/DataStreams/PushingToViewsBlockOutputStream.cpp
index cbc63056c1f..2e96a8d3ea2 100644
--- a/dbms/src/DataStreams/PushingToViewsBlockOutputStream.cpp
+++ b/dbms/src/DataStreams/PushingToViewsBlockOutputStream.cpp
@@ -215,17 +215,17 @@ void PushingToViewsBlockOutputStream::process(const Block & block, size_t view_n
                                           block));
             InterpreterSelectQuery select(view.query, local_context, SelectQueryOptions());
             in = std::make_shared<MaterializingBlockInputStream>(select.execute().in);
+
+            /// Squashing is needed here because the materialized view query can generate a lot of blocks
+            /// even when only one block is inserted into the parent table (e.g. if the query is a GROUP BY
+            /// and two-level aggregation is triggered).
+            in = std::make_shared<SquashingBlockInputStream>(
+                    in, context.getSettingsRef().min_insert_block_size_rows, context.getSettingsRef().min_insert_block_size_bytes);
+            in = std::make_shared<ConvertingBlockInputStream>(context, in, view.out->getHeader(), ConvertingBlockInputStream::MatchColumnsMode::Position);
         }
         else
             in = std::make_shared<OneBlockInputStream>(block);
 
-        /// Squashing is needed here because the materialized view query can generate a lot of blocks
-        /// even when only one block is inserted into the parent table (e.g. if the query is a GROUP BY
-        /// and two-level aggregation is triggered).
-        in = std::make_shared<SquashingBlockInputStream>(
-            in, context.getSettingsRef().min_insert_block_size_rows, context.getSettingsRef().min_insert_block_size_bytes);
-        in = std::make_shared<ConvertingBlockInputStream>(context, in, view.out->getHeader(), ConvertingBlockInputStream::MatchColumnsMode::Position);
-
         in->readPrefix();
 
         while (Block result_block = in->read())

From 18939a57765028fc65afba1bcb0464f4dd7a8ff7 Mon Sep 17 00:00:00 2001
From: Nikolai Kochetov <nik-kochetov@yandex-team.ru>
Date: Mon, 12 Aug 2019 13:59:45 +0300
Subject: [PATCH 063/107] Fix build/

---
 dbms/src/DataStreams/BlocksBlockInputStream.h | 4 ++--
 dbms/src/Storages/ProxyStorage.h              | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/dbms/src/DataStreams/BlocksBlockInputStream.h b/dbms/src/DataStreams/BlocksBlockInputStream.h
index 58a63e5b85e..27407acbfae 100644
--- a/dbms/src/DataStreams/BlocksBlockInputStream.h
+++ b/dbms/src/DataStreams/BlocksBlockInputStream.h
@@ -23,8 +23,8 @@ class BlocksBlockInputStream : public IBlockInputStream
 {
 public:
     /// Acquires shared ownership of the blocks vector
-    BlocksBlockInputStream(const std::shared_ptr<BlocksPtr> & blocks_ptr_, Block header)
-        : blocks(*blocks_ptr_), it((*blocks_ptr_)->begin()), end((*blocks_ptr_)->end()), header(std::move(header)) {}
+    BlocksBlockInputStream(const std::shared_ptr<BlocksPtr> & blocks_ptr_, Block header_)
+        : blocks(*blocks_ptr_), it((*blocks_ptr_)->begin()), end((*blocks_ptr_)->end()), header(std::move(header_)) {}
 
     String getName() const override { return "Blocks"; }
 
diff --git a/dbms/src/Storages/ProxyStorage.h b/dbms/src/Storages/ProxyStorage.h
index 3e6926eb323..60faa907209 100644
--- a/dbms/src/Storages/ProxyStorage.h
+++ b/dbms/src/Storages/ProxyStorage.h
@@ -8,8 +8,8 @@ namespace DB
 class ProxyStorage : public IStorage
 {
 public:
-    ProxyStorage(StoragePtr storage, BlockInputStreams streams, QueryProcessingStage::Enum to_stage)
-    : storage(std::move(storage)), streams(std::move(streams)), to_stage(to_stage) {}
+    ProxyStorage(StoragePtr storage_, BlockInputStreams streams_, QueryProcessingStage::Enum to_stage_)
+    : storage(std::move(storage_)), streams(std::move(streams_)), to_stage(to_stage_) {}
 
 public:
     std::string getName() const override { return "ProxyStorage(" + storage->getName() + ")"; }

From 545420963d49c5df63648d51e0cb0be5389e4d43 Mon Sep 17 00:00:00 2001
From: Nikolai Kochetov <nik-kochetov@yandex-team.ru>
Date: Mon, 12 Aug 2019 14:04:30 +0300
Subject: [PATCH 064/107] Fix build/

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

diff --git a/dbms/src/Parsers/ParserAlterQuery.h b/dbms/src/Parsers/ParserAlterQuery.h
index 3dd7f89062b..13f5681a9da 100644
--- a/dbms/src/Parsers/ParserAlterQuery.h
+++ b/dbms/src/Parsers/ParserAlterQuery.h
@@ -48,7 +48,7 @@ public:
     bool is_live_view;
     bool is_live_channel;
 
-    ParserAlterCommandList(bool is_live_view = false, bool is_live_channel = false) : is_live_view(is_live_view), is_live_channel(is_live_channel) {}
+    ParserAlterCommandList(bool is_live_view_ = false, bool is_live_channel_ = false) : is_live_view(is_live_view_), is_live_channel(is_live_channel_) {}
 };
 
 
@@ -62,7 +62,7 @@ public:
     bool is_live_view;
     bool is_live_channel;
 
-    ParserAlterCommand(bool is_live_view = false, bool is_live_channel = false) : is_live_view(is_live_view), is_live_channel(is_live_channel) {}
+    ParserAlterCommand(bool is_live_view_ = false, bool is_live_channel_ = false) : is_live_view(is_live_view_), is_live_channel(is_live_channel_) {}
 };
 
 

From 43e5cbe35c5b4aef6035faac9a054c7798e72eee Mon Sep 17 00:00:00 2001
From: Nikolai Kochetov <nik-kochetov@yandex-team.ru>
Date: Mon, 12 Aug 2019 14:06:28 +0300
Subject: [PATCH 065/107] Fix build/

---
 dbms/src/Storages/StorageLiveView.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/dbms/src/Storages/StorageLiveView.cpp b/dbms/src/Storages/StorageLiveView.cpp
index df7f8c896b3..6e42b9780e1 100644
--- a/dbms/src/Storages/StorageLiveView.cpp
+++ b/dbms/src/Storages/StorageLiveView.cpp
@@ -103,8 +103,8 @@ StorageLiveView::StorageLiveView(
     const String & database_name_,
     Context & local_context,
     const ASTCreateQuery & query,
-    const ColumnsDescription & columns)
-    : IStorage(columns), table_name(table_name_),
+    const ColumnsDescription & columns_)
+    : IStorage(columns_), table_name(table_name_),
     database_name(database_name_), global_context(local_context.getGlobalContext())
 {
     if (!query.select)

From 43ee50e512e92fa8b067e53ad0d3c907f98e1c69 Mon Sep 17 00:00:00 2001
From: dimarub2000 <dimarub2000@gmail.com>
Date: Tue, 13 Aug 2019 22:12:31 +0300
Subject: [PATCH 066/107] QuantileExactExclusive function added.

---
 .../AggregateFunctionQuantile.cpp             |  7 ++
 .../AggregateFunctionQuantile.h               |  6 +-
 dbms/src/AggregateFunctions/QuantileExact.h   | 70 +++++++++++++++++--
 3 files changed, 78 insertions(+), 5 deletions(-)

diff --git a/dbms/src/AggregateFunctions/AggregateFunctionQuantile.cpp b/dbms/src/AggregateFunctions/AggregateFunctionQuantile.cpp
index d41654daee5..9d07286371c 100644
--- a/dbms/src/AggregateFunctions/AggregateFunctionQuantile.cpp
+++ b/dbms/src/AggregateFunctions/AggregateFunctionQuantile.cpp
@@ -24,6 +24,9 @@ template <typename Value, bool FloatReturn> using FuncQuantilesDeterministic = A
 template <typename Value, bool _> using FuncQuantileExact = AggregateFunctionQuantile<Value, QuantileExact<Value>, NameQuantileExact, false, void, false>;
 template <typename Value, bool _> using FuncQuantilesExact = AggregateFunctionQuantile<Value, QuantileExact<Value>, NameQuantilesExact, false, void, true>;
 
+template <typename Value, bool _> using FuncQuantileExactExclusive = AggregateFunctionQuantile<Value, QuantileExactExclusive<Value>, NameQuantileExactExclusive, false, Float64, false>;
+template <typename Value, bool _> using FuncQuantilesExactExclusive = AggregateFunctionQuantile<Value, QuantileExactExclusive<Value>, NameQuantilesExactExclusive, false, Float64, true>;
+
 template <typename Value, bool _> using FuncQuantileExactWeighted = AggregateFunctionQuantile<Value, QuantileExactWeighted<Value>, NameQuantileExactWeighted, true, void, false>;
 template <typename Value, bool _> using FuncQuantilesExactWeighted = AggregateFunctionQuantile<Value, QuantileExactWeighted<Value>, NameQuantilesExactWeighted, true, void, true>;
 
@@ -92,6 +95,10 @@ void registerAggregateFunctionsQuantile(AggregateFunctionFactory & factory)
     factory.registerFunction(NameQuantileExact::name, createAggregateFunctionQuantile<FuncQuantileExact>);
     factory.registerFunction(NameQuantilesExact::name, createAggregateFunctionQuantile<FuncQuantilesExact>);
 
+    factory.registerFunction(NameQuantileExactExclusive::name, createAggregateFunctionQuantile<FuncQuantileExactExclusive>);
+    factory.registerFunction(NameQuantilesExactExclusive::name, createAggregateFunctionQuantile<FuncQuantilesExactExclusive>);
+
+
     factory.registerFunction(NameQuantileExactWeighted::name, createAggregateFunctionQuantile<FuncQuantileExactWeighted>);
     factory.registerFunction(NameQuantilesExactWeighted::name, createAggregateFunctionQuantile<FuncQuantilesExactWeighted>);
 
diff --git a/dbms/src/AggregateFunctions/AggregateFunctionQuantile.h b/dbms/src/AggregateFunctions/AggregateFunctionQuantile.h
index 2e9ec914b99..4fdac6cdd53 100644
--- a/dbms/src/AggregateFunctions/AggregateFunctionQuantile.h
+++ b/dbms/src/AggregateFunctions/AggregateFunctionQuantile.h
@@ -199,8 +199,12 @@ struct NameQuantileDeterministic { static constexpr auto name = "quantileDetermi
 struct NameQuantilesDeterministic { static constexpr auto name = "quantilesDeterministic"; };
 
 struct NameQuantileExact { static constexpr auto name = "quantileExact"; };
-struct NameQuantileExactWeighted { static constexpr auto name = "quantileExactWeighted"; };
 struct NameQuantilesExact { static constexpr auto name = "quantilesExact"; };
+
+struct NameQuantileExactExclusive { static constexpr auto name = "quantileExactExclusive"; };
+struct NameQuantilesExactExclusive { static constexpr auto name = "quantilesExactExclusive"; };
+
+struct NameQuantileExactWeighted { static constexpr auto name = "quantileExactWeighted"; };
 struct NameQuantilesExactWeighted { static constexpr auto name = "quantilesExactWeighted"; };
 
 struct NameQuantileTiming { static constexpr auto name = "quantileTiming"; };
diff --git a/dbms/src/AggregateFunctions/QuantileExact.h b/dbms/src/AggregateFunctions/QuantileExact.h
index a5b616669b9..b23a2975487 100644
--- a/dbms/src/AggregateFunctions/QuantileExact.h
+++ b/dbms/src/AggregateFunctions/QuantileExact.h
@@ -64,7 +64,7 @@ struct QuantileExact
     }
 
     /// Get the value of the `level` quantile. The level must be between 0 and 1.
-    Value get(Float64 level)
+    virtual Value get(Float64 level)
     {
         if (!array.empty())
         {
@@ -81,7 +81,7 @@ struct QuantileExact
 
     /// Get the `size` values of `levels` quantiles. Write `size` results starting with `result` address.
     /// indices - an array of index levels such that the corresponding elements will go in ascending order.
-    void getMany(const Float64 * levels, const size_t * indices, size_t size, Value * result)
+    virtual void getMany(const Float64 * levels, const size_t * indices, size_t size, Value * result)
     {
         if (!array.empty())
         {
@@ -108,15 +108,77 @@ struct QuantileExact
     }
 
     /// The same, but in the case of an empty state, NaN is returned.
-    Float64 getFloat(Float64) const
+    virtual Float64 getFloat(Float64)
     {
         throw Exception("Method getFloat is not implemented for QuantileExact", ErrorCodes::NOT_IMPLEMENTED);
     }
 
-    void getManyFloat(const Float64 *, const size_t *, size_t, Float64 *) const
+    virtual void getManyFloat(const Float64 *, const size_t *, size_t, Float64 *)
     {
         throw Exception("Method getManyFloat is not implemented for QuantileExact", ErrorCodes::NOT_IMPLEMENTED);
     }
+
+    virtual ~QuantileExact() = default;
+};
+
+template <typename Value>
+struct QuantileExactExclusive : public QuantileExact<Value>
+{
+    using QuantileExact<Value>::array;
+    /// Get the value of the `level` quantile. The level must be between 0 and 1.
+    Float64 getFloat(Float64 level) override
+    {
+        if (!array.empty())
+        {
+            Float64 h = level * (array.size() + 1);
+            auto n = static_cast<size_t>(h);
+
+            if (n >= array.size())
+                return array[array.size() - 1];
+            else if (n < 1)
+                return array[0];
+
+            std::nth_element(array.begin(), array.begin() + n - 1, array.end());
+            std::nth_element(array.begin() + n, array.begin() + n, array.end());
+
+            return array[n - 1] + (h - n) * (array[n] - array[n - 1]);
+        }
+
+        return std::numeric_limits<Float64>::quiet_NaN();
+    }
+
+    void getManyFloat(const Float64 * levels, const size_t * indices, size_t size, Float64 * result) override
+    {
+        if (!array.empty())
+        {
+            size_t prev_n = 0;
+            for (size_t i = 0; i < size; ++i)
+            {
+                auto level = levels[indices[i]];
+
+                Float64 h = level * (array.size() + 1);
+                auto n = static_cast<size_t>(h);
+
+                if (n >= array.size())
+                    result[indices[i]] = array[array.size() - 1];
+                else if (n < 1)
+                    result[indices[i]] = array[0];
+                else
+                {
+                    std::nth_element(array.begin() + prev_n, array.begin() + n - 1, array.end());
+                    std::nth_element(array.begin() + n, array.begin() + n, array.end());
+
+                    result[indices[i]] = array[n - 1] + (h - n) * (array[n] - array[n - 1]);
+                    prev_n = n;
+                }
+            }
+        }
+        else
+        {
+            for (size_t i = 0; i < size; ++i)
+                result[i] = std::numeric_limits<Float64>::quiet_NaN();
+        }
+    }
 };
 
 }

From 6b6e477c76d103ba110de38c36b86b659d136935 Mon Sep 17 00:00:00 2001
From: dimarub2000 <dimarub2000@gmail.com>
Date: Wed, 14 Aug 2019 14:13:04 +0300
Subject: [PATCH 067/107] Added QuantileExactInclusive function. Deleted
 redundant virtuals.

---
 .../AggregateFunctionQuantile.cpp             |  5 ++
 .../AggregateFunctionQuantile.h               |  3 +
 dbms/src/AggregateFunctions/QuantileExact.h   | 88 +++++++++++++++++--
 3 files changed, 87 insertions(+), 9 deletions(-)

diff --git a/dbms/src/AggregateFunctions/AggregateFunctionQuantile.cpp b/dbms/src/AggregateFunctions/AggregateFunctionQuantile.cpp
index 9d07286371c..e3d0cbdc289 100644
--- a/dbms/src/AggregateFunctions/AggregateFunctionQuantile.cpp
+++ b/dbms/src/AggregateFunctions/AggregateFunctionQuantile.cpp
@@ -27,6 +27,9 @@ template <typename Value, bool _> using FuncQuantilesExact = AggregateFunctionQu
 template <typename Value, bool _> using FuncQuantileExactExclusive = AggregateFunctionQuantile<Value, QuantileExactExclusive<Value>, NameQuantileExactExclusive, false, Float64, false>;
 template <typename Value, bool _> using FuncQuantilesExactExclusive = AggregateFunctionQuantile<Value, QuantileExactExclusive<Value>, NameQuantilesExactExclusive, false, Float64, true>;
 
+template <typename Value, bool _> using FuncQuantileExactInclusive = AggregateFunctionQuantile<Value, QuantileExactInclusive<Value>, NameQuantileExactInclusive, false, Float64, false>;
+template <typename Value, bool _> using FuncQuantilesExactInclusive = AggregateFunctionQuantile<Value, QuantileExactInclusive<Value>, NameQuantilesExactInclusive, false, Float64, true>;
+
 template <typename Value, bool _> using FuncQuantileExactWeighted = AggregateFunctionQuantile<Value, QuantileExactWeighted<Value>, NameQuantileExactWeighted, true, void, false>;
 template <typename Value, bool _> using FuncQuantilesExactWeighted = AggregateFunctionQuantile<Value, QuantileExactWeighted<Value>, NameQuantilesExactWeighted, true, void, true>;
 
@@ -98,6 +101,8 @@ void registerAggregateFunctionsQuantile(AggregateFunctionFactory & factory)
     factory.registerFunction(NameQuantileExactExclusive::name, createAggregateFunctionQuantile<FuncQuantileExactExclusive>);
     factory.registerFunction(NameQuantilesExactExclusive::name, createAggregateFunctionQuantile<FuncQuantilesExactExclusive>);
 
+    factory.registerFunction(NameQuantileExactInclusive::name, createAggregateFunctionQuantile<FuncQuantileExactInclusive>);
+    factory.registerFunction(NameQuantilesExactInclusive::name, createAggregateFunctionQuantile<FuncQuantilesExactInclusive>);
 
     factory.registerFunction(NameQuantileExactWeighted::name, createAggregateFunctionQuantile<FuncQuantileExactWeighted>);
     factory.registerFunction(NameQuantilesExactWeighted::name, createAggregateFunctionQuantile<FuncQuantilesExactWeighted>);
diff --git a/dbms/src/AggregateFunctions/AggregateFunctionQuantile.h b/dbms/src/AggregateFunctions/AggregateFunctionQuantile.h
index 4fdac6cdd53..718bf419dd0 100644
--- a/dbms/src/AggregateFunctions/AggregateFunctionQuantile.h
+++ b/dbms/src/AggregateFunctions/AggregateFunctionQuantile.h
@@ -204,6 +204,9 @@ struct NameQuantilesExact { static constexpr auto name = "quantilesExact"; };
 struct NameQuantileExactExclusive { static constexpr auto name = "quantileExactExclusive"; };
 struct NameQuantilesExactExclusive { static constexpr auto name = "quantilesExactExclusive"; };
 
+struct NameQuantileExactInclusive { static constexpr auto name = "quantileExactInclusive"; };
+struct NameQuantilesExactInclusive { static constexpr auto name = "quantilesExactInclusive"; };
+
 struct NameQuantileExactWeighted { static constexpr auto name = "quantileExactWeighted"; };
 struct NameQuantilesExactWeighted { static constexpr auto name = "quantilesExactWeighted"; };
 
diff --git a/dbms/src/AggregateFunctions/QuantileExact.h b/dbms/src/AggregateFunctions/QuantileExact.h
index b23a2975487..ffa12640f8e 100644
--- a/dbms/src/AggregateFunctions/QuantileExact.h
+++ b/dbms/src/AggregateFunctions/QuantileExact.h
@@ -14,6 +14,7 @@ namespace DB
 namespace ErrorCodes
 {
     extern const int NOT_IMPLEMENTED;
+    extern const int BAD_ARGUMENTS;
 }
 
 /** Calculates quantile by collecting all values into array
@@ -64,7 +65,7 @@ struct QuantileExact
     }
 
     /// Get the value of the `level` quantile. The level must be between 0 and 1.
-    virtual Value get(Float64 level)
+    Value get(Float64 level)
     {
         if (!array.empty())
         {
@@ -81,7 +82,7 @@ struct QuantileExact
 
     /// Get the `size` values of `levels` quantiles. Write `size` results starting with `result` address.
     /// indices - an array of index levels such that the corresponding elements will go in ascending order.
-    virtual void getMany(const Float64 * levels, const size_t * indices, size_t size, Value * result)
+    void getMany(const Float64 * levels, const size_t * indices, size_t size, Value * result)
     {
         if (!array.empty())
         {
@@ -121,13 +122,18 @@ struct QuantileExact
     virtual ~QuantileExact() = default;
 };
 
+/// QuantileExactInclusive is equivalent to Excel PERCENTILE.EXC, R-6, SAS-4, SciPy-(0,0)
 template <typename Value>
 struct QuantileExactExclusive : public QuantileExact<Value>
 {
     using QuantileExact<Value>::array;
-    /// Get the value of the `level` quantile. The level must be between 0 and 1.
+
+    /// Get the value of the `level` quantile. The level must be between 0 and 1 excluding bounds.
     Float64 getFloat(Float64 level) override
     {
+        if (level == 0. || level == 1.)
+            throw Exception("QuantileExactExclusive cannot interpolate for the percentiles 1 and 0", ErrorCodes::BAD_ARGUMENTS);
+
         if (!array.empty())
         {
             Float64 h = level * (array.size() + 1);
@@ -139,9 +145,73 @@ struct QuantileExactExclusive : public QuantileExact<Value>
                 return array[0];
 
             std::nth_element(array.begin(), array.begin() + n - 1, array.end());
-            std::nth_element(array.begin() + n, array.begin() + n, array.end());
+            auto nth_element = std::min_element(array.begin() + n, array.end());
 
-            return array[n - 1] + (h - n) * (array[n] - array[n - 1]);
+            return array[n - 1] + (h - n) * (*nth_element - array[n - 1]);
+        }
+
+        return std::numeric_limits<Float64>::quiet_NaN();
+    }
+
+    void getManyFloat(const Float64 * levels, const size_t * indices, size_t size, Float64 * result) override
+    {
+        if (!array.empty())
+        {
+            size_t prev_n = 0;
+            for (size_t i = 0; i < size; ++i)
+            {
+                auto level = levels[indices[i]];
+                if (level == 0. || level == 1.)
+                    throw Exception("QuantileExactExclusive cannot interpolate for the percentiles 1 and 0", ErrorCodes::BAD_ARGUMENTS);
+
+                Float64 h = level * (array.size() + 1);
+                auto n = static_cast<size_t>(h);
+
+                if (n >= array.size())
+                    result[indices[i]] = array[array.size() - 1];
+                else if (n < 1)
+                    result[indices[i]] = array[0];
+                else
+                {
+                    std::nth_element(array.begin() + prev_n, array.begin() + n - 1, array.end());
+                    auto nth_element = std::min_element(array.begin() + n, array.end());
+
+                    result[indices[i]] = array[n - 1] + (h - n) * (*nth_element - array[n - 1]);
+                    prev_n = n - 1;
+                }
+            }
+        }
+        else
+        {
+            for (size_t i = 0; i < size; ++i)
+                result[i] = std::numeric_limits<Float64>::quiet_NaN();
+        }
+    }
+};
+
+/// QuantileExactInclusive is equivalent to Excel PERCENTILE and PERCENTILE.INC, R-7,  SciPy-(1,1)
+template <typename Value>
+struct QuantileExactInclusive : public QuantileExact<Value>
+{
+    using QuantileExact<Value>::array;
+
+    /// Get the value of the `level` quantile. The level must be between 0 and 1 including bounds.
+    Float64 getFloat(Float64 level) override
+    {
+        if (!array.empty())
+        {
+            Float64 h = level * (array.size() - 1) + 1;
+            auto n = static_cast<size_t>(h);
+
+            if (n >= array.size())
+                return array[array.size() - 1];
+            else if (n < 1)
+                return array[0];
+
+            std::nth_element(array.begin(), array.begin() + n - 1, array.end());
+            auto nth_element = std::min_element(array.begin() + n, array.end());
+
+            return array[n - 1] + (h - n) * (*nth_element - array[n - 1]);
         }
 
         return std::numeric_limits<Float64>::quiet_NaN();
@@ -156,7 +226,7 @@ struct QuantileExactExclusive : public QuantileExact<Value>
             {
                 auto level = levels[indices[i]];
 
-                Float64 h = level * (array.size() + 1);
+                Float64 h = level * (array.size() - 1) + 1;
                 auto n = static_cast<size_t>(h);
 
                 if (n >= array.size())
@@ -166,10 +236,10 @@ struct QuantileExactExclusive : public QuantileExact<Value>
                 else
                 {
                     std::nth_element(array.begin() + prev_n, array.begin() + n - 1, array.end());
-                    std::nth_element(array.begin() + n, array.begin() + n, array.end());
+                    auto nth_element = std::min_element(array.begin() + n, array.end());
 
-                    result[indices[i]] = array[n - 1] + (h - n) * (array[n] - array[n - 1]);
-                    prev_n = n;
+                    result[indices[i]] = array[n - 1] + (h - n) * (*nth_element - array[n - 1]);
+                    prev_n = n - 1;
                 }
             }
         }

From 73e208917c8a97eeeedf22a661fd1d1a0f6588b8 Mon Sep 17 00:00:00 2001
From: dimarub2000 <dimarub2000@gmail.com>
Date: Wed, 14 Aug 2019 14:18:46 +0300
Subject: [PATCH 068/107] Fixed comment

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

diff --git a/dbms/src/AggregateFunctions/QuantileExact.h b/dbms/src/AggregateFunctions/QuantileExact.h
index ffa12640f8e..058c433e992 100644
--- a/dbms/src/AggregateFunctions/QuantileExact.h
+++ b/dbms/src/AggregateFunctions/QuantileExact.h
@@ -122,7 +122,7 @@ struct QuantileExact
     virtual ~QuantileExact() = default;
 };
 
-/// QuantileExactInclusive is equivalent to Excel PERCENTILE.EXC, R-6, SAS-4, SciPy-(0,0)
+/// QuantileExactExclusive is equivalent to Excel PERCENTILE.EXC, R-6, SAS-4, SciPy-(0,0)
 template <typename Value>
 struct QuantileExactExclusive : public QuantileExact<Value>
 {
@@ -131,11 +131,11 @@ struct QuantileExactExclusive : public QuantileExact<Value>
     /// Get the value of the `level` quantile. The level must be between 0 and 1 excluding bounds.
     Float64 getFloat(Float64 level) override
     {
-        if (level == 0. || level == 1.)
-            throw Exception("QuantileExactExclusive cannot interpolate for the percentiles 1 and 0", ErrorCodes::BAD_ARGUMENTS);
-
         if (!array.empty())
         {
+            if (level == 0. || level == 1.)
+                throw Exception("QuantileExactExclusive cannot interpolate for the percentiles 1 and 0", ErrorCodes::BAD_ARGUMENTS);
+
             Float64 h = level * (array.size() + 1);
             auto n = static_cast<size_t>(h);
 

From e56f6264309429fac145b817baee4330c8bcbda5 Mon Sep 17 00:00:00 2001
From: Dmitry Rubashkin <dimarub2000@sandbox-407922969>
Date: Wed, 14 Aug 2019 16:45:04 +0300
Subject: [PATCH 069/107] Tests

---
 ...79_quantileExcatExclusive_and_Inclusive.reference |  6 ++++++
 .../00979_quantileExcatExclusive_and_Inclusive.sql   | 12 ++++++++++++
 2 files changed, 18 insertions(+)
 create mode 100644 dbms/tests/queries/0_stateless/00979_quantileExcatExclusive_and_Inclusive.reference
 create mode 100644 dbms/tests/queries/0_stateless/00979_quantileExcatExclusive_and_Inclusive.sql

diff --git a/dbms/tests/queries/0_stateless/00979_quantileExcatExclusive_and_Inclusive.reference b/dbms/tests/queries/0_stateless/00979_quantileExcatExclusive_and_Inclusive.reference
new file mode 100644
index 00000000000..1ac0dd60fca
--- /dev/null
+++ b/dbms/tests/queries/0_stateless/00979_quantileExcatExclusive_and_Inclusive.reference
@@ -0,0 +1,6 @@
+[249.25,499.5,749.75,899.9,949.9499999999999,989.99,998.999]
+[249.75,499.5,749.25,899.1,949.05,989.01,998.001]
+[250,500,750,900,950,990,999]
+599.6
+599.6
+600
diff --git a/dbms/tests/queries/0_stateless/00979_quantileExcatExclusive_and_Inclusive.sql b/dbms/tests/queries/0_stateless/00979_quantileExcatExclusive_and_Inclusive.sql
new file mode 100644
index 00000000000..9652fbbb664
--- /dev/null
+++ b/dbms/tests/queries/0_stateless/00979_quantileExcatExclusive_and_Inclusive.sql
@@ -0,0 +1,12 @@
+DROP TABLE IF EXISTS num;
+CREATE TABLE num AS numbers(1000);
+
+SELECT quantilesExactExclusive(0.25, 0.5, 0.75, 0.9, 0.95, 0.99, 0.999)(x) FROM (SELECT number AS x FROM num);
+SELECT quantilesExactInclusive(0.25, 0.5, 0.75, 0.9, 0.95, 0.99, 0.999)(x) FROM (SELECT number AS x FROM num);
+SELECT quantilesExact(0.25, 0.5, 0.75, 0.9, 0.95, 0.99, 0.999)(x) FROM (SELECT number AS x FROM num);
+
+SELECT quantileExactExclusive(0.6)(x) FROM (SELECT number AS x FROM num);
+SELECT quantileExactExclusive(0.6)(x) FROM (SELECT number AS x FROM num);
+SELECT quantileExact(0.6)(x) FROM (SELECT number AS x FROM num);
+
+DROP TABLE num;

From 4090e89410d9809df358268bc5de26d4af4d93c8 Mon Sep 17 00:00:00 2001
From: Dmitry Rubashkin <dimarub2000@sandbox-407922969>
Date: Wed, 14 Aug 2019 16:47:48 +0300
Subject: [PATCH 070/107] Tests fixed

---
 .../00979_quantileExcatExclusive_and_Inclusive.reference        | 2 +-
 .../0_stateless/00979_quantileExcatExclusive_and_Inclusive.sql  | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/dbms/tests/queries/0_stateless/00979_quantileExcatExclusive_and_Inclusive.reference b/dbms/tests/queries/0_stateless/00979_quantileExcatExclusive_and_Inclusive.reference
index 1ac0dd60fca..8689402746e 100644
--- a/dbms/tests/queries/0_stateless/00979_quantileExcatExclusive_and_Inclusive.reference
+++ b/dbms/tests/queries/0_stateless/00979_quantileExcatExclusive_and_Inclusive.reference
@@ -2,5 +2,5 @@
 [249.75,499.5,749.25,899.1,949.05,989.01,998.001]
 [250,500,750,900,950,990,999]
 599.6
-599.6
+599.4
 600
diff --git a/dbms/tests/queries/0_stateless/00979_quantileExcatExclusive_and_Inclusive.sql b/dbms/tests/queries/0_stateless/00979_quantileExcatExclusive_and_Inclusive.sql
index 9652fbbb664..99cbcfbd6b9 100644
--- a/dbms/tests/queries/0_stateless/00979_quantileExcatExclusive_and_Inclusive.sql
+++ b/dbms/tests/queries/0_stateless/00979_quantileExcatExclusive_and_Inclusive.sql
@@ -6,7 +6,7 @@ SELECT quantilesExactInclusive(0.25, 0.5, 0.75, 0.9, 0.95, 0.99, 0.999)(x) FROM
 SELECT quantilesExact(0.25, 0.5, 0.75, 0.9, 0.95, 0.99, 0.999)(x) FROM (SELECT number AS x FROM num);
 
 SELECT quantileExactExclusive(0.6)(x) FROM (SELECT number AS x FROM num);
-SELECT quantileExactExclusive(0.6)(x) FROM (SELECT number AS x FROM num);
+SELECT quantileExactInclusive(0.6)(x) FROM (SELECT number AS x FROM num);
 SELECT quantileExact(0.6)(x) FROM (SELECT number AS x FROM num);
 
 DROP TABLE num;

From e2171a038b56cca3504ed42870e58698550dbc08 Mon Sep 17 00:00:00 2001
From: Nikolai Kochetov <nik-kochetov@yandex-team.ru>
Date: Thu, 15 Aug 2019 14:10:33 +0300
Subject: [PATCH 071/107] Temporarily disabled
 00963_temporary_live_view_watch_live_timeout.

---
 ..._temporary_live_view_watch_live_timeout.py | 49 -------------------
 1 file changed, 49 deletions(-)
 delete mode 100755 dbms/tests/queries/0_stateless/00963_temporary_live_view_watch_live_timeout.py

diff --git a/dbms/tests/queries/0_stateless/00963_temporary_live_view_watch_live_timeout.py b/dbms/tests/queries/0_stateless/00963_temporary_live_view_watch_live_timeout.py
deleted file mode 100755
index df627c84e49..00000000000
--- a/dbms/tests/queries/0_stateless/00963_temporary_live_view_watch_live_timeout.py
+++ /dev/null
@@ -1,49 +0,0 @@
-#!/usr/bin/env python
-import os
-import sys
-import signal
-
-CURDIR = os.path.dirname(os.path.realpath(__file__))
-sys.path.insert(0, os.path.join(CURDIR, 'helpers'))
-
-from client import client, prompt, end_of_block
-
-log = None
-# uncomment the line below for debugging
-#log=sys.stdout
-
-with client(name='client1>', log=log) as client1, client(name='client2>', log=log) as client2:
-    client1.expect(prompt)
-    client2.expect(prompt)
-
-    client1.send('DROP TABLE IF EXISTS test.lv')
-    client1.expect(prompt)
-    client1.send('DROP TABLE IF EXISTS test.mt')
-    client1.expect(prompt)
-    client1.send('SET temporary_live_view_timeout=1')
-    client1.expect(prompt)
-    client1.send('CREATE TABLE test.mt (a Int32) Engine=MergeTree order by tuple()')
-    client1.expect(prompt)
-    client1.send('CREATE TEMPORARY LIVE VIEW test.lv AS SELECT sum(a) FROM test.mt')
-    client1.expect(prompt)
-    client1.send('WATCH test.lv')
-    client1.expect(r'0.*1' + end_of_block)
-    client2.send('INSERT INTO test.mt VALUES (1),(2),(3)')
-    client2.expect(prompt)
-    client1.expect(r'6.*2' + end_of_block)
-    client2.send('INSERT INTO test.mt VALUES (4),(5),(6)')
-    client2.expect(prompt)
-    client1.expect(r'21.*3' + end_of_block)
-    # send Ctrl-C
-    client1.send('\x03', eol='')
-    match = client1.expect('(%s)|([#\$] )' % prompt)
-    if match.groups()[1]:
-        client1.send(client1.command)
-        client1.expect(prompt)
-    client1.send('SELECT sleep(1)')
-    client1.expect(prompt)
-    client1.send('DROP TABLE test.lv')
-    client1.expect('Table test.lv doesn\'t exist')
-    client1.expect(prompt)
-    client1.send('DROP TABLE test.mt')
-    client1.expect(prompt)

From 67f6129284a12b207f9debf720ae6de462573d1a Mon Sep 17 00:00:00 2001
From: Nikolai Kochetov <nik-kochetov@yandex-team.ru>
Date: Thu, 15 Aug 2019 14:18:41 +0300
Subject: [PATCH 072/107] Temporarily disabled
 00963_temporary_live_view_watch_live_timeout.

---
 ...y_live_view_watch_live_timeout.py.disabled | 49 +++++++++++++++++++
 1 file changed, 49 insertions(+)
 create mode 100755 dbms/tests/queries/0_stateless/00963_temporary_live_view_watch_live_timeout.py.disabled

diff --git a/dbms/tests/queries/0_stateless/00963_temporary_live_view_watch_live_timeout.py.disabled b/dbms/tests/queries/0_stateless/00963_temporary_live_view_watch_live_timeout.py.disabled
new file mode 100755
index 00000000000..df627c84e49
--- /dev/null
+++ b/dbms/tests/queries/0_stateless/00963_temporary_live_view_watch_live_timeout.py.disabled
@@ -0,0 +1,49 @@
+#!/usr/bin/env python
+import os
+import sys
+import signal
+
+CURDIR = os.path.dirname(os.path.realpath(__file__))
+sys.path.insert(0, os.path.join(CURDIR, 'helpers'))
+
+from client import client, prompt, end_of_block
+
+log = None
+# uncomment the line below for debugging
+#log=sys.stdout
+
+with client(name='client1>', log=log) as client1, client(name='client2>', log=log) as client2:
+    client1.expect(prompt)
+    client2.expect(prompt)
+
+    client1.send('DROP TABLE IF EXISTS test.lv')
+    client1.expect(prompt)
+    client1.send('DROP TABLE IF EXISTS test.mt')
+    client1.expect(prompt)
+    client1.send('SET temporary_live_view_timeout=1')
+    client1.expect(prompt)
+    client1.send('CREATE TABLE test.mt (a Int32) Engine=MergeTree order by tuple()')
+    client1.expect(prompt)
+    client1.send('CREATE TEMPORARY LIVE VIEW test.lv AS SELECT sum(a) FROM test.mt')
+    client1.expect(prompt)
+    client1.send('WATCH test.lv')
+    client1.expect(r'0.*1' + end_of_block)
+    client2.send('INSERT INTO test.mt VALUES (1),(2),(3)')
+    client2.expect(prompt)
+    client1.expect(r'6.*2' + end_of_block)
+    client2.send('INSERT INTO test.mt VALUES (4),(5),(6)')
+    client2.expect(prompt)
+    client1.expect(r'21.*3' + end_of_block)
+    # send Ctrl-C
+    client1.send('\x03', eol='')
+    match = client1.expect('(%s)|([#\$] )' % prompt)
+    if match.groups()[1]:
+        client1.send(client1.command)
+        client1.expect(prompt)
+    client1.send('SELECT sleep(1)')
+    client1.expect(prompt)
+    client1.send('DROP TABLE test.lv')
+    client1.expect('Table test.lv doesn\'t exist')
+    client1.expect(prompt)
+    client1.send('DROP TABLE test.mt')
+    client1.expect(prompt)

From 688cc4976a028a013dbba8800767b5240061ee1c Mon Sep 17 00:00:00 2001
From: Nikolai Kochetov <nik-kochetov@yandex-team.ru>
Date: Fri, 16 Aug 2019 14:03:23 +0300
Subject: [PATCH 073/107] Moved NOTICE to dbms/src

---
 NOTICE          | 41 -----------------------------------------
 dbms/src/NOTICE | 41 +++++++++++++++++++++++++++++++++++++++++
 2 files changed, 41 insertions(+), 41 deletions(-)
 delete mode 100644 NOTICE
 create mode 100644 dbms/src/NOTICE

diff --git a/NOTICE b/NOTICE
deleted file mode 100644
index 59c6923e66a..00000000000
--- a/NOTICE
+++ /dev/null
@@ -1,41 +0,0 @@
---
-The following notice shall be applied to the files listed below.
-
-Some modifications Copyright (c) 2018 BlackBerry Limited
-
-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.
-
-dbms/src/Common/ErrorCodes.cpp
-dbms/src/Common/UInt128.h
-dbms/src/Core/Block.h
-dbms/src/Core/Defines.h
-dbms/src/Core/Settings.h
-dbms/src/DataStreams/PushingToViewsBlockOutputStream.cpp
-dbms/src/DataStreams/PushingToViewsBlockOutputStream.h
-dbms/src/DataStreams/copyData.cpp
-dbms/src/Databases/DatabasesCommon.cpp
-dbms/src/IO/WriteBufferValidUTF8.cpp
-dbms/src/Interpreters/InterpreterAlterQuery.cpp
-dbms/src/Interpreters/InterpreterCreateQuery.cpp
-dbms/src/Interpreters/InterpreterFactory.cpp
-dbms/src/Parsers/ASTAlterQuery.cpp
-dbms/src/Parsers/ASTAlterQuery.h
-dbms/src/Parsers/ASTCreateQuery.cpp
-dbms/src/Parsers/ASTCreateQuery.h
-dbms/src/Parsers/ParserAlterQuery.cpp
-dbms/src/Parsers/ParserAlterQuery.h
-dbms/src/Parsers/ParserCreateQuery.cpp
-dbms/src/Parsers/ParserCreateQuery.h
-dbms/src/Parsers/ParserQueryWithOutput.cpp
-dbms/src/Storages/IStorage.h
-dbms/src/Storages/StorageFactory.cpp
-dbms/src/Storages/registerStorages.cpp
---
diff --git a/dbms/src/NOTICE b/dbms/src/NOTICE
new file mode 100644
index 00000000000..d0d3efe3f8e
--- /dev/null
+++ b/dbms/src/NOTICE
@@ -0,0 +1,41 @@
+--
+The following notice shall be applied to the files listed below.
+
+Some modifications Copyright (c) 2018 BlackBerry Limited
+
+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.
+
+Common/ErrorCodes.cpp
+Common/UInt128.h
+Core/Block.h
+Core/Defines.h
+Core/Settings.h
+DataStreams/PushingToViewsBlockOutputStream.cpp
+DataStreams/PushingToViewsBlockOutputStream.h
+DataStreams/copyData.cpp
+Databases/DatabasesCommon.cpp
+IO/WriteBufferValidUTF8.cpp
+Interpreters/InterpreterAlterQuery.cpp
+Interpreters/InterpreterCreateQuery.cpp
+Interpreters/InterpreterFactory.cpp
+Parsers/ASTAlterQuery.cpp
+Parsers/ASTAlterQuery.h
+Parsers/ASTCreateQuery.cpp
+Parsers/ASTCreateQuery.h
+Parsers/ParserAlterQuery.cpp
+Parsers/ParserAlterQuery.h
+Parsers/ParserCreateQuery.cpp
+Parsers/ParserCreateQuery.h
+Parsers/ParserQueryWithOutput.cpp
+Storages/IStorage.h
+Storages/StorageFactory.cpp
+Storages/registerStorages.cpp
+--

From 8bbcecf3b1c58aa3220d36ee09ea8ac38ab7e872 Mon Sep 17 00:00:00 2001
From: Alexander Tokmakov <avtokmakov@yandex-team.ru>
Date: Fri, 16 Aug 2019 19:14:08 +0300
Subject: [PATCH 074/107] add test

---
 .../__init__.py                               |  0
 .../configs/remote_servers.xml                | 19 ++++++
 .../test.py                                   | 59 +++++++++++++++++++
 3 files changed, 78 insertions(+)
 create mode 100644 dbms/tests/integration/test_inconsistent_parts_after_clone_replica/__init__.py
 create mode 100644 dbms/tests/integration/test_inconsistent_parts_after_clone_replica/configs/remote_servers.xml
 create mode 100644 dbms/tests/integration/test_inconsistent_parts_after_clone_replica/test.py

diff --git a/dbms/tests/integration/test_inconsistent_parts_after_clone_replica/__init__.py b/dbms/tests/integration/test_inconsistent_parts_after_clone_replica/__init__.py
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/dbms/tests/integration/test_inconsistent_parts_after_clone_replica/configs/remote_servers.xml b/dbms/tests/integration/test_inconsistent_parts_after_clone_replica/configs/remote_servers.xml
new file mode 100644
index 00000000000..a6e80ce2b08
--- /dev/null
+++ b/dbms/tests/integration/test_inconsistent_parts_after_clone_replica/configs/remote_servers.xml
@@ -0,0 +1,19 @@
+<yandex>
+    <remote_servers>
+        <test_cluster>
+            <shard>
+                <internal_replication>true</internal_replication>
+                <replica>
+                    <default_database>shard_0</default_database>
+                    <host>node1</host>
+                    <port>9000</port>
+                </replica>
+                <replica>
+                    <default_database>shard_0</default_database>
+                    <host>node2</host>
+                    <port>9000</port>
+                </replica>
+            </shard>
+        </test_cluster>
+    </remote_servers>
+</yandex>
diff --git a/dbms/tests/integration/test_inconsistent_parts_after_clone_replica/test.py b/dbms/tests/integration/test_inconsistent_parts_after_clone_replica/test.py
new file mode 100644
index 00000000000..c1513798189
--- /dev/null
+++ b/dbms/tests/integration/test_inconsistent_parts_after_clone_replica/test.py
@@ -0,0 +1,59 @@
+import pytest
+
+from helpers.cluster import ClickHouseCluster
+from helpers.network import PartitionManager
+from helpers.test_tools import assert_eq_with_retry
+
+
+def fill_nodes(nodes, shard):
+    for node in nodes:
+        node.query(
+        '''
+        CREATE DATABASE test;
+        CREATE TABLE test_table(date Date, id UInt32)
+        ENGINE = ReplicatedMergeTree('/clickhouse/tables/test{shard}/replicated', '{replica}')
+        ORDER BY id PARTITION BY toYYYYMM(date) 
+        SETTINGS min_replicated_logs_to_keep=3, max_replicated_logs_to_keep=5, cleanup_delay_period=0, cleanup_delay_period_random_add=0;
+        '''.format(shard=shard, replica=node.name))
+
+
+cluster = ClickHouseCluster(__file__)
+node1 = cluster.add_instance('node1', main_configs=['configs/remote_servers.xml'], with_zookeeper=True)
+node2 = cluster.add_instance('node2', main_configs=['configs/remote_servers.xml'], with_zookeeper=True)
+
+@pytest.fixture(scope="module")
+def start_cluster():
+    try:
+        cluster.start()
+        fill_nodes([node1, node2], 1)
+        yield cluster
+    except Exception as ex:
+        print ex
+    finally:
+        cluster.shutdown()
+
+
+def test_inconsistent_parts_if_drop_while_replica_not_active(start_cluster):
+    with PartitionManager() as pm:
+        # insert into all replicas
+        node1.query("INSERT INTO test_table VALUES ('2019-08-16', 100)")
+        assert_eq_with_retry(node2, "SELECT count(*) FROM test_table", node1.query("SELECT count(*) FROM test_table"))
+
+        # disable network on the first replica
+        pm.partition_instances(node1, node2)
+        pm.drop_instance_zk_connections(node1)
+
+        # drop all parts on the second replica
+        node2.query_with_retry("ALTER TABLE test_table DROP PARTITION 201908")
+        assert_eq_with_retry(node2, "SELECT count(*) FROM test_table", "0")
+
+        # insert into the second replica
+        # DROP_RANGE will be removed from the replication log and the first replica will be lost
+        for i in range(100):
+            node2.query("INSERT INTO test_table VALUES ('2019-08-16', {})".format(i))
+
+        # the first replica will be cloned from the second
+        pm.heal_all()
+        assert_eq_with_retry(node1, "SELECT count(*) FROM test_table", node2.query("SELECT count(*) FROM test_table"))
+
+

From e9070ede0a0162b21984be5ef4e2d0e4dc24e50b Mon Sep 17 00:00:00 2001
From: Nikolai Kochetov <nik-kochetov@yandex-team.ru>
Date: Fri, 16 Aug 2019 19:28:25 +0300
Subject: [PATCH 075/107] Try to rewrite live view test.

---
 .../00991_live_view_watch_http.python         | 87 +++++++++++++++++++
 .../00991_live_view_watch_http.reference      |  0
 .../0_stateless/00991_live_view_watch_http.sh |  6 ++
 3 files changed, 93 insertions(+)
 create mode 100755 dbms/tests/queries/0_stateless/00991_live_view_watch_http.python
 create mode 100644 dbms/tests/queries/0_stateless/00991_live_view_watch_http.reference
 create mode 100755 dbms/tests/queries/0_stateless/00991_live_view_watch_http.sh

diff --git a/dbms/tests/queries/0_stateless/00991_live_view_watch_http.python b/dbms/tests/queries/0_stateless/00991_live_view_watch_http.python
new file mode 100755
index 00000000000..d2e55cd1ea1
--- /dev/null
+++ b/dbms/tests/queries/0_stateless/00991_live_view_watch_http.python
@@ -0,0 +1,87 @@
+#!/usr/bin/env python
+
+import subprocess
+import threading
+import Queue as queue
+import os
+import sys
+
+
+CLICKHOUSE_CLIENT = os.environ.get('CLICKHOUSE_CLIENT')
+CLICKHOUSE_CURL = os.environ.get('CLICKHOUSE_CURL')
+CLICKHOUSE_URL = os.environ.get('CLICKHOUSE_URL')
+
+
+print(CLICKHOUSE_CLIENT)
+print(CLICKHOUSE_CURL)
+print(CLICKHOUSE_URL)
+
+
+def send_query(query):
+    cmd = list(CLICKHOUSE_CLIENT.split())
+    cmd += ['--query', query]
+    print(' '.join(cmd))
+    return subprocess.Popen(cmd, stdout=subprocess.PIPE, close_fds=True).stdout
+
+
+def send_http_query(query):
+    cmd = list(['curl', '--max-time', '20'])
+    cmd += ['-sS', CLICKHOUSE_URL, '-d', query]
+    return subprocess.Popen(cmd, stdout=subprocess.PIPE, close_fds=True, bufsize=1).stdout
+
+
+def read_lines_and_push_to_queue(pipe, queue):
+    print('--------')
+    sys.stdout.flush()
+    s = ''
+    while True:
+        char = pipe.read(1)
+        if char == '':
+            break
+
+        print('>  ' + char)
+        if char == '\n':
+            queue.put(s)
+            s = ''
+        else:
+            s += char
+        sys.stdout.flush()
+        #queue.put(line)
+
+    if s:
+       queue.put(s)
+    print(None)
+    queue.put(None)
+
+
+def test():
+    print(1)
+    send_query('DROP TABLE IF EXISTS test.lv').read()
+    print(2)
+    send_query('DROP TABLE IF EXISTS test.mt').read()
+    send_query('CREATE TABLE test.mt (a Int32) Engine=MergeTree order by tuple()').read()
+    send_query('CREATE LIVE VIEW test.lv AS SELECT sum(a) FROM test.mt').read()
+
+    q = queue.Queue()
+    pipe = send_http_query('WATCH test.lv')
+    sys.stdout.flush()
+    thread = threading.Thread(target=read_lines_and_push_to_queue, args=(pipe, q))
+    thread.start()
+    print(3)
+    sys.stdout.flush()
+    assert (q.get() == '0\t1')
+    print(3.1)
+    sys.stdout.flush()
+    send_query('INSERT INTO test.mt VALUES (1),(2),(3)').read()
+    print(4)
+    assert (q.get() == '6\t2')
+    print(4.1)
+    send_query('DROP TABLE test.lv').read()
+    print(5)
+    assert (q.get() is None)
+    print(5.2)
+    send_query('DROP TABLE test.mt').read()
+    print(6)
+    thread.join()
+
+test()
diff --git a/dbms/tests/queries/0_stateless/00991_live_view_watch_http.reference b/dbms/tests/queries/0_stateless/00991_live_view_watch_http.reference
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/dbms/tests/queries/0_stateless/00991_live_view_watch_http.sh b/dbms/tests/queries/0_stateless/00991_live_view_watch_http.sh
new file mode 100755
index 00000000000..88cce77f595
--- /dev/null
+++ b/dbms/tests/queries/0_stateless/00991_live_view_watch_http.sh
@@ -0,0 +1,6 @@
+#!/usr/bin/env bash
+
+CURDIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
+. $CURDIR/../shell_config.sh
+
+python $CURDIR/00991_live_view_watch_http.python

From 7baddc4cb6b503d93b7588e02553bb773f6dddab Mon Sep 17 00:00:00 2001
From: Alexander Tokmakov <avtokmakov@yandex-team.ru>
Date: Fri, 16 Aug 2019 21:34:54 +0300
Subject: [PATCH 076/107] update changelog

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

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 2a0b69bcc6d..081b7f08a4d 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,63 @@
+## ClickHouse release 19.13.2.19, 2019-08-14
+
+### New Feature
+* Added functions for working with the сustom week number [#5212](https://github.com/yandex/ClickHouse/pull/5212) ([Andy Yang](https://github.com/andyyzh))
+* New query processing pipeline. Use `experimental_use_processors=1` option to enable it. [#4914](https://github.com/yandex/ClickHouse/pull/4914) ([Nikolai Kochetov](https://github.com/KochetovNicolai))
+* It is possible to select several columns by providing a pattern of three dots before or after of a stem. [#5951](https://github.com/yandex/ClickHouse/pull/5951) ([mfridental](https://github.com/mfridental))
+* Allow to specify a list of columns with `COLUMNS('regexp')` expression that works like a more sophisticated variant of `*` asterisk. [#6038](https://github.com/yandex/ClickHouse/pull/6038) ([alexey-milovidov](https://github.com/alexey-milovidov))
+* `CREATE TABLE AS table_function()` is now possible [#6057](https://github.com/yandex/ClickHouse/pull/6057) ([dimarub2000](https://github.com/dimarub2000))
+* Throws an exception if `config.d` file doesn't have the corresponding root element as the config file [#6123](https://github.com/yandex/ClickHouse/pull/6123) ([dimarub2000](https://github.com/dimarub2000))
+* Poor man's profiler for each query being executed [#4247](https://github.com/yandex/ClickHouse/issues/4247) ([laplab](https://github.com/laplab))
+* Adam optimizer for stochastic descent. Made it default (because it shows good quality without almost any tuning). [#6000](https://github.com/yandex/ClickHouse/pull/6000) ([Quid37](https://github.com/Quid37))
+
+### Bug Fix
+* For row-level security feature it's crucial for all storages to provide proper database name. Now it's implemented. [#5953](https://github.com/yandex/ClickHouse/pull/5953) ([Ivan](https://github.com/abyss7))
+* Now client could receive lags with any desired level. [#5964](https://github.com/yandex/ClickHouse/pull/5964) ([Nikita Mikhaylov](https://github.com/nikitamikhaylov))
+* Fixed `DoubleDelta` encoding cases for random `Int32` and `Int64`. [#5998](https://github.com/yandex/ClickHouse/pull/5998) ([Vasily Nemkov](https://github.com/Enmk))
+* Fix client version number which is able to read additional progress data from the server. [#6018](https://github.com/yandex/ClickHouse/pull/6018) ([alesapin](https://github.com/alesapin))
+* Fixed overestimation of `max_rows_to_read` if the setting `merge_tree_uniform_read_distribution` is set to 0. [#6019](https://github.com/yandex/ClickHouse/pull/6019) ([alexey-milovidov](https://github.com/alexey-milovidov))
+* Fix backward compatibility for `CHECK QUERY`. [#6024](https://github.com/yandex/ClickHouse/pull/6024) ([alesapin](https://github.com/alesapin))
+* After introduction of virtual columns in storages `DESCRIBE TABLE` started to show them too, it was unexpected and now is fixed. [#6040](https://github.com/yandex/ClickHouse/pull/6040) ([Ivan](https://github.com/abyss7))
+* Fix non-deterministic result of `uniq` aggregate function in extreme rare cases. The bug was present in all ClickHouse versions. [#6058](https://github.com/yandex/ClickHouse/pull/6058) ([alexey-milovidov](https://github.com/alexey-milovidov))
+* Fix segfault when we set a little bit too high CIDR on the function `IPv6CIDRToRange`. [#6068](https://github.com/yandex/ClickHouse/pull/6068) ([Guillaume Tassery](https://github.com/YiuRULE))
+* Fix the situation when Kafka consumer got paused before subscription and not resumed afterwards. [#6075](https://github.com/yandex/ClickHouse/pull/6075) ([Ivan](https://github.com/abyss7))
+* Fixed useless and incorrect condition on update field for initial loading of external dictionaries via ODBC, MySQL, ClickHouse and HTTP. This fixes [#6069](https://github.com/yandex/ClickHouse/issues/6069). [#6083](https://github.com/yandex/ClickHouse/pull/6083) ([alexey-milovidov](https://github.com/alexey-milovidov))
+* Fixed irrelevant exception in cast of `LowCardinality(Nullable)` to not-Nullable column in case if it doesn't contain Nulls (e.g. in query like `SELECT CAST(CAST('Hello' AS LowCardinality(Nullable(String))) AS String)`. This fixes [#6094](https://github.com/yandex/ClickHouse/issues/6094). [#6119](https://github.com/yandex/ClickHouse/pull/6119) ([Nikolai Kochetov](https://github.com/KochetovNicolai))
+* Fix bug with writing secondary indices marks with adaptive granularity. [#6126](https://github.com/yandex/ClickHouse/pull/6126) ([alesapin](https://github.com/alesapin))
+
+### Improvement
+* The setting `input_format_defaults_for_omitted_fields` is enabled by default. It enables calculation of complex default expressions for ommitted fields in `JSONEachRow` format. It should be the expected behaviour but may lead to neglible performance difference or subtle incompatibilities. [#6043](https://github.com/yandex/ClickHouse/pull/6043) ([Artem Zuikov](https://github.com/4ertus2))
+
+### Performance Improvement
+* Optimize `count()` [#6028](https://github.com/yandex/ClickHouse/pull/6028) ([Amos Bird](https://github.com/amosbird))
+
+### Build/Testing/Packaging Improvement
+* Fixed MSan report. [#6144](https://github.com/yandex/ClickHouse/pull/6144) ([alexey-milovidov](https://github.com/alexey-milovidov))
+* Report memory usage in performance tests. [#5899](https://github.com/yandex/ClickHouse/pull/5899) ([akuzm](https://github.com/akuzm))
+* Add ability to sign .rpm clickhouse packages. [#5977](https://github.com/yandex/ClickHouse/pull/5977) ([alesapin](https://github.com/alesapin))
+* Add dependencies for RPM packages [#6023](https://github.com/yandex/ClickHouse/pull/6023) ([alesapin](https://github.com/alesapin))
+* Fix build with external `libcxx` [#6010](https://github.com/yandex/ClickHouse/pull/6010) ([Ivan](https://github.com/abyss7))
+* Fix shared build with `rdkafka` library [#6101](https://github.com/yandex/ClickHouse/pull/6101) ([Ivan](https://github.com/abyss7))
+
+## ClickHouse release 19.11.7.40, 2019-08-14
+
+### Bug fix
+* Fix segfault when using `arrayReduce` for constant arguments. [#6326](https://github.com/yandex/ClickHouse/pull/6326) ([alexey-milovidov](https://github.com/alexey-milovidov))
+* Fixed `toFloat()` monotonicity. [#6374](https://github.com/yandex/ClickHouse/pull/6374) ([dimarub2000](https://github.com/dimarub2000))
+* Fix segfault with enabled `optimize_skip_unused_shards` and missing sharding key. [#6384](https://github.com/yandex/ClickHouse/pull/6384) ([CurtizJ](https://github.com/CurtizJ))
+* Fixed logic of `arrayEnumerateUniqRanked` function. [#6423](https://github.com/yandex/ClickHouse/pull/6423) ([alexey-milovidov](https://github.com/alexey-milovidov))
+* Removed extra verbose logging from MySQL handler. [#6389](https://github.com/yandex/ClickHouse/pull/6389) ([alexey-milovidov](https://github.com/alexey-milovidov))
+* Fix wrong behavior and possible segfaults in `topK` and `topKWeighted` aggregated functions. [#6404](https://github.com/yandex/ClickHouse/pull/6404) ([CurtizJ](https://github.com/CurtizJ))
+* Do not expose virtual columns in `system.columns` table. This is required for backward compatibility. [#6406](https://github.com/yandex/ClickHouse/pull/6406) ([alexey-milovidov](https://github.com/alexey-milovidov))
+* Fix bug with memory allocation for string fields in complex key cache dictionary. [#6447](https://github.com/yandex/ClickHouse/pull/6447) ([alesapin](https://github.com/alesapin))
+* Fix bug with enabling adaptive granularity when creating new replica for `Replicated*MergeTree` table. [#6452](https://github.com/yandex/ClickHouse/pull/6452) ([alesapin](https://github.com/alesapin))
+* Fix infinite loop when reading Kafka messages. [#6354](https://github.com/yandex/ClickHouse/pull/6354) ([abyss7](https://github.com/abyss7))
+* Fixed the possibility of a fabricated query to cause server crash due to stack overflow in SQL parser and possibility of stack overflow in `Merge` and `Distributed` tables [#6433](https://github.com/yandex/ClickHouse/pull/6433) ([alexey-milovidov](https://github.com/alexey-milovidov))
+* Fixed Gorilla encoding error on small sequences. [#6344](https://github.com/yandex/ClickHouse/pull/6444) ([Enmk](https://github.com/Enmk))
+
+### Improvement
+* Allow user to override `poll_interval` and `idle_connection_timeout` settings on connection. [#6230](https://github.com/yandex/ClickHouse/pull/6230) ([alexey-milovidov](https://github.com/alexey-milovidov))
+
 ## ClickHouse release 19.11.5.28, 2019-08-05
 
 ### Bug fix

From 5c10bff9c2089d78234fa31fe6ceb6624e09e547 Mon Sep 17 00:00:00 2001
From: Nikolai Kochetov <nik-kochetov@yandex-team.ru>
Date: Fri, 16 Aug 2019 21:52:29 +0300
Subject: [PATCH 077/107] Try to rewrite live view test.

---
 .../00991_live_view_watch_http.python         | 83 ++++++++-----------
 1 file changed, 34 insertions(+), 49 deletions(-)

diff --git a/dbms/tests/queries/0_stateless/00991_live_view_watch_http.python b/dbms/tests/queries/0_stateless/00991_live_view_watch_http.python
index d2e55cd1ea1..2f46aa11046 100755
--- a/dbms/tests/queries/0_stateless/00991_live_view_watch_http.python
+++ b/dbms/tests/queries/0_stateless/00991_live_view_watch_http.python
@@ -12,76 +12,61 @@ CLICKHOUSE_CURL = os.environ.get('CLICKHOUSE_CURL')
 CLICKHOUSE_URL = os.environ.get('CLICKHOUSE_URL')
 
 
-print(CLICKHOUSE_CLIENT)
-print(CLICKHOUSE_CURL)
-print(CLICKHOUSE_URL)
-
-
 def send_query(query):
     cmd = list(CLICKHOUSE_CLIENT.split())
     cmd += ['--query', query]
-    print(' '.join(cmd))
-    return subprocess.Popen(cmd, stdout=subprocess.PIPE, close_fds=True).stdout
+    # print(cmd)
+    return subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
 
 
 def send_http_query(query):
-    cmd = list(['curl', '--max-time', '20'])
-    cmd += ['-sS', CLICKHOUSE_URL, '-d', query]
-    return subprocess.Popen(cmd, stdout=subprocess.PIPE, close_fds=True, bufsize=1).stdout
+    cmd =  list(CLICKHOUSE_CURL.split()) # list(['curl', '-sSN', '--max-time', '10'])
+    cmd += ['-sSN', CLICKHOUSE_URL, '-d', query]
+    return subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
 
 
-def read_lines_and_push_to_queue(pipe, queue):
-    print('--------')
+def read_lines_and_push_to_queue(p, queue):
+    pipe = p.stdout
     sys.stdout.flush()
-    s = ''
-    while True:
-        char = pipe.read(1)
-        if char == '':
-            break
 
-        print('>  ' + char)
-        if char == '\n':
-            queue.put(s)
-            s = ''
-        else:
-            s += char
+    for line in iter(pipe.readline, ''):
+        line = line.strip()
+        print(line)
         sys.stdout.flush()
-        #queue.put(line)
+        queue.put(line)
 
-    if s:
-       queue.put(s)
-    print(None)
     queue.put(None)
+    p.wait()
 
 
 def test():
-    print(1)
-    send_query('DROP TABLE IF EXISTS test.lv').read()
-    print(2)
-    send_query('DROP TABLE IF EXISTS test.mt').read()
-    send_query('CREATE TABLE test.mt (a Int32) Engine=MergeTree order by tuple()').read()
-    send_query('CREATE LIVE VIEW test.lv AS SELECT sum(a) FROM test.mt').read()
+    send_query('DROP TABLE IF EXISTS test.lv').stdout.read()
+    send_query('DROP TABLE IF EXISTS test.mt').stdout.read()
+    send_query('CREATE TABLE test.mt (a Int32) Engine=MergeTree order by tuple()').stdout.read()
+    send_query('CREATE LIVE VIEW test.lv AS SELECT sum(a) FROM test.mt').stdout.read()
 
     q = queue.Queue()
     pipe = send_http_query('WATCH test.lv')
-    sys.stdout.flush()
     thread = threading.Thread(target=read_lines_and_push_to_queue, args=(pipe, q))
     thread.start()
-    print(3)
-    sys.stdout.flush()
-    assert (q.get() == '0\t1')
-    print(3.1)
-    sys.stdout.flush()
-    send_query('INSERT INTO test.mt VALUES (1),(2),(3)').read()
-    print(4)
-    assert (q.get() == '6\t2')
-    print(4.1)
-    send_query('DROP TABLE test.lv').read()
-    print(5)
-    assert (q.get() is None)
-    print(5.2)
-    send_query('DROP TABLE test.mt').read()
-    print(6)
+
+    line = q.get()
+    print(line)
+    assert (line == '0\t1')
+
+    p = send_query('INSERT INTO test.mt VALUES (1),(2),(3)')
+    p.stdout.read()
+    p.wait()
+    line = q.get()
+    print(line)
+    assert (line == '6\t2')
+
+    p = send_query('DROP TABLE if exitst test.lv')
+    p.stdout.read()
+    p.wait()
+    p = send_query('DROP TABLE if exitst test.mt')
+    p.stdout.read()
+    p.wait()
     thread.join()
 
 test()

From 4bc8419042ac55d294b1fb4c5ef231348a2896b7 Mon Sep 17 00:00:00 2001
From: Alexander Tokmakov <avtokmakov@yandex-team.ru>
Date: Sun, 18 Aug 2019 21:39:30 +0300
Subject: [PATCH 078/107] fixes

---
 CHANGELOG.md | 37 +++++++++++++------------------------
 1 file changed, 13 insertions(+), 24 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 081b7f08a4d..6ec0ea442fc 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,41 +1,30 @@
 ## ClickHouse release 19.13.2.19, 2019-08-14
 
 ### New Feature
+* Allow to specify a list of columns with `COLUMNS('regexp')` expression that works like a more sophisticated variant of `*` asterisk. [#5951](https://github.com/yandex/ClickHouse/pull/5951)  ([mfridental](https://github.com/mfridental)), ([alexey-milovidov](https://github.com/alexey-milovidov))
+* `CREATE TABLE AS table_function()` is now possible [#6057](https://github.com/yandex/ClickHouse/pull/6057) ([dimarub2000](https://github.com/dimarub2000))
+* Poor man's profiler for each query being executed. It stops query execution thread at random time points to collect current backtrace. After some time a developer can analyze which code points profiler visits most often to find probable efficiency issues. [#4247](https://github.com/yandex/ClickHouse/issues/4247) ([laplab](https://github.com/laplab))
+* Adam optimizer for stochastic gradient descent is used by default in `stochasticLinearRegression()` and `stochasticLogisticRegression()` aggregate functions, because it shows good quality without almost any tuning. [#6000](https://github.com/yandex/ClickHouse/pull/6000) ([Quid37](https://github.com/Quid37))
+
+### Experimental features
 * Added functions for working with the сustom week number [#5212](https://github.com/yandex/ClickHouse/pull/5212) ([Andy Yang](https://github.com/andyyzh))
 * New query processing pipeline. Use `experimental_use_processors=1` option to enable it. [#4914](https://github.com/yandex/ClickHouse/pull/4914) ([Nikolai Kochetov](https://github.com/KochetovNicolai))
-* It is possible to select several columns by providing a pattern of three dots before or after of a stem. [#5951](https://github.com/yandex/ClickHouse/pull/5951) ([mfridental](https://github.com/mfridental))
-* Allow to specify a list of columns with `COLUMNS('regexp')` expression that works like a more sophisticated variant of `*` asterisk. [#6038](https://github.com/yandex/ClickHouse/pull/6038) ([alexey-milovidov](https://github.com/alexey-milovidov))
-* `CREATE TABLE AS table_function()` is now possible [#6057](https://github.com/yandex/ClickHouse/pull/6057) ([dimarub2000](https://github.com/dimarub2000))
-* Throws an exception if `config.d` file doesn't have the corresponding root element as the config file [#6123](https://github.com/yandex/ClickHouse/pull/6123) ([dimarub2000](https://github.com/dimarub2000))
-* Poor man's profiler for each query being executed [#4247](https://github.com/yandex/ClickHouse/issues/4247) ([laplab](https://github.com/laplab))
-* Adam optimizer for stochastic descent. Made it default (because it shows good quality without almost any tuning). [#6000](https://github.com/yandex/ClickHouse/pull/6000) ([Quid37](https://github.com/Quid37))
 
 ### Bug Fix
-* For row-level security feature it's crucial for all storages to provide proper database name. Now it's implemented. [#5953](https://github.com/yandex/ClickHouse/pull/5953) ([Ivan](https://github.com/abyss7))
-* Now client could receive lags with any desired level. [#5964](https://github.com/yandex/ClickHouse/pull/5964) ([Nikita Mikhaylov](https://github.com/nikitamikhaylov))
-* Fixed `DoubleDelta` encoding cases for random `Int32` and `Int64`. [#5998](https://github.com/yandex/ClickHouse/pull/5998) ([Vasily Nemkov](https://github.com/Enmk))
-* Fix client version number which is able to read additional progress data from the server. [#6018](https://github.com/yandex/ClickHouse/pull/6018) ([alesapin](https://github.com/alesapin))
+* `RENAME` queries now work with all storages. [#5953](https://github.com/yandex/ClickHouse/pull/5953) ([Ivan](https://github.com/abyss7))
+* Now client could receive logs from server with any desired level by setting `send_logs_level` regardless to the log level specified in server settings. [#5964](https://github.com/yandex/ClickHouse/pull/5964) ([Nikita Mikhaylov](https://github.com/nikitamikhaylov))
+* Fixed `DoubleDelta` encoding of `Int64` for large `DoubleDelta` values, improved `DoubleDelta` encoding for random data for `Int32`. [#5998](https://github.com/yandex/ClickHouse/pull/5998) ([Vasily Nemkov](https://github.com/Enmk))
 * Fixed overestimation of `max_rows_to_read` if the setting `merge_tree_uniform_read_distribution` is set to 0. [#6019](https://github.com/yandex/ClickHouse/pull/6019) ([alexey-milovidov](https://github.com/alexey-milovidov))
-* Fix backward compatibility for `CHECK QUERY`. [#6024](https://github.com/yandex/ClickHouse/pull/6024) ([alesapin](https://github.com/alesapin))
-* After introduction of virtual columns in storages `DESCRIBE TABLE` started to show them too, it was unexpected and now is fixed. [#6040](https://github.com/yandex/ClickHouse/pull/6040) ([Ivan](https://github.com/abyss7))
-* Fix non-deterministic result of `uniq` aggregate function in extreme rare cases. The bug was present in all ClickHouse versions. [#6058](https://github.com/yandex/ClickHouse/pull/6058) ([alexey-milovidov](https://github.com/alexey-milovidov))
-* Fix segfault when we set a little bit too high CIDR on the function `IPv6CIDRToRange`. [#6068](https://github.com/yandex/ClickHouse/pull/6068) ([Guillaume Tassery](https://github.com/YiuRULE))
-* Fix the situation when Kafka consumer got paused before subscription and not resumed afterwards. [#6075](https://github.com/yandex/ClickHouse/pull/6075) ([Ivan](https://github.com/abyss7))
-* Fixed useless and incorrect condition on update field for initial loading of external dictionaries via ODBC, MySQL, ClickHouse and HTTP. This fixes [#6069](https://github.com/yandex/ClickHouse/issues/6069). [#6083](https://github.com/yandex/ClickHouse/pull/6083) ([alexey-milovidov](https://github.com/alexey-milovidov))
-* Fixed irrelevant exception in cast of `LowCardinality(Nullable)` to not-Nullable column in case if it doesn't contain Nulls (e.g. in query like `SELECT CAST(CAST('Hello' AS LowCardinality(Nullable(String))) AS String)`. This fixes [#6094](https://github.com/yandex/ClickHouse/issues/6094). [#6119](https://github.com/yandex/ClickHouse/pull/6119) ([Nikolai Kochetov](https://github.com/KochetovNicolai))
-* Fix bug with writing secondary indices marks with adaptive granularity. [#6126](https://github.com/yandex/ClickHouse/pull/6126) ([alesapin](https://github.com/alesapin))
+* Throws an exception if `config.d` file doesn't have the corresponding root element as the config file [#6123](https://github.com/yandex/ClickHouse/pull/6123) ([dimarub2000](https://github.com/dimarub2000))
 
 ### Improvement
-* The setting `input_format_defaults_for_omitted_fields` is enabled by default. It enables calculation of complex default expressions for ommitted fields in `JSONEachRow` format. It should be the expected behaviour but may lead to neglible performance difference or subtle incompatibilities. [#6043](https://github.com/yandex/ClickHouse/pull/6043) ([Artem Zuikov](https://github.com/4ertus2))
+* The setting `input_format_defaults_for_omitted_fields` is enabled by default. It enables calculation of complex default expressions for omitted fields in `JSONEachRow` and `CSV*` formats. It should be the expected behaviour but may lead to negligible performance difference or subtle incompatibilities. [#6043](https://github.com/yandex/ClickHouse/pull/6043) ([Artem Zuikov](https://github.com/4ertus2)), [#5625](https://github.com/yandex/ClickHouse/pull/5625) ([akuzm](https://github.com/akuzm))
 
 ### Performance Improvement
-* Optimize `count()` [#6028](https://github.com/yandex/ClickHouse/pull/6028) ([Amos Bird](https://github.com/amosbird))
+* Optimize `count()`. Now it uses the smallest column (if possible). [#6028](https://github.com/yandex/ClickHouse/pull/6028) ([Amos Bird](https://github.com/amosbird))
 
 ### Build/Testing/Packaging Improvement
-* Fixed MSan report. [#6144](https://github.com/yandex/ClickHouse/pull/6144) ([alexey-milovidov](https://github.com/alexey-milovidov))
 * Report memory usage in performance tests. [#5899](https://github.com/yandex/ClickHouse/pull/5899) ([akuzm](https://github.com/akuzm))
-* Add ability to sign .rpm clickhouse packages. [#5977](https://github.com/yandex/ClickHouse/pull/5977) ([alesapin](https://github.com/alesapin))
-* Add dependencies for RPM packages [#6023](https://github.com/yandex/ClickHouse/pull/6023) ([alesapin](https://github.com/alesapin))
 * Fix build with external `libcxx` [#6010](https://github.com/yandex/ClickHouse/pull/6010) ([Ivan](https://github.com/abyss7))
 * Fix shared build with `rdkafka` library [#6101](https://github.com/yandex/ClickHouse/pull/6101) ([Ivan](https://github.com/abyss7))
 
@@ -53,7 +42,7 @@
 * Fix bug with enabling adaptive granularity when creating new replica for `Replicated*MergeTree` table. [#6452](https://github.com/yandex/ClickHouse/pull/6452) ([alesapin](https://github.com/alesapin))
 * Fix infinite loop when reading Kafka messages. [#6354](https://github.com/yandex/ClickHouse/pull/6354) ([abyss7](https://github.com/abyss7))
 * Fixed the possibility of a fabricated query to cause server crash due to stack overflow in SQL parser and possibility of stack overflow in `Merge` and `Distributed` tables [#6433](https://github.com/yandex/ClickHouse/pull/6433) ([alexey-milovidov](https://github.com/alexey-milovidov))
-* Fixed Gorilla encoding error on small sequences. [#6344](https://github.com/yandex/ClickHouse/pull/6444) ([Enmk](https://github.com/Enmk))
+* Fixed Gorilla encoding error on small sequences. [#6444](https://github.com/yandex/ClickHouse/pull/6444) ([Enmk](https://github.com/Enmk))
 
 ### Improvement
 * Allow user to override `poll_interval` and `idle_connection_timeout` settings on connection. [#6230](https://github.com/yandex/ClickHouse/pull/6230) ([alexey-milovidov](https://github.com/alexey-milovidov))

From c70d5851698ea36c77866b1f058631d56d390aeb Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=93=D0=B5=D0=BE=D1=80=D0=B3=D0=B8=D0=B9=20=D0=9A=D0=BE?=
 =?UTF-8?q?=D0=BD=D0=B4=D1=80=D0=B0=D1=82=D1=8C=D0=B5=D0=B2?=
 <orivej@yandex-team.ru>
Date: Mon, 19 Aug 2019 05:13:39 +0000
Subject: [PATCH 079/107] DEVTOOLS-5755 Remove odbc-bridge.cpp from
 clickhouse-lib

odbc-bridge.cpp defines main() so it should not be included in clickhouse-lib.
---
 dbms/programs/odbc-bridge/CMakeLists.txt | 1 -
 1 file changed, 1 deletion(-)

diff --git a/dbms/programs/odbc-bridge/CMakeLists.txt b/dbms/programs/odbc-bridge/CMakeLists.txt
index 060a36e9275..444d6e8d8e0 100644
--- a/dbms/programs/odbc-bridge/CMakeLists.txt
+++ b/dbms/programs/odbc-bridge/CMakeLists.txt
@@ -5,7 +5,6 @@ set(CLICKHOUSE_ODBC_BRIDGE_SOURCES
     ${CMAKE_CURRENT_SOURCE_DIR}/IdentifierQuoteHandler.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/MainHandler.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/ODBCBlockInputStream.cpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/odbc-bridge.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/ODBCBridge.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/PingHandler.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/validateODBCConnectionString.cpp

From 4c45ce3038808aef468edc95fa9f8bb16f21c4bd Mon Sep 17 00:00:00 2001
From: Nikolai Kochetov <nik-kochetov@yandex-team.ru>
Date: Mon, 19 Aug 2019 12:47:08 +0300
Subject: [PATCH 080/107] Apply patches to Live View tests.

---
 .../queries/0_stateless/helpers/client.py     | 35 +++++++++++++------
 .../queries/0_stateless/helpers/uexpect.py    |  3 +-
 2 files changed, 26 insertions(+), 12 deletions(-)

diff --git a/dbms/tests/queries/0_stateless/helpers/client.py b/dbms/tests/queries/0_stateless/helpers/client.py
index de4da794805..f3938d3bf63 100644
--- a/dbms/tests/queries/0_stateless/helpers/client.py
+++ b/dbms/tests/queries/0_stateless/helpers/client.py
@@ -1,5 +1,6 @@
 import os
 import sys
+import time
 
 CURDIR = os.path.dirname(os.path.realpath(__file__))
 
@@ -10,14 +11,26 @@ import uexpect
 prompt = ':\) '
 end_of_block = r'.*\r\n.*\r\n'
 
-def client(command=None, name='', log=None):
-    client = uexpect.spawn(['/bin/bash','--noediting'])
-    if command is None:
-        command = os.environ.get('CLICKHOUSE_BINARY', 'clickhouse') + '-client'
-    client.command = command
-    client.eol('\r')
-    client.logger(log, prefix=name)
-    client.timeout(20)
-    client.expect('[#\$] ', timeout=2)
-    client.send(command)
-    return client
+class client(object):
+    def __init__(self, command=None, name='', log=None):
+        self.client = uexpect.spawn(['/bin/bash','--noediting'])
+        if command is None:
+            command = os.environ.get('CLICKHOUSE_BINARY', 'clickhouse') + '-client'
+        self.client.command = command
+        self.client.eol('\r')
+        self.client.logger(log, prefix=name)
+        self.client.timeout(20)
+        self.client.expect('[#\$] ', timeout=2)
+        self.client.send(command)
+
+    def __enter__(self):
+        return self.client.__enter__()
+
+    def __exit__(self, type, value, traceback):
+        self.client.reader['kill_event'].set()
+        # send Ctrl-C
+        self.client.send('\x03', eol='')
+        time.sleep(0.3)
+        self.client.send('quit', eol='\r')
+        self.client.send('\x03', eol='')
+        return self.client.__exit__(type, value, traceback)
diff --git a/dbms/tests/queries/0_stateless/helpers/uexpect.py b/dbms/tests/queries/0_stateless/helpers/uexpect.py
index d65190e2b29..930a45a099e 100644
--- a/dbms/tests/queries/0_stateless/helpers/uexpect.py
+++ b/dbms/tests/queries/0_stateless/helpers/uexpect.py
@@ -189,6 +189,7 @@ def spawn(command):
     queue = Queue()
     reader_kill_event = Event()
     thread = Thread(target=reader, args=(process, master, queue, reader_kill_event))
+    thread.daemon = True
     thread.start()
 
     return IO(process, master, queue, reader={'thread':thread, 'kill_event':reader_kill_event})
@@ -199,6 +200,6 @@ def reader(process, out, queue, kill_event):
             data = os.read(out, 65536)
             queue.put(data)
         except OSError, e:
-            if e.errno == 5 and kill_event.is_set():
+            if kill_event.is_set():
                 break
             raise

From 6d29ed99d9b0270dc6e14438f914bd5f04fef001 Mon Sep 17 00:00:00 2001
From: alesapin <alesapin@gmail.com>
Date: Mon, 19 Aug 2019 13:37:04 +0300
Subject: [PATCH 081/107] Fix bug with enable_mixed_granularity_parts and
 mutations

---
 .../MergeTree/IMergedBlockOutputStream.cpp        | 15 ++++++++-------
 .../Storages/MergeTree/IMergedBlockOutputStream.h |  5 ++++-
 dbms/src/Storages/MergeTree/MergeTreeData.cpp     |  3 ++-
 .../MergeTree/MergeTreeDataMergerMutator.cpp      |  4 +++-
 .../MergeTree/MergedColumnOnlyOutputStream.cpp    |  6 ++++--
 .../MergeTree/MergedColumnOnlyOutputStream.h      |  3 ++-
 .../integration/test_adaptive_granularity/test.py | 11 +++++++++++
 7 files changed, 34 insertions(+), 13 deletions(-)

diff --git a/dbms/src/Storages/MergeTree/IMergedBlockOutputStream.cpp b/dbms/src/Storages/MergeTree/IMergedBlockOutputStream.cpp
index 4109a5511af..407fcb18ad5 100644
--- a/dbms/src/Storages/MergeTree/IMergedBlockOutputStream.cpp
+++ b/dbms/src/Storages/MergeTree/IMergedBlockOutputStream.cpp
@@ -25,25 +25,26 @@ IMergedBlockOutputStream::IMergedBlockOutputStream(
     size_t aio_threshold_,
     bool blocks_are_granules_size_,
     const std::vector<MergeTreeIndexPtr> & indices_to_recalc,
-    const MergeTreeIndexGranularity & index_granularity_)
+    const MergeTreeIndexGranularity & index_granularity_,
+    const MergeTreeIndexGranularityInfo * index_granularity_info_)
     : storage(storage_)
     , part_path(part_path_)
     , min_compress_block_size(min_compress_block_size_)
     , max_compress_block_size(max_compress_block_size_)
     , aio_threshold(aio_threshold_)
-    , marks_file_extension(storage.canUseAdaptiveGranularity() ? getAdaptiveMrkExtension() : getNonAdaptiveMrkExtension())
+    , can_use_adaptive_granularity(index_granularity_info_ ? index_granularity_info_->is_adaptive : storage.canUseAdaptiveGranularity())
+    , marks_file_extension(can_use_adaptive_granularity ? getAdaptiveMrkExtension() : getNonAdaptiveMrkExtension())
     , blocks_are_granules_size(blocks_are_granules_size_)
     , index_granularity(index_granularity_)
     , compute_granularity(index_granularity.empty())
     , codec(std::move(codec_))
     , skip_indices(indices_to_recalc)
-    , with_final_mark(storage.settings.write_final_mark && storage.canUseAdaptiveGranularity())
+    , with_final_mark(storage.settings.write_final_mark && can_use_adaptive_granularity)
 {
     if (blocks_are_granules_size && !index_granularity.empty())
         throw Exception("Can't take information about index granularity from blocks, when non empty index_granularity array specified", ErrorCodes::LOGICAL_ERROR);
 }
 
-
 void IMergedBlockOutputStream::addStreams(
     const String & path,
     const String & name,
@@ -145,7 +146,7 @@ void IMergedBlockOutputStream::fillIndexGranularity(const Block & block)
         blocks_are_granules_size,
         index_offset,
         index_granularity,
-        storage.canUseAdaptiveGranularity());
+        can_use_adaptive_granularity);
 }
 
 void IMergedBlockOutputStream::writeSingleMark(
@@ -176,7 +177,7 @@ void IMergedBlockOutputStream::writeSingleMark(
 
          writeIntBinary(stream.plain_hashing.count(), stream.marks);
          writeIntBinary(stream.compressed.offset(), stream.marks);
-         if (storage.canUseAdaptiveGranularity())
+         if (can_use_adaptive_granularity)
              writeIntBinary(number_of_rows, stream.marks);
      }, path);
 }
@@ -362,7 +363,7 @@ void IMergedBlockOutputStream::calculateAndSerializeSkipIndices(
                     writeIntBinary(stream.compressed.offset(), stream.marks);
                     /// Actually this numbers is redundant, but we have to store them
                     /// to be compatible with normal .mrk2 file format
-                    if (storage.canUseAdaptiveGranularity())
+                    if (can_use_adaptive_granularity)
                         writeIntBinary(1UL, stream.marks);
 
                     ++skip_index_current_mark;
diff --git a/dbms/src/Storages/MergeTree/IMergedBlockOutputStream.h b/dbms/src/Storages/MergeTree/IMergedBlockOutputStream.h
index cbf78c1a2ea..97c7922042d 100644
--- a/dbms/src/Storages/MergeTree/IMergedBlockOutputStream.h
+++ b/dbms/src/Storages/MergeTree/IMergedBlockOutputStream.h
@@ -1,6 +1,7 @@
 #pragma once
 
 #include <Storages/MergeTree/MergeTreeIndexGranularity.h>
+#include <Storages/MergeTree/MergeTreeIndexGranularityInfo.h>
 #include <IO/WriteBufferFromFile.h>
 #include <Compression/CompressedWriteBuffer.h>
 #include <IO/HashingWriteBuffer.h>
@@ -23,7 +24,8 @@ public:
         size_t aio_threshold_,
         bool blocks_are_granules_size_,
         const std::vector<MergeTreeIndexPtr> & indices_to_recalc,
-        const MergeTreeIndexGranularity & index_granularity_);
+        const MergeTreeIndexGranularity & index_granularity_,
+        const MergeTreeIndexGranularityInfo * index_granularity_info_ = nullptr);
 
     using WrittenOffsetColumns = std::set<std::string>;
 
@@ -141,6 +143,7 @@ protected:
     size_t current_mark = 0;
     size_t skip_index_mark = 0;
 
+    const bool can_use_adaptive_granularity;
     const std::string marks_file_extension;
     const bool blocks_are_granules_size;
 
diff --git a/dbms/src/Storages/MergeTree/MergeTreeData.cpp b/dbms/src/Storages/MergeTree/MergeTreeData.cpp
index 3b57c27d3e9..d8871b9e1a8 100644
--- a/dbms/src/Storages/MergeTree/MergeTreeData.cpp
+++ b/dbms/src/Storages/MergeTree/MergeTreeData.cpp
@@ -1581,7 +1581,8 @@ void MergeTreeData::alterDataPart(
             true /* skip_offsets */,
             {},
             unused_written_offsets,
-            part->index_granularity);
+            part->index_granularity,
+            &part->index_granularity_info);
 
         in.readPrefix();
         out.writePrefix();
diff --git a/dbms/src/Storages/MergeTree/MergeTreeDataMergerMutator.cpp b/dbms/src/Storages/MergeTree/MergeTreeDataMergerMutator.cpp
index 19d775890d8..74193fa7156 100644
--- a/dbms/src/Storages/MergeTree/MergeTreeDataMergerMutator.cpp
+++ b/dbms/src/Storages/MergeTree/MergeTreeDataMergerMutator.cpp
@@ -934,6 +934,7 @@ MergeTreeData::MutableDataPartPtr MergeTreeDataMergerMutator::mutatePartToTempor
     new_data_part->relative_path = "tmp_mut_" + future_part.name;
     new_data_part->is_temp = true;
     new_data_part->ttl_infos = source_part->ttl_infos;
+    new_data_part->index_granularity_info = source_part->index_granularity_info;
 
     String new_part_tmp_path = new_data_part->getFullPath();
 
@@ -1069,7 +1070,8 @@ MergeTreeData::MutableDataPartPtr MergeTreeDataMergerMutator::mutatePartToTempor
             /* skip_offsets = */ false,
             std::vector<MergeTreeIndexPtr>(indices_to_recalc.begin(), indices_to_recalc.end()),
             unused_written_offsets,
-            source_part->index_granularity
+            source_part->index_granularity,
+            &source_part->index_granularity_info
         );
 
         in->readPrefix();
diff --git a/dbms/src/Storages/MergeTree/MergedColumnOnlyOutputStream.cpp b/dbms/src/Storages/MergeTree/MergedColumnOnlyOutputStream.cpp
index e79ec7dd046..3c15bd54df2 100644
--- a/dbms/src/Storages/MergeTree/MergedColumnOnlyOutputStream.cpp
+++ b/dbms/src/Storages/MergeTree/MergedColumnOnlyOutputStream.cpp
@@ -8,14 +8,16 @@ MergedColumnOnlyOutputStream::MergedColumnOnlyOutputStream(
     CompressionCodecPtr default_codec_, bool skip_offsets_,
     const std::vector<MergeTreeIndexPtr> & indices_to_recalc_,
     WrittenOffsetColumns & already_written_offset_columns_,
-    const MergeTreeIndexGranularity & index_granularity_)
+    const MergeTreeIndexGranularity & index_granularity_,
+    const MergeTreeIndexGranularityInfo * index_granularity_info_)
     : IMergedBlockOutputStream(
         storage_, part_path_, storage_.global_context.getSettings().min_compress_block_size,
         storage_.global_context.getSettings().max_compress_block_size, default_codec_,
         storage_.global_context.getSettings().min_bytes_to_use_direct_io,
         false,
         indices_to_recalc_,
-        index_granularity_),
+        index_granularity_,
+        index_granularity_info_),
     header(header_), sync(sync_), skip_offsets(skip_offsets_),
     already_written_offset_columns(already_written_offset_columns_)
 {
diff --git a/dbms/src/Storages/MergeTree/MergedColumnOnlyOutputStream.h b/dbms/src/Storages/MergeTree/MergedColumnOnlyOutputStream.h
index b8d637f37fb..8970bf19565 100644
--- a/dbms/src/Storages/MergeTree/MergedColumnOnlyOutputStream.h
+++ b/dbms/src/Storages/MergeTree/MergedColumnOnlyOutputStream.h
@@ -17,7 +17,8 @@ public:
         CompressionCodecPtr default_codec_, bool skip_offsets_,
         const std::vector<MergeTreeIndexPtr> & indices_to_recalc_,
         WrittenOffsetColumns & already_written_offset_columns_,
-        const MergeTreeIndexGranularity & index_granularity_);
+        const MergeTreeIndexGranularity & index_granularity_,
+        const MergeTreeIndexGranularityInfo * index_granularity_info_ = nullptr);
 
     Block getHeader() const override { return header; }
     void write(const Block & block) override;
diff --git a/dbms/tests/integration/test_adaptive_granularity/test.py b/dbms/tests/integration/test_adaptive_granularity/test.py
index db653427f02..50b43fc08ec 100644
--- a/dbms/tests/integration/test_adaptive_granularity/test.py
+++ b/dbms/tests/integration/test_adaptive_granularity/test.py
@@ -288,6 +288,17 @@ def test_mixed_granularity_single_node(start_dynamic_cluster, node):
 
     node.exec_in_container(["bash", "-c", "find {p} -name '*.mrk' | grep '.*'".format(p=path_to_old_part)]) # check that we have non adaptive files
 
+    node.query("ALTER TABLE table_with_default_granularity UPDATE dummy = dummy + 1 WHERE 1")
+    # still works
+    assert node.query("SELECT count() from table_with_default_granularity") == '6\n'
+
+    node.query("ALTER TABLE table_with_default_granularity MODIFY COLUMN dummy String")
+    node.query("ALTER TABLE table_with_default_granularity ADD COLUMN dummy2 Float64")
+
+    #still works
+    assert node.query("SELECT count() from table_with_default_granularity") == '6\n'
+
+
 def test_version_update_two_nodes(start_dynamic_cluster):
     node11.query("INSERT INTO table_with_default_granularity VALUES (toDate('2018-10-01'), 1, 333), (toDate('2018-10-02'), 2, 444)")
     node12.query("SYSTEM SYNC REPLICA table_with_default_granularity")

From a33c59d83b618450ba31df29fb3aeee31810c476 Mon Sep 17 00:00:00 2001
From: Nikolai Kochetov <nik-kochetov@yandex-team.ru>
Date: Mon, 19 Aug 2019 14:08:10 +0300
Subject: [PATCH 082/107] Update Live View test.

---
 .../00991_live_view_watch_http.python         | 31 +++++++------------
 .../00991_live_view_watch_http.reference      |  4 +++
 2 files changed, 15 insertions(+), 20 deletions(-)

diff --git a/dbms/tests/queries/0_stateless/00991_live_view_watch_http.python b/dbms/tests/queries/0_stateless/00991_live_view_watch_http.python
index 2f46aa11046..938547ca0cb 100755
--- a/dbms/tests/queries/0_stateless/00991_live_view_watch_http.python
+++ b/dbms/tests/queries/0_stateless/00991_live_view_watch_http.python
@@ -16,19 +16,16 @@ def send_query(query):
     cmd = list(CLICKHOUSE_CLIENT.split())
     cmd += ['--query', query]
     # print(cmd)
-    return subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
+    return subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT).stdout
 
 
 def send_http_query(query):
     cmd =  list(CLICKHOUSE_CURL.split()) # list(['curl', '-sSN', '--max-time', '10'])
     cmd += ['-sSN', CLICKHOUSE_URL, '-d', query]
-    return subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
+    return subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT).stdout
 
 
-def read_lines_and_push_to_queue(p, queue):
-    pipe = p.stdout
-    sys.stdout.flush()
-
+def read_lines_and_push_to_queue(pipe, queue):
     for line in iter(pipe.readline, ''):
         line = line.strip()
         print(line)
@@ -36,14 +33,13 @@ def read_lines_and_push_to_queue(p, queue):
         queue.put(line)
 
     queue.put(None)
-    p.wait()
 
 
 def test():
-    send_query('DROP TABLE IF EXISTS test.lv').stdout.read()
-    send_query('DROP TABLE IF EXISTS test.mt').stdout.read()
-    send_query('CREATE TABLE test.mt (a Int32) Engine=MergeTree order by tuple()').stdout.read()
-    send_query('CREATE LIVE VIEW test.lv AS SELECT sum(a) FROM test.mt').stdout.read()
+    send_query('DROP TABLE IF EXISTS test.lv').read()
+    send_query('DROP TABLE IF EXISTS test.mt').read()
+    send_query('CREATE TABLE test.mt (a Int32) Engine=MergeTree order by tuple()').read()
+    send_query('CREATE LIVE VIEW test.lv AS SELECT sum(a) FROM test.mt').read()
 
     q = queue.Queue()
     pipe = send_http_query('WATCH test.lv')
@@ -54,19 +50,14 @@ def test():
     print(line)
     assert (line == '0\t1')
 
-    p = send_query('INSERT INTO test.mt VALUES (1),(2),(3)')
-    p.stdout.read()
-    p.wait()
+    send_query('INSERT INTO test.mt VALUES (1),(2),(3)').read()
     line = q.get()
     print(line)
     assert (line == '6\t2')
 
-    p = send_query('DROP TABLE if exitst test.lv')
-    p.stdout.read()
-    p.wait()
-    p = send_query('DROP TABLE if exitst test.mt')
-    p.stdout.read()
-    p.wait()
+    send_query('DROP TABLE if exists test.lv').read()
+    send_query('DROP TABLE if exists test.lv').read()
+
     thread.join()
 
 test()
diff --git a/dbms/tests/queries/0_stateless/00991_live_view_watch_http.reference b/dbms/tests/queries/0_stateless/00991_live_view_watch_http.reference
index e69de29bb2d..489457d751b 100644
--- a/dbms/tests/queries/0_stateless/00991_live_view_watch_http.reference
+++ b/dbms/tests/queries/0_stateless/00991_live_view_watch_http.reference
@@ -0,0 +1,4 @@
+0	1
+0	1
+6	2
+6	2

From 6991683a5f6c72dc465528905f8c46253558e73e Mon Sep 17 00:00:00 2001
From: Alexander Tokmakov <avtokmakov@yandex-team.ru>
Date: Mon, 19 Aug 2019 15:06:44 +0300
Subject: [PATCH 083/107] remove local parts which source replica doesnt have

---
 .../Storages/StorageReplicatedMergeTree.cpp   | 31 +++++++++++++++++--
 .../__init__.py                               |  0
 .../configs/remote_servers.xml                |  0
 .../test.py                                   |  7 +++--
 4 files changed, 33 insertions(+), 5 deletions(-)
 rename dbms/tests/integration/{test_inconsistent_parts_after_clone_replica => test_consistent_parts_after_clone_replica}/__init__.py (100%)
 rename dbms/tests/integration/{test_inconsistent_parts_after_clone_replica => test_consistent_parts_after_clone_replica}/configs/remote_servers.xml (100%)
 rename dbms/tests/integration/{test_inconsistent_parts_after_clone_replica => test_consistent_parts_after_clone_replica}/test.py (93%)

diff --git a/dbms/src/Storages/StorageReplicatedMergeTree.cpp b/dbms/src/Storages/StorageReplicatedMergeTree.cpp
index a436d426202..8ba8daca413 100644
--- a/dbms/src/Storages/StorageReplicatedMergeTree.cpp
+++ b/dbms/src/Storages/StorageReplicatedMergeTree.cpp
@@ -1942,10 +1942,37 @@ void StorageReplicatedMergeTree::cloneReplica(const String & source_replica, Coo
     }
 
     /// Add to the queue jobs to receive all the active parts that the reference/master replica has.
-    Strings parts = zookeeper->getChildren(source_path + "/parts");
-    ActiveDataPartSet active_parts_set(format_version, parts);
+    Strings source_replica_parts = zookeeper->getChildren(source_path + "/parts");
+    ActiveDataPartSet active_parts_set(format_version, source_replica_parts);
 
     Strings active_parts = active_parts_set.getParts();
+
+    /// Remove local parts if source replica does not have them, because such parts will never be fetched by other replicas.
+    Strings local_parts_in_zk = zookeeper->getChildren(replica_path + "/parts");
+    Strings parts_to_remove_from_zk;
+    for (const auto & part : local_parts_in_zk)
+    {
+        if (active_parts_set.getContainingPart(part).empty())
+        {
+            queue.remove(zookeeper, part);
+            parts_to_remove_from_zk.emplace_back(part);
+            LOG_WARNING(log, "Source replica does not have part " << part << ". Removing it from ZooKeeper.");
+        }
+    }
+    tryRemovePartsFromZooKeeperWithRetries(parts_to_remove_from_zk);
+
+    auto local_active_parts = getDataParts();
+    DataPartsVector parts_to_remove_from_working_set;
+    for (const auto & part : local_active_parts)
+    {
+        if (active_parts_set.getContainingPart(part->name).empty())
+        {
+            parts_to_remove_from_working_set.emplace_back(part);
+            LOG_WARNING(log, "Source replica does not have part " << part->name << ". Removing it from working set.");
+        }
+    }
+    removePartsFromWorkingSet(parts_to_remove_from_working_set, true);
+
     for (const String & name : active_parts)
     {
         LogEntry log_entry;
diff --git a/dbms/tests/integration/test_inconsistent_parts_after_clone_replica/__init__.py b/dbms/tests/integration/test_consistent_parts_after_clone_replica/__init__.py
similarity index 100%
rename from dbms/tests/integration/test_inconsistent_parts_after_clone_replica/__init__.py
rename to dbms/tests/integration/test_consistent_parts_after_clone_replica/__init__.py
diff --git a/dbms/tests/integration/test_inconsistent_parts_after_clone_replica/configs/remote_servers.xml b/dbms/tests/integration/test_consistent_parts_after_clone_replica/configs/remote_servers.xml
similarity index 100%
rename from dbms/tests/integration/test_inconsistent_parts_after_clone_replica/configs/remote_servers.xml
rename to dbms/tests/integration/test_consistent_parts_after_clone_replica/configs/remote_servers.xml
diff --git a/dbms/tests/integration/test_inconsistent_parts_after_clone_replica/test.py b/dbms/tests/integration/test_consistent_parts_after_clone_replica/test.py
similarity index 93%
rename from dbms/tests/integration/test_inconsistent_parts_after_clone_replica/test.py
rename to dbms/tests/integration/test_consistent_parts_after_clone_replica/test.py
index c1513798189..b8a58242ad1 100644
--- a/dbms/tests/integration/test_inconsistent_parts_after_clone_replica/test.py
+++ b/dbms/tests/integration/test_consistent_parts_after_clone_replica/test.py
@@ -36,7 +36,8 @@ def start_cluster():
 def test_inconsistent_parts_if_drop_while_replica_not_active(start_cluster):
     with PartitionManager() as pm:
         # insert into all replicas
-        node1.query("INSERT INTO test_table VALUES ('2019-08-16', 100)")
+        for i in range(50):
+            node1.query("INSERT INTO test_table VALUES ('2019-08-16', {})".format(i))
         assert_eq_with_retry(node2, "SELECT count(*) FROM test_table", node1.query("SELECT count(*) FROM test_table"))
 
         # disable network on the first replica
@@ -49,8 +50,8 @@ def test_inconsistent_parts_if_drop_while_replica_not_active(start_cluster):
 
         # insert into the second replica
         # DROP_RANGE will be removed from the replication log and the first replica will be lost
-        for i in range(100):
-            node2.query("INSERT INTO test_table VALUES ('2019-08-16', {})".format(i))
+        for i in range(50):
+            node2.query("INSERT INTO test_table VALUES ('2019-08-16', {})".format(50 + i))
 
         # the first replica will be cloned from the second
         pm.heal_all()

From 646071f360525f831cc5f8066dbcfc3f1b853935 Mon Sep 17 00:00:00 2001
From: Ivan Blinkov <github@blinkov.ru>
Date: Mon, 19 Aug 2019 16:13:58 +0300
Subject: [PATCH 084/107] Update roadmap.md (#6545)

---
 docs/en/roadmap.md | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/docs/en/roadmap.md b/docs/en/roadmap.md
index 34307e519b0..11f1f793235 100644
--- a/docs/en/roadmap.md
+++ b/docs/en/roadmap.md
@@ -1,15 +1,14 @@
 # Roadmap
 
-## Q2 2019
+## Q3 2019
 
 - DDL for dictionaries
 - Integration with S3-like object stores
 - Multiple storages for hot/cold data, JBOD support
 
-## Q3 2019
+## Q4 2019
 
-- JOIN execution improvements:
-    - Distributed join not limited by memory
+- JOIN not limited by available memory
 - Resource pools for more precise distribution of cluster capacity between users
 - Fine-grained authorization
 - Integration with external authentication services

From 7e600ccc06fa107bfee18a9604422570c63df1da Mon Sep 17 00:00:00 2001
From: Ivan Blinkov <github@blinkov.ru>
Date: Mon, 19 Aug 2019 16:15:46 +0300
Subject: [PATCH 085/107] revert #6544 (#6547)


From 619ee4489ec4387e06cddfa9a8e37375df329572 Mon Sep 17 00:00:00 2001
From: Nikolai Kochetov <nik-kochetov@yandex-team.ru>
Date: Mon, 19 Aug 2019 16:26:37 +0300
Subject: [PATCH 086/107] Added 00991_live_view_watch_event_live.

---
 .../00991_live_view_watch_event_live.python   | 81 +++++++++++++++++++
 ...00991_live_view_watch_event_live.reference |  8 ++
 .../00991_live_view_watch_event_live.sh       |  6 ++
 3 files changed, 95 insertions(+)
 create mode 100644 dbms/tests/queries/0_stateless/00991_live_view_watch_event_live.python
 create mode 100644 dbms/tests/queries/0_stateless/00991_live_view_watch_event_live.reference
 create mode 100755 dbms/tests/queries/0_stateless/00991_live_view_watch_event_live.sh

diff --git a/dbms/tests/queries/0_stateless/00991_live_view_watch_event_live.python b/dbms/tests/queries/0_stateless/00991_live_view_watch_event_live.python
new file mode 100644
index 00000000000..6f2e55f72e6
--- /dev/null
+++ b/dbms/tests/queries/0_stateless/00991_live_view_watch_event_live.python
@@ -0,0 +1,81 @@
+#!/usr/bin/env python
+
+import subprocess
+import threading
+import Queue as queue
+import os
+import sys
+import signal
+
+
+CLICKHOUSE_CLIENT = os.environ.get('CLICKHOUSE_CLIENT')
+CLICKHOUSE_CURL = os.environ.get('CLICKHOUSE_CURL')
+CLICKHOUSE_URL = os.environ.get('CLICKHOUSE_URL')
+
+
+def send_query(query):
+    cmd = list(CLICKHOUSE_CLIENT.split())
+    cmd += ['--query', query]
+    # print(cmd)
+    return subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT).stdout
+
+
+def send_query_in_process_group(query):
+    cmd = list(CLICKHOUSE_CLIENT.split())
+    cmd += ['--query', query]
+    print(cmd)
+    return subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, preexec_fn=os.setsid)
+
+
+def read_lines_and_push_to_queue(pipe, queue):
+    try:
+        for line in iter(pipe.readline, ''):
+            line = line.strip()
+            print(line)
+            sys.stdout.flush()
+            queue.put(line)
+    except KeyboardInterrupt:
+        pass
+
+    queue.put(None)
+
+
+def test():
+    send_query('DROP TABLE IF EXISTS test.lv').read()
+    send_query('DROP TABLE IF EXISTS test.mt').read()
+    send_query('CREATE TABLE test.mt (a Int32) Engine=MergeTree order by tuple()').read()
+    send_query('CREATE LIVE VIEW test.lv AS SELECT sum(a) FROM test.mt').read()
+
+    q = queue.Queue()
+    p = send_query_in_process_group('WATCH test.lv')
+    thread = threading.Thread(target=read_lines_and_push_to_queue, args=(p.stdout, q))
+    thread.start()
+
+    line = q.get()
+    print(line)
+    assert (line == '0\t1')
+
+    send_query('INSERT INTO test.mt VALUES (1),(2),(3)').read()
+    line = q.get()
+    print(line)
+    assert (line == '6\t2')
+
+    send_query('INSERT INTO test.mt VALUES (4),(5),(6)').read()
+    line = q.get()
+    print(line)
+    assert (line == '21\t3')
+
+    # Send Ctrl+C to client.
+    os.killpg(os.getpgid(p.pid), signal.SIGINT)
+    # This insert shouldn't affect lv.
+    send_query('INSERT INTO test.mt VALUES (7),(8),(9)').read()
+    line = q.get()
+    print(line)
+    assert (line is None)
+
+    send_query('DROP TABLE if exists test.lv').read()
+    send_query('DROP TABLE if exists test.lv').read()
+
+    thread.join()
+
+test()
diff --git a/dbms/tests/queries/0_stateless/00991_live_view_watch_event_live.reference b/dbms/tests/queries/0_stateless/00991_live_view_watch_event_live.reference
new file mode 100644
index 00000000000..e48dcf35d3e
--- /dev/null
+++ b/dbms/tests/queries/0_stateless/00991_live_view_watch_event_live.reference
@@ -0,0 +1,8 @@
+['/home/nik-kochetov/dev/ClickHouse/build-tsan/dbms/programs/clickhouse', 'client', '--send_logs_level=warning', '--database=default', '--query', 'WATCH test.lv']
+0	1
+0	1
+6	2
+6	2
+21	3
+21	3
+None
diff --git a/dbms/tests/queries/0_stateless/00991_live_view_watch_event_live.sh b/dbms/tests/queries/0_stateless/00991_live_view_watch_event_live.sh
new file mode 100755
index 00000000000..10e4e98b2e3
--- /dev/null
+++ b/dbms/tests/queries/0_stateless/00991_live_view_watch_event_live.sh
@@ -0,0 +1,6 @@
+#!/usr/bin/env bash
+
+CURDIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
+. $CURDIR/../shell_config.sh
+
+python $CURDIR/00991_live_view_watch_event_live.python

From e188ae40ceea110463a4d58f644e96d35b71be3d Mon Sep 17 00:00:00 2001
From: Nikolai Kochetov <nik-kochetov@yandex-team.ru>
Date: Mon, 19 Aug 2019 16:35:00 +0300
Subject: [PATCH 087/107] Added 00991_temporary_live_view_watch_live.

---
 ...0991_temporary_live_view_watch_live.python | 81 +++++++++++++++++++
 ...1_temporary_live_view_watch_live.reference |  8 ++
 .../00991_temporary_live_view_watch_live.sh   |  6 ++
 3 files changed, 95 insertions(+)
 create mode 100644 dbms/tests/queries/0_stateless/00991_temporary_live_view_watch_live.python
 create mode 100644 dbms/tests/queries/0_stateless/00991_temporary_live_view_watch_live.reference
 create mode 100755 dbms/tests/queries/0_stateless/00991_temporary_live_view_watch_live.sh

diff --git a/dbms/tests/queries/0_stateless/00991_temporary_live_view_watch_live.python b/dbms/tests/queries/0_stateless/00991_temporary_live_view_watch_live.python
new file mode 100644
index 00000000000..341a9f04c56
--- /dev/null
+++ b/dbms/tests/queries/0_stateless/00991_temporary_live_view_watch_live.python
@@ -0,0 +1,81 @@
+#!/usr/bin/env python
+
+import subprocess
+import threading
+import Queue as queue
+import os
+import sys
+import signal
+
+
+CLICKHOUSE_CLIENT = os.environ.get('CLICKHOUSE_CLIENT')
+CLICKHOUSE_CURL = os.environ.get('CLICKHOUSE_CURL')
+CLICKHOUSE_URL = os.environ.get('CLICKHOUSE_URL')
+
+
+def send_query(query):
+    cmd = list(CLICKHOUSE_CLIENT.split())
+    cmd += ['--query', query]
+    # print(cmd)
+    return subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT).stdout
+
+
+def send_query_in_process_group(query):
+    cmd = list(CLICKHOUSE_CLIENT.split())
+    cmd += ['--query', query]
+    print(cmd)
+    return subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, preexec_fn=os.setsid)
+
+
+def read_lines_and_push_to_queue(pipe, queue):
+    try:
+        for line in iter(pipe.readline, ''):
+            line = line.strip()
+            print(line)
+            sys.stdout.flush()
+            queue.put(line)
+    except KeyboardInterrupt:
+        pass
+
+    queue.put(None)
+
+
+def test():
+    send_query('DROP TABLE IF EXISTS test.lv').read()
+    send_query('DROP TABLE IF EXISTS test.mt').read()
+    send_query('CREATE TABLE test.mt (a Int32) Engine=MergeTree order by tuple()').read()
+    send_query('CREATE TEMPORARY LIVE VIEW test.lv AS SELECT sum(a) FROM test.mt').read()
+
+    q = queue.Queue()
+    p = send_query_in_process_group('WATCH test.lv')
+    thread = threading.Thread(target=read_lines_and_push_to_queue, args=(p.stdout, q))
+    thread.start()
+
+    line = q.get()
+    print(line)
+    assert (line == '0\t1')
+
+    send_query('INSERT INTO test.mt VALUES (1),(2),(3)').read()
+    line = q.get()
+    print(line)
+    assert (line == '6\t2')
+
+    send_query('INSERT INTO test.mt VALUES (4),(5),(6)').read()
+    line = q.get()
+    print(line)
+    assert (line == '21\t3')
+
+    # Send Ctrl+C to client.
+    os.killpg(os.getpgid(p.pid), signal.SIGINT)
+    # This insert shouldn't affect lv.
+    send_query('INSERT INTO test.mt VALUES (7),(8),(9)').read()
+    line = q.get()
+    print(line)
+    assert (line is None)
+
+    send_query('DROP TABLE if exists test.lv').read()
+    send_query('DROP TABLE if exists test.lv').read()
+
+    thread.join()
+
+test()
diff --git a/dbms/tests/queries/0_stateless/00991_temporary_live_view_watch_live.reference b/dbms/tests/queries/0_stateless/00991_temporary_live_view_watch_live.reference
new file mode 100644
index 00000000000..e48dcf35d3e
--- /dev/null
+++ b/dbms/tests/queries/0_stateless/00991_temporary_live_view_watch_live.reference
@@ -0,0 +1,8 @@
+['/home/nik-kochetov/dev/ClickHouse/build-tsan/dbms/programs/clickhouse', 'client', '--send_logs_level=warning', '--database=default', '--query', 'WATCH test.lv']
+0	1
+0	1
+6	2
+6	2
+21	3
+21	3
+None
diff --git a/dbms/tests/queries/0_stateless/00991_temporary_live_view_watch_live.sh b/dbms/tests/queries/0_stateless/00991_temporary_live_view_watch_live.sh
new file mode 100755
index 00000000000..4d01d1c3a8e
--- /dev/null
+++ b/dbms/tests/queries/0_stateless/00991_temporary_live_view_watch_live.sh
@@ -0,0 +1,6 @@
+#!/usr/bin/env bash
+
+CURDIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
+. $CURDIR/../shell_config.sh
+
+python $CURDIR/00991_temporary_live_view_watch_live.python

From 943a7480b5829b17f20c47906c083832ff81a231 Mon Sep 17 00:00:00 2001
From: alexey-milovidov <milovidov@yandex-team.ru>
Date: Mon, 19 Aug 2019 16:43:59 +0300
Subject: [PATCH 088/107] Update CHANGELOG.md

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

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 6ec0ea442fc..fe803d3259d 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3,7 +3,7 @@
 ### New Feature
 * Allow to specify a list of columns with `COLUMNS('regexp')` expression that works like a more sophisticated variant of `*` asterisk. [#5951](https://github.com/yandex/ClickHouse/pull/5951)  ([mfridental](https://github.com/mfridental)), ([alexey-milovidov](https://github.com/alexey-milovidov))
 * `CREATE TABLE AS table_function()` is now possible [#6057](https://github.com/yandex/ClickHouse/pull/6057) ([dimarub2000](https://github.com/dimarub2000))
-* Poor man's profiler for each query being executed. It stops query execution thread at random time points to collect current backtrace. After some time a developer can analyze which code points profiler visits most often to find probable efficiency issues. [#4247](https://github.com/yandex/ClickHouse/issues/4247) ([laplab](https://github.com/laplab))
+* Sampling profiler on query level. [Example](https://gist.github.com/alexey-milovidov/92758583dd41c24c360fdb8d6a4da194). [#4247](https://github.com/yandex/ClickHouse/issues/4247) ([laplab](https://github.com/laplab)) [#6124](https://github.com/yandex/ClickHouse/pull/6124) ([alexey-milovidov](https://github.com/alexey-milovidov)) [#6250](https://github.com/yandex/ClickHouse/pull/6250) [#6283](https://github.com/yandex/ClickHouse/pull/6283) [#6386](https://github.com/yandex/ClickHouse/pull/6386) 
 * Adam optimizer for stochastic gradient descent is used by default in `stochasticLinearRegression()` and `stochasticLogisticRegression()` aggregate functions, because it shows good quality without almost any tuning. [#6000](https://github.com/yandex/ClickHouse/pull/6000) ([Quid37](https://github.com/Quid37))
 
 ### Experimental features

From d77c02ecf6ef230d453836e609daba391eb9b62e Mon Sep 17 00:00:00 2001
From: alexey-milovidov <milovidov@yandex-team.ru>
Date: Mon, 19 Aug 2019 16:46:26 +0300
Subject: [PATCH 089/107] Update CHANGELOG.md

---
 CHANGELOG.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index fe803d3259d..d69a6c68e76 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,14 +1,14 @@
 ## ClickHouse release 19.13.2.19, 2019-08-14
 
 ### New Feature
+* Sampling profiler on query level. [Example](https://gist.github.com/alexey-milovidov/92758583dd41c24c360fdb8d6a4da194). [#4247](https://github.com/yandex/ClickHouse/issues/4247) ([laplab](https://github.com/laplab)) [#6124](https://github.com/yandex/ClickHouse/pull/6124) ([alexey-milovidov](https://github.com/alexey-milovidov)) [#6250](https://github.com/yandex/ClickHouse/pull/6250) [#6283](https://github.com/yandex/ClickHouse/pull/6283) [#6386](https://github.com/yandex/ClickHouse/pull/6386) 
 * Allow to specify a list of columns with `COLUMNS('regexp')` expression that works like a more sophisticated variant of `*` asterisk. [#5951](https://github.com/yandex/ClickHouse/pull/5951)  ([mfridental](https://github.com/mfridental)), ([alexey-milovidov](https://github.com/alexey-milovidov))
 * `CREATE TABLE AS table_function()` is now possible [#6057](https://github.com/yandex/ClickHouse/pull/6057) ([dimarub2000](https://github.com/dimarub2000))
-* Sampling profiler on query level. [Example](https://gist.github.com/alexey-milovidov/92758583dd41c24c360fdb8d6a4da194). [#4247](https://github.com/yandex/ClickHouse/issues/4247) ([laplab](https://github.com/laplab)) [#6124](https://github.com/yandex/ClickHouse/pull/6124) ([alexey-milovidov](https://github.com/alexey-milovidov)) [#6250](https://github.com/yandex/ClickHouse/pull/6250) [#6283](https://github.com/yandex/ClickHouse/pull/6283) [#6386](https://github.com/yandex/ClickHouse/pull/6386) 
 * Adam optimizer for stochastic gradient descent is used by default in `stochasticLinearRegression()` and `stochasticLogisticRegression()` aggregate functions, because it shows good quality without almost any tuning. [#6000](https://github.com/yandex/ClickHouse/pull/6000) ([Quid37](https://github.com/Quid37))
+* Added functions for working with the сustom week number [#5212](https://github.com/yandex/ClickHouse/pull/5212) ([Andy Yang](https://github.com/andyyzh))
 
 ### Experimental features
-* Added functions for working with the сustom week number [#5212](https://github.com/yandex/ClickHouse/pull/5212) ([Andy Yang](https://github.com/andyyzh))
-* New query processing pipeline. Use `experimental_use_processors=1` option to enable it. [#4914](https://github.com/yandex/ClickHouse/pull/4914) ([Nikolai Kochetov](https://github.com/KochetovNicolai))
+* New query processing pipeline. Use `experimental_use_processors=1` option to enable it. Use for your own trouble. [#4914](https://github.com/yandex/ClickHouse/pull/4914) ([Nikolai Kochetov](https://github.com/KochetovNicolai))
 
 ### Bug Fix
 * `RENAME` queries now work with all storages. [#5953](https://github.com/yandex/ClickHouse/pull/5953) ([Ivan](https://github.com/abyss7))

From 4ded8deea299ac23e8a20bd1bad32d6cd5fff5c7 Mon Sep 17 00:00:00 2001
From: alexey-milovidov <milovidov@yandex-team.ru>
Date: Mon, 19 Aug 2019 16:48:29 +0300
Subject: [PATCH 090/107] Update CHANGELOG.md

---
 CHANGELOG.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index d69a6c68e76..0f8e8166d21 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -6,19 +6,19 @@
 * `CREATE TABLE AS table_function()` is now possible [#6057](https://github.com/yandex/ClickHouse/pull/6057) ([dimarub2000](https://github.com/dimarub2000))
 * Adam optimizer for stochastic gradient descent is used by default in `stochasticLinearRegression()` and `stochasticLogisticRegression()` aggregate functions, because it shows good quality without almost any tuning. [#6000](https://github.com/yandex/ClickHouse/pull/6000) ([Quid37](https://github.com/Quid37))
 * Added functions for working with the сustom week number [#5212](https://github.com/yandex/ClickHouse/pull/5212) ([Andy Yang](https://github.com/andyyzh))
+* `RENAME` queries now work with all storages. [#5953](https://github.com/yandex/ClickHouse/pull/5953) ([Ivan](https://github.com/abyss7))
+* Now client receive logs from server with any desired level by setting `send_logs_level` regardless to the log level specified in server settings. [#5964](https://github.com/yandex/ClickHouse/pull/5964) ([Nikita Mikhaylov](https://github.com/nikitamikhaylov))
 
 ### Experimental features
 * New query processing pipeline. Use `experimental_use_processors=1` option to enable it. Use for your own trouble. [#4914](https://github.com/yandex/ClickHouse/pull/4914) ([Nikolai Kochetov](https://github.com/KochetovNicolai))
 
 ### Bug Fix
-* `RENAME` queries now work with all storages. [#5953](https://github.com/yandex/ClickHouse/pull/5953) ([Ivan](https://github.com/abyss7))
-* Now client could receive logs from server with any desired level by setting `send_logs_level` regardless to the log level specified in server settings. [#5964](https://github.com/yandex/ClickHouse/pull/5964) ([Nikita Mikhaylov](https://github.com/nikitamikhaylov))
 * Fixed `DoubleDelta` encoding of `Int64` for large `DoubleDelta` values, improved `DoubleDelta` encoding for random data for `Int32`. [#5998](https://github.com/yandex/ClickHouse/pull/5998) ([Vasily Nemkov](https://github.com/Enmk))
 * Fixed overestimation of `max_rows_to_read` if the setting `merge_tree_uniform_read_distribution` is set to 0. [#6019](https://github.com/yandex/ClickHouse/pull/6019) ([alexey-milovidov](https://github.com/alexey-milovidov))
-* Throws an exception if `config.d` file doesn't have the corresponding root element as the config file [#6123](https://github.com/yandex/ClickHouse/pull/6123) ([dimarub2000](https://github.com/dimarub2000))
 
 ### Improvement
 * The setting `input_format_defaults_for_omitted_fields` is enabled by default. It enables calculation of complex default expressions for omitted fields in `JSONEachRow` and `CSV*` formats. It should be the expected behaviour but may lead to negligible performance difference or subtle incompatibilities. [#6043](https://github.com/yandex/ClickHouse/pull/6043) ([Artem Zuikov](https://github.com/4ertus2)), [#5625](https://github.com/yandex/ClickHouse/pull/5625) ([akuzm](https://github.com/akuzm))
+* Throws an exception if `config.d` file doesn't have the corresponding root element as the config file [#6123](https://github.com/yandex/ClickHouse/pull/6123) ([dimarub2000](https://github.com/dimarub2000))
 
 ### Performance Improvement
 * Optimize `count()`. Now it uses the smallest column (if possible). [#6028](https://github.com/yandex/ClickHouse/pull/6028) ([Amos Bird](https://github.com/amosbird))

From e4dda4332ef2a9ed7e87b6c681dd2cdd74c534a4 Mon Sep 17 00:00:00 2001
From: alexey-milovidov <milovidov@yandex-team.ru>
Date: Mon, 19 Aug 2019 16:52:16 +0300
Subject: [PATCH 091/107] Update CHANGELOG.md

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

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 0f8e8166d21..09774773686 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -13,6 +13,7 @@
 * New query processing pipeline. Use `experimental_use_processors=1` option to enable it. Use for your own trouble. [#4914](https://github.com/yandex/ClickHouse/pull/4914) ([Nikolai Kochetov](https://github.com/KochetovNicolai))
 
 ### Bug Fix
+* Kafka integration has been fixed in this version.
 * Fixed `DoubleDelta` encoding of `Int64` for large `DoubleDelta` values, improved `DoubleDelta` encoding for random data for `Int32`. [#5998](https://github.com/yandex/ClickHouse/pull/5998) ([Vasily Nemkov](https://github.com/Enmk))
 * Fixed overestimation of `max_rows_to_read` if the setting `merge_tree_uniform_read_distribution` is set to 0. [#6019](https://github.com/yandex/ClickHouse/pull/6019) ([alexey-milovidov](https://github.com/alexey-milovidov))
 
@@ -31,6 +32,7 @@
 ## ClickHouse release 19.11.7.40, 2019-08-14
 
 ### Bug fix
+* Kafka integration has been fixed in this version.
 * Fix segfault when using `arrayReduce` for constant arguments. [#6326](https://github.com/yandex/ClickHouse/pull/6326) ([alexey-milovidov](https://github.com/alexey-milovidov))
 * Fixed `toFloat()` monotonicity. [#6374](https://github.com/yandex/ClickHouse/pull/6374) ([dimarub2000](https://github.com/dimarub2000))
 * Fix segfault with enabled `optimize_skip_unused_shards` and missing sharding key. [#6384](https://github.com/yandex/ClickHouse/pull/6384) ([CurtizJ](https://github.com/CurtizJ))

From a466040201d23e228c5c8f3b7f8d163ee73f3122 Mon Sep 17 00:00:00 2001
From: Nikolai Kochetov <nik-kochetov@yandex-team.ru>
Date: Mon, 19 Aug 2019 17:39:35 +0300
Subject: [PATCH 092/107] Added
 00991_temporary_live_view_watch_events_heartbeat.

---
 .../00991_live_view_watch_event_live.python   |  2 +-
 ...00991_live_view_watch_event_live.reference |  1 -
 ...ry_live_view_watch_events_heartbeat.python | 83 +++++++++++++++++++
 ...live_view_watch_events_heartbeat.reference |  0
 ...porary_live_view_watch_events_heartbeat.sh |  6 ++
 ...0991_temporary_live_view_watch_live.python |  2 +-
 ...1_temporary_live_view_watch_live.reference |  1 -
 7 files changed, 91 insertions(+), 4 deletions(-)
 create mode 100644 dbms/tests/queries/0_stateless/00991_temporary_live_view_watch_events_heartbeat.python
 create mode 100644 dbms/tests/queries/0_stateless/00991_temporary_live_view_watch_events_heartbeat.reference
 create mode 100755 dbms/tests/queries/0_stateless/00991_temporary_live_view_watch_events_heartbeat.sh

diff --git a/dbms/tests/queries/0_stateless/00991_live_view_watch_event_live.python b/dbms/tests/queries/0_stateless/00991_live_view_watch_event_live.python
index 6f2e55f72e6..782671cdfaf 100644
--- a/dbms/tests/queries/0_stateless/00991_live_view_watch_event_live.python
+++ b/dbms/tests/queries/0_stateless/00991_live_view_watch_event_live.python
@@ -23,7 +23,7 @@ def send_query(query):
 def send_query_in_process_group(query):
     cmd = list(CLICKHOUSE_CLIENT.split())
     cmd += ['--query', query]
-    print(cmd)
+    # print(cmd)
     return subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, preexec_fn=os.setsid)
 
 
diff --git a/dbms/tests/queries/0_stateless/00991_live_view_watch_event_live.reference b/dbms/tests/queries/0_stateless/00991_live_view_watch_event_live.reference
index e48dcf35d3e..1e94cdade41 100644
--- a/dbms/tests/queries/0_stateless/00991_live_view_watch_event_live.reference
+++ b/dbms/tests/queries/0_stateless/00991_live_view_watch_event_live.reference
@@ -1,4 +1,3 @@
-['/home/nik-kochetov/dev/ClickHouse/build-tsan/dbms/programs/clickhouse', 'client', '--send_logs_level=warning', '--database=default', '--query', 'WATCH test.lv']
 0	1
 0	1
 6	2
diff --git a/dbms/tests/queries/0_stateless/00991_temporary_live_view_watch_events_heartbeat.python b/dbms/tests/queries/0_stateless/00991_temporary_live_view_watch_events_heartbeat.python
new file mode 100644
index 00000000000..70063adc6e3
--- /dev/null
+++ b/dbms/tests/queries/0_stateless/00991_temporary_live_view_watch_events_heartbeat.python
@@ -0,0 +1,83 @@
+#!/usr/bin/env python
+
+import subprocess
+import threading
+import Queue as queue
+import os
+import sys
+import signal
+
+
+CLICKHOUSE_CLIENT = os.environ.get('CLICKHOUSE_CLIENT')
+CLICKHOUSE_CURL = os.environ.get('CLICKHOUSE_CURL')
+CLICKHOUSE_URL = os.environ.get('CLICKHOUSE_URL')
+
+
+def send_query(query):
+    cmd = list(CLICKHOUSE_CLIENT.split())
+    cmd += ['--query', query]
+    # print(cmd)
+    return subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT).stdout
+
+
+def send_query_in_process_group(query):
+    cmd = list(CLICKHOUSE_CLIENT.split())
+    cmd += ['--query', query, '--live_view_heartbeat_interval=1', '--progress']
+    # print(cmd)
+    return subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, preexec_fn=os.setsid)
+
+
+def read_lines_and_push_to_queue(pipe, queue):
+    try:
+        for line in iter(pipe.readline, ''):
+            line = line.strip()
+            # print(line)
+            sys.stdout.flush()
+            queue.put(line)
+    except KeyboardInterrupt:
+        pass
+
+    queue.put(None)
+
+
+def test():
+    send_query('DROP TABLE IF EXISTS test.lv').read()
+    send_query('DROP TABLE IF EXISTS test.mt').read()
+    send_query('CREATE TABLE test.mt (a Int32) Engine=MergeTree order by tuple()').read()
+    send_query('CREATE TEMPORARY LIVE VIEW test.lv AS SELECT sum(a) FROM test.mt').read()
+
+    q = queue.Queue()
+    p = send_query_in_process_group('WATCH test.lv')
+    thread = threading.Thread(target=read_lines_and_push_to_queue, args=(p.stdout, q))
+    thread.start()
+
+    line = q.get()
+    # print(line)
+    assert (line.endswith('0\t1'))
+    assert ('Progress: 0.00 rows' in line)
+
+    send_query('INSERT INTO test.mt VALUES (1),(2),(3)').read()
+    line = q.get()
+    assert (line.endswith('6\t2'))
+    assert ('Progress: 1.00 rows' in line)
+
+    # send_query('INSERT INTO test.mt VALUES (4),(5),(6)').read()
+    # line = q.get()
+    # print(line)
+    # assert (line.endswith('6\t2'))
+    # assert ('Progress: 1.00 rows' in line)
+
+    # Send Ctrl+C to client.
+    os.killpg(os.getpgid(p.pid), signal.SIGINT)
+    # This insert shouldn't affect lv.
+    send_query('INSERT INTO test.mt VALUES (7),(8),(9)').read()
+    line = q.get()
+    # print(line)
+    # assert (line is None)
+
+    send_query('DROP TABLE if exists test.lv').read()
+    send_query('DROP TABLE if exists test.lv').read()
+
+    thread.join()
+
+test()
diff --git a/dbms/tests/queries/0_stateless/00991_temporary_live_view_watch_events_heartbeat.reference b/dbms/tests/queries/0_stateless/00991_temporary_live_view_watch_events_heartbeat.reference
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/dbms/tests/queries/0_stateless/00991_temporary_live_view_watch_events_heartbeat.sh b/dbms/tests/queries/0_stateless/00991_temporary_live_view_watch_events_heartbeat.sh
new file mode 100755
index 00000000000..f7aa13d52b3
--- /dev/null
+++ b/dbms/tests/queries/0_stateless/00991_temporary_live_view_watch_events_heartbeat.sh
@@ -0,0 +1,6 @@
+#!/usr/bin/env bash
+
+CURDIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
+. $CURDIR/../shell_config.sh
+
+python $CURDIR/00991_temporary_live_view_watch_events_heartbeat.python
diff --git a/dbms/tests/queries/0_stateless/00991_temporary_live_view_watch_live.python b/dbms/tests/queries/0_stateless/00991_temporary_live_view_watch_live.python
index 341a9f04c56..d290018a02c 100644
--- a/dbms/tests/queries/0_stateless/00991_temporary_live_view_watch_live.python
+++ b/dbms/tests/queries/0_stateless/00991_temporary_live_view_watch_live.python
@@ -23,7 +23,7 @@ def send_query(query):
 def send_query_in_process_group(query):
     cmd = list(CLICKHOUSE_CLIENT.split())
     cmd += ['--query', query]
-    print(cmd)
+    # print(cmd)
     return subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, preexec_fn=os.setsid)
 
 
diff --git a/dbms/tests/queries/0_stateless/00991_temporary_live_view_watch_live.reference b/dbms/tests/queries/0_stateless/00991_temporary_live_view_watch_live.reference
index e48dcf35d3e..1e94cdade41 100644
--- a/dbms/tests/queries/0_stateless/00991_temporary_live_view_watch_live.reference
+++ b/dbms/tests/queries/0_stateless/00991_temporary_live_view_watch_live.reference
@@ -1,4 +1,3 @@
-['/home/nik-kochetov/dev/ClickHouse/build-tsan/dbms/programs/clickhouse', 'client', '--send_logs_level=warning', '--database=default', '--query', 'WATCH test.lv']
 0	1
 0	1
 6	2

From 61769865d8b81b9fe4e94bdf04352425f025c9f3 Mon Sep 17 00:00:00 2001
From: "philip.han" <philip.han@kakaocorp.com>
Date: Mon, 19 Aug 2019 22:12:25 +0900
Subject: [PATCH 093/107] Added 'strict' parameter in windowFunnel() and added
 testcases.

---
 .../AggregateFunctionWindowFunnel.cpp            |  4 ++--
 .../AggregateFunctionWindowFunnel.h              | 16 +++++++++++++++-
 .../00632_aggregation_window_funnel.sql          | 11 ++++++++++-
 3 files changed, 27 insertions(+), 4 deletions(-)

diff --git a/dbms/src/AggregateFunctions/AggregateFunctionWindowFunnel.cpp b/dbms/src/AggregateFunctions/AggregateFunctionWindowFunnel.cpp
index 4cf7784342c..56ee5dcb012 100644
--- a/dbms/src/AggregateFunctions/AggregateFunctionWindowFunnel.cpp
+++ b/dbms/src/AggregateFunctions/AggregateFunctionWindowFunnel.cpp
@@ -17,8 +17,8 @@ namespace
 template <template <typename> class Data>
 AggregateFunctionPtr createAggregateFunctionWindowFunnel(const std::string & name, const DataTypes & arguments, const Array & params)
 {
-    if (params.size() != 1)
-        throw Exception{"Aggregate function " + name + " requires exactly one parameter.", ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH};
+    if (params.size() < 1)
+        throw Exception{"Aggregate function " + name + " requires at least one parameter: <window>, [option, [option, ...]]", ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH};
 
     if (arguments.size() < 2)
         throw Exception("Aggregate function " + name + " requires one timestamp argument and at least one event condition.", ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH);
diff --git a/dbms/src/AggregateFunctions/AggregateFunctionWindowFunnel.h b/dbms/src/AggregateFunctions/AggregateFunctionWindowFunnel.h
index 1e3c005f73f..df93ec5c0ba 100644
--- a/dbms/src/AggregateFunctions/AggregateFunctionWindowFunnel.h
+++ b/dbms/src/AggregateFunctions/AggregateFunctionWindowFunnel.h
@@ -139,6 +139,7 @@ class AggregateFunctionWindowFunnel final
 private:
     UInt64 window;
     UInt8 events_size;
+    UInt8 strict;
 
 
     // Loop through the entire events_list, update the event timestamp value
@@ -165,6 +166,10 @@ private:
 
             if (event_idx == 0)
                 events_timestamp[0] = timestamp;
+            else if (strict && events_timestamp[event_idx] >= 0)
+            {
+                return event_idx + 1;
+            }
             else if (events_timestamp[event_idx - 1] >= 0 && timestamp <= events_timestamp[event_idx - 1] + window)
             {
                 events_timestamp[event_idx] = events_timestamp[event_idx - 1];
@@ -191,8 +196,17 @@ public:
     {
         events_size = arguments.size() - 1;
         window = params.at(0).safeGet<UInt64>();
-    }
 
+        strict = 0;
+        for (size_t i = 1; i < params.size(); ++i)
+        {
+            String option = params.at(i).safeGet<String>();
+            if (option.compare("strict") == 0)
+                strict = 1;
+            else
+                throw Exception{"Aggregate function " + getName() + " doesn't support a parameter: " + option, ErrorCodes::BAD_ARGUMENTS};
+        }
+    }
 
     DataTypePtr getReturnType() const override
     {
diff --git a/dbms/tests/queries/0_stateless/00632_aggregation_window_funnel.sql b/dbms/tests/queries/0_stateless/00632_aggregation_window_funnel.sql
index a59e1700647..2e8df1b4710 100644
--- a/dbms/tests/queries/0_stateless/00632_aggregation_window_funnel.sql
+++ b/dbms/tests/queries/0_stateless/00632_aggregation_window_funnel.sql
@@ -9,7 +9,6 @@ select 3 = windowFunnel(10000)(timestamp, event = 1000, event = 1001, event = 10
 select 4 = windowFunnel(10000)(timestamp, event = 1000, event = 1001, event = 1002, event = 1008) from funnel_test;
 
 
-
 select 1 = windowFunnel(1)(timestamp, event = 1000) from funnel_test;
 select 3 = windowFunnel(2)(timestamp, event = 1003, event = 1004, event = 1005, event = 1006, event = 1007) from funnel_test;
 select 4 = windowFunnel(3)(timestamp, event = 1003, event = 1004, event = 1005, event = 1006, event = 1007) from funnel_test;
@@ -39,6 +38,16 @@ select 1 = windowFunnel(10000)(timestamp, event = 1008, event = 1001) from funne
 select 5 = windowFunnel(4)(timestamp, event = 1003, event = 1004, event = 1005, event = 1006, event = 1007) from funnel_test_u64;
 select 4 = windowFunnel(4)(timestamp, event <= 1007, event >= 1002, event <= 1006, event >= 1004) from funnel_test_u64;
 
+
+drop table if exists funnel_test_strict;
+create table funnel_test_strict (timestamp UInt32, event UInt32) engine=Memory;
+insert into funnel_test_strict values (00,1000),(10,1001),(20,1002),(30,1003),(40,1004),(50,1005),(51,1005),(60,1006),(70,1007),(80,1008);
+
+select 6 = windowFunnel(10000, 'strict')(timestamp, event = 1000, event = 1001, event = 1002, event = 1003, event = 1004, event = 1005, event = 1006) from funnel_test_strict;
+select 7 = windowFunnel(10000)(timestamp, event = 1000, event = 1001, event = 1002, event = 1003, event = 1004, event = 1005, event = 1006) from funnel_test_strict;
+
+
 drop table funnel_test;
 drop table funnel_test2;
 drop table funnel_test_u64;
+drop table funnel_test_strict;

From bb4136f7b0f57aa531016deb992b56ddd0e3693b Mon Sep 17 00:00:00 2001
From: dimarub2000 <dimarub2000@gmail.com>
Date: Mon, 19 Aug 2019 19:03:25 +0300
Subject: [PATCH 094/107] virtual functions deleted

---
 dbms/src/AggregateFunctions/QuantileExact.h | 21 ++++-----------------
 1 file changed, 4 insertions(+), 17 deletions(-)

diff --git a/dbms/src/AggregateFunctions/QuantileExact.h b/dbms/src/AggregateFunctions/QuantileExact.h
index 058c433e992..5a1343b1399 100644
--- a/dbms/src/AggregateFunctions/QuantileExact.h
+++ b/dbms/src/AggregateFunctions/QuantileExact.h
@@ -107,19 +107,6 @@ struct QuantileExact
                 result[i] = Value();
         }
     }
-
-    /// The same, but in the case of an empty state, NaN is returned.
-    virtual Float64 getFloat(Float64)
-    {
-        throw Exception("Method getFloat is not implemented for QuantileExact", ErrorCodes::NOT_IMPLEMENTED);
-    }
-
-    virtual void getManyFloat(const Float64 *, const size_t *, size_t, Float64 *)
-    {
-        throw Exception("Method getManyFloat is not implemented for QuantileExact", ErrorCodes::NOT_IMPLEMENTED);
-    }
-
-    virtual ~QuantileExact() = default;
 };
 
 /// QuantileExactExclusive is equivalent to Excel PERCENTILE.EXC, R-6, SAS-4, SciPy-(0,0)
@@ -129,7 +116,7 @@ struct QuantileExactExclusive : public QuantileExact<Value>
     using QuantileExact<Value>::array;
 
     /// Get the value of the `level` quantile. The level must be between 0 and 1 excluding bounds.
-    Float64 getFloat(Float64 level) override
+    Float64 getFloat(Float64 level)
     {
         if (!array.empty())
         {
@@ -153,7 +140,7 @@ struct QuantileExactExclusive : public QuantileExact<Value>
         return std::numeric_limits<Float64>::quiet_NaN();
     }
 
-    void getManyFloat(const Float64 * levels, const size_t * indices, size_t size, Float64 * result) override
+    void getManyFloat(const Float64 * levels, const size_t * indices, size_t size, Float64 * result)
     {
         if (!array.empty())
         {
@@ -196,7 +183,7 @@ struct QuantileExactInclusive : public QuantileExact<Value>
     using QuantileExact<Value>::array;
 
     /// Get the value of the `level` quantile. The level must be between 0 and 1 including bounds.
-    Float64 getFloat(Float64 level) override
+    Float64 getFloat(Float64 level)
     {
         if (!array.empty())
         {
@@ -217,7 +204,7 @@ struct QuantileExactInclusive : public QuantileExact<Value>
         return std::numeric_limits<Float64>::quiet_NaN();
     }
 
-    void getManyFloat(const Float64 * levels, const size_t * indices, size_t size, Float64 * result) override
+    void getManyFloat(const Float64 * levels, const size_t * indices, size_t size, Float64 * result)
     {
         if (!array.empty())
         {

From c62eb7a3ae483d5d4beda8d92362a59c665c73eb Mon Sep 17 00:00:00 2001
From: Alexander Tokmakov <avtokmakov@yandex-team.ru>
Date: Mon, 19 Aug 2019 19:51:50 +0300
Subject: [PATCH 095/107] check columns count and types

---
 dbms/src/Interpreters/Set.cpp                | 32 ++++++++++++--------
 dbms/src/Interpreters/Set.h                  |  3 ++
 dbms/src/Storages/MergeTree/KeyCondition.cpp |  8 ++++-
 3 files changed, 30 insertions(+), 13 deletions(-)

diff --git a/dbms/src/Interpreters/Set.cpp b/dbms/src/Interpreters/Set.cpp
index 7840a314380..4313decd36d 100644
--- a/dbms/src/Interpreters/Set.cpp
+++ b/dbms/src/Interpreters/Set.cpp
@@ -320,13 +320,7 @@ ColumnPtr Set::execute(const Block & block, bool negative) const
         return res;
     }
 
-    if (data_types.size() != num_key_columns)
-    {
-        std::stringstream message;
-        message << "Number of columns in section IN doesn't match. "
-            << num_key_columns << " at left, " << data_types.size() << " at right.";
-        throw Exception(message.str(), ErrorCodes::NUMBER_OF_COLUMNS_DOESNT_MATCH);
-    }
+    checkColumnsNumber(num_key_columns);
 
     /// Remember the columns we will work with. Also check that the data types are correct.
     ColumnRawPtrs key_columns;
@@ -337,11 +331,7 @@ ColumnPtr Set::execute(const Block & block, bool negative) const
 
     for (size_t i = 0; i < num_key_columns; ++i)
     {
-        if (!removeNullable(data_types[i])->equals(*removeNullable(block.safeGetByPosition(i).type)))
-            throw Exception("Types of column " + toString(i + 1) + " in section IN don't match: "
-                + data_types[i]->getName() + " on the right, " + block.safeGetByPosition(i).type->getName() +
-                " on the left.", ErrorCodes::TYPE_MISMATCH);
-
+        checkTypesEqual(i, block.safeGetByPosition(i).type);
         materialized_columns.emplace_back(block.safeGetByPosition(i).column->convertToFullColumnIfConst());
         key_columns.emplace_back() = materialized_columns.back().get();
     }
@@ -421,6 +411,24 @@ void Set::executeOrdinary(
     }
 }
 
+void Set::checkColumnsNumber(size_t num_key_columns) const
+{
+    if (data_types.size() != num_key_columns)
+    {
+        std::stringstream message;
+        message << "Number of columns in section IN doesn't match. "
+                << num_key_columns << " at left, " << data_types.size() << " at right.";
+        throw Exception(message.str(), ErrorCodes::NUMBER_OF_COLUMNS_DOESNT_MATCH);
+    }
+}
+
+void Set::checkTypesEqual(size_t set_type_idx, const DataTypePtr & other_type) const
+{
+    if (!removeNullable(data_types[set_type_idx])->equals(*removeNullable(other_type)))
+        throw Exception("Types of column " + toString(set_type_idx + 1) + " in section IN don't match: "
+                        + data_types[set_type_idx]->getName() + " on the right, " + other_type->getName() +
+                        " on the left.", ErrorCodes::TYPE_MISMATCH);
+}
 
 MergeTreeSetIndex::MergeTreeSetIndex(const Columns & set_elements, std::vector<KeyTuplePositionMapping> && index_mapping_)
     : indexes_mapping(std::move(index_mapping_))
diff --git a/dbms/src/Interpreters/Set.h b/dbms/src/Interpreters/Set.h
index aad10451de0..a252f1ebc1e 100644
--- a/dbms/src/Interpreters/Set.h
+++ b/dbms/src/Interpreters/Set.h
@@ -70,6 +70,9 @@ public:
     bool hasExplicitSetElements() const { return fill_set_elements; }
     Columns getSetElements() const { return { set_elements.begin(), set_elements.end() }; }
 
+    void checkColumnsNumber(size_t num_key_columns) const;
+    void checkTypesEqual(size_t set_type_idx, const DataTypePtr & other_type) const;
+
 private:
     size_t keys_size = 0;
     Sizes key_sizes;
diff --git a/dbms/src/Storages/MergeTree/KeyCondition.cpp b/dbms/src/Storages/MergeTree/KeyCondition.cpp
index 790c72329a2..0ebe8f79aba 100644
--- a/dbms/src/Storages/MergeTree/KeyCondition.cpp
+++ b/dbms/src/Storages/MergeTree/KeyCondition.cpp
@@ -546,11 +546,13 @@ bool KeyCondition::tryPrepareSetIndex(
         }
     };
 
+    size_t left_args_count = 1;
     const auto * left_arg_tuple = left_arg->as<ASTFunction>();
     if (left_arg_tuple && left_arg_tuple->name == "tuple")
     {
         const auto & tuple_elements = left_arg_tuple->arguments->children;
-        for (size_t i = 0; i < tuple_elements.size(); ++i)
+        left_args_count = tuple_elements.size();
+        for (size_t i = 0; i < left_args_count; ++i)
             get_key_tuple_position_mapping(tuple_elements[i], i);
     }
     else
@@ -577,6 +579,10 @@ bool KeyCondition::tryPrepareSetIndex(
     if (!prepared_set->hasExplicitSetElements())
         return false;
 
+    prepared_set->checkColumnsNumber(left_args_count);
+    for (size_t i = 0; i < indexes_mapping.size(); ++i)
+        prepared_set->checkTypesEqual(indexes_mapping[i].tuple_index, removeLowCardinality(data_types[i]));
+
     out.set_index = std::make_shared<MergeTreeSetIndex>(prepared_set->getSetElements(), std::move(indexes_mapping));
 
     return true;

From 9e2537a7d09ebee108ea2e68a6d6b2f282f528f1 Mon Sep 17 00:00:00 2001
From: Alexander Tokmakov <avtokmakov@yandex-team.ru>
Date: Mon, 19 Aug 2019 19:52:05 +0300
Subject: [PATCH 096/107] add test

---
 .../00981_in_subquery_with_tuple.reference    |  7 +++++++
 .../00981_in_subquery_with_tuple.sh           | 21 +++++++++++++++++++
 2 files changed, 28 insertions(+)
 create mode 100644 dbms/tests/queries/0_stateless/00981_in_subquery_with_tuple.reference
 create mode 100755 dbms/tests/queries/0_stateless/00981_in_subquery_with_tuple.sh

diff --git a/dbms/tests/queries/0_stateless/00981_in_subquery_with_tuple.reference b/dbms/tests/queries/0_stateless/00981_in_subquery_with_tuple.reference
new file mode 100644
index 00000000000..673d035ede6
--- /dev/null
+++ b/dbms/tests/queries/0_stateless/00981_in_subquery_with_tuple.reference
@@ -0,0 +1,7 @@
+OK1
+OK2
+OK3
+OK4
+OK5
+2019-08-11	world
+2019-08-12	hello
diff --git a/dbms/tests/queries/0_stateless/00981_in_subquery_with_tuple.sh b/dbms/tests/queries/0_stateless/00981_in_subquery_with_tuple.sh
new file mode 100755
index 00000000000..89dc15cedf6
--- /dev/null
+++ b/dbms/tests/queries/0_stateless/00981_in_subquery_with_tuple.sh
@@ -0,0 +1,21 @@
+#!/usr/bin/env bash
+
+CURDIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
+. $CURDIR/../shell_config.sh
+
+$CLICKHOUSE_CLIENT --query="DROP TABLE IF EXISTS bug";
+$CLICKHOUSE_CLIENT --query="CREATE TABLE bug (d Date, s String) ENGINE = MergeTree(d, s, 8192)";
+$CLICKHOUSE_CLIENT --query="INSERT INTO bug VALUES ('2019-08-09', 'hello'), ('2019-08-10', 'world'), ('2019-08-11', 'world'), ('2019-08-12', 'hello')";
+
+#SET force_primary_key = 1;
+
+$CLICKHOUSE_CLIENT --query="SELECT * FROM bug WHERE (s, d) IN (SELECT (s, max(d)) FROM bug GROUP BY s) ORDER BY d" 2>&1 | grep "Number of columns in section IN doesn't match" > /dev/null && echo "OK1";
+$CLICKHOUSE_CLIENT --query="SELECT * FROM bug WHERE (s, d, s) IN (SELECT s, max(d) FROM bug GROUP BY s)" 2>&1 | grep "Number of columns in section IN doesn't match" > /dev/null && echo "OK2";
+$CLICKHOUSE_CLIENT --query="SELECT * FROM bug WHERE (s, d) IN (SELECT s, max(d), s FROM bug GROUP BY s)" 2>&1 | grep "Number of columns in section IN doesn't match" > /dev/null && echo "OK3";
+
+$CLICKHOUSE_CLIENT --query="SELECT * FROM bug WHERE (s, toDateTime(d)) IN (SELECT s, max(d) FROM bug GROUP BY s)" 2>&1 | grep "Types of column 2 in section IN don't match" > /dev/null && echo "OK4";
+$CLICKHOUSE_CLIENT --query="SELECT * FROM bug WHERE (s, d) IN (SELECT s, toDateTime(max(d)) FROM bug GROUP BY s)" 2>&1 | grep "Types of column 2 in section IN don't match" > /dev/null && echo "OK5";
+
+$CLICKHOUSE_CLIENT --query="SELECT * FROM bug WHERE (s, d) IN (SELECT s, max(d) FROM bug GROUP BY s) ORDER BY d";
+
+$CLICKHOUSE_CLIENT --query="DROP TABLE bug";

From 3277f9e3deb862cee88d3c5210c86b9a61545ce1 Mon Sep 17 00:00:00 2001
From: Nikolai Kochetov <nik-kochetov@yandex-team.ru>
Date: Mon, 19 Aug 2019 20:56:00 +0300
Subject: [PATCH 097/107] Add patch to Live View tests.

---
 ...nt_live.sh => 00991_live_view_watch_event_live.sh.disabled} | 0
 ...ew_watch_http.sh => 00991_live_view_watch_http.sh.disabled} | 0
 ...991_temporary_live_view_watch_events_heartbeat.sh.disabled} | 0
 ...ive.sh => 00991_temporary_live_view_watch_live.sh.disabled} | 0
 dbms/tests/queries/0_stateless/helpers/uexpect.py              | 3 ++-
 5 files changed, 2 insertions(+), 1 deletion(-)
 rename dbms/tests/queries/0_stateless/{00991_live_view_watch_event_live.sh => 00991_live_view_watch_event_live.sh.disabled} (100%)
 rename dbms/tests/queries/0_stateless/{00991_live_view_watch_http.sh => 00991_live_view_watch_http.sh.disabled} (100%)
 rename dbms/tests/queries/0_stateless/{00991_temporary_live_view_watch_events_heartbeat.sh => 00991_temporary_live_view_watch_events_heartbeat.sh.disabled} (100%)
 rename dbms/tests/queries/0_stateless/{00991_temporary_live_view_watch_live.sh => 00991_temporary_live_view_watch_live.sh.disabled} (100%)

diff --git a/dbms/tests/queries/0_stateless/00991_live_view_watch_event_live.sh b/dbms/tests/queries/0_stateless/00991_live_view_watch_event_live.sh.disabled
similarity index 100%
rename from dbms/tests/queries/0_stateless/00991_live_view_watch_event_live.sh
rename to dbms/tests/queries/0_stateless/00991_live_view_watch_event_live.sh.disabled
diff --git a/dbms/tests/queries/0_stateless/00991_live_view_watch_http.sh b/dbms/tests/queries/0_stateless/00991_live_view_watch_http.sh.disabled
similarity index 100%
rename from dbms/tests/queries/0_stateless/00991_live_view_watch_http.sh
rename to dbms/tests/queries/0_stateless/00991_live_view_watch_http.sh.disabled
diff --git a/dbms/tests/queries/0_stateless/00991_temporary_live_view_watch_events_heartbeat.sh b/dbms/tests/queries/0_stateless/00991_temporary_live_view_watch_events_heartbeat.sh.disabled
similarity index 100%
rename from dbms/tests/queries/0_stateless/00991_temporary_live_view_watch_events_heartbeat.sh
rename to dbms/tests/queries/0_stateless/00991_temporary_live_view_watch_events_heartbeat.sh.disabled
diff --git a/dbms/tests/queries/0_stateless/00991_temporary_live_view_watch_live.sh b/dbms/tests/queries/0_stateless/00991_temporary_live_view_watch_live.sh.disabled
similarity index 100%
rename from dbms/tests/queries/0_stateless/00991_temporary_live_view_watch_live.sh
rename to dbms/tests/queries/0_stateless/00991_temporary_live_view_watch_live.sh.disabled
diff --git a/dbms/tests/queries/0_stateless/helpers/uexpect.py b/dbms/tests/queries/0_stateless/helpers/uexpect.py
index 930a45a099e..f71b32a53e1 100644
--- a/dbms/tests/queries/0_stateless/helpers/uexpect.py
+++ b/dbms/tests/queries/0_stateless/helpers/uexpect.py
@@ -101,6 +101,7 @@ class IO(object):
 
     def close(self, force=True):
         self.reader['kill_event'].set()
+        os.system('pkill -TERM -P %d' % self.process.pid)
         if force:
             self.process.kill()
         else:
@@ -199,7 +200,7 @@ def reader(process, out, queue, kill_event):
         try:
             data = os.read(out, 65536)
             queue.put(data)
-        except OSError, e:
+        except:
             if kill_event.is_set():
                 break
             raise

From f0a161787a740f2d69f3a026e71c26d434981b40 Mon Sep 17 00:00:00 2001
From: alexey-milovidov <milovidov@yandex-team.ru>
Date: Mon, 19 Aug 2019 23:12:04 +0300
Subject: [PATCH 098/107] Update CHANGELOG.md

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

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 09774773686..58c38dc120a 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -350,7 +350,7 @@ It allows to set commit mode: after every batch of messages is handled, or after
 * Renamed functions `leastSqr` to `simpleLinearRegression`, `LinearRegression` to `linearRegression`, `LogisticRegression` to `logisticRegression`. [#5391](https://github.com/yandex/ClickHouse/pull/5391) ([Nikolai Kochetov](https://github.com/KochetovNicolai))
 
 ### Performance Improvements
-* Paralellize processing of parts in alter modify query. [#4639](https://github.com/yandex/ClickHouse/pull/4639) ([Ivan Kush](https://github.com/IvanKush))
+* Paralellize processing of parts of non-replicated MergeTree tables in ALTER MODIFY query. [#4639](https://github.com/yandex/ClickHouse/pull/4639) ([Ivan Kush](https://github.com/IvanKush))
 * Optimizations in regular expressions extraction. [#5193](https://github.com/yandex/ClickHouse/pull/5193) [#5191](https://github.com/yandex/ClickHouse/pull/5191) ([Danila Kutenin](https://github.com/danlark1))
 * Do not add right join key column to join result if it's used only in join on section. [#5260](https://github.com/yandex/ClickHouse/pull/5260) ([Artem Zuikov](https://github.com/4ertus2))
 * Freeze the Kafka buffer after first empty response. It avoids multiple invokations of `ReadBuffer::next()` for empty result in some row-parsing streams. [#5283](https://github.com/yandex/ClickHouse/pull/5283) ([Ivan](https://github.com/abyss7))

From fe5cd470681010e86445f3660ac8095d811deb1b Mon Sep 17 00:00:00 2001
From: Alexander Kazakov <Akazz@users.noreply.github.com>
Date: Mon, 19 Aug 2019 23:28:24 +0300
Subject: [PATCH 099/107] Process prewhere clause in "skip unused shards"
 optimization (#6521)

* Process prewhere clause in optimize_skip_unused_shards

* Better diagnostics and logging
---
 dbms/src/Storages/StorageDistributed.cpp      |  58 ++++++++--
 ...t_on_unused_shards_with_prewhere.reference |  15 +++
 ...p_select_on_unused_shards_with_prewhere.sh | 100 ++++++++++++++++++
 3 files changed, 167 insertions(+), 6 deletions(-)
 create mode 100644 dbms/tests/queries/0_stateless/00754_distributed_optimize_skip_select_on_unused_shards_with_prewhere.reference
 create mode 100755 dbms/tests/queries/0_stateless/00754_distributed_optimize_skip_select_on_unused_shards_with_prewhere.sh

diff --git a/dbms/src/Storages/StorageDistributed.cpp b/dbms/src/Storages/StorageDistributed.cpp
index e862d27fdaa..49c2ebc7286 100644
--- a/dbms/src/Storages/StorageDistributed.cpp
+++ b/dbms/src/Storages/StorageDistributed.cpp
@@ -176,6 +176,22 @@ IColumn::Selector createSelector(const ClusterPtr cluster, const ColumnWithTypeA
     throw Exception{"Sharding key expression does not evaluate to an integer type", ErrorCodes::TYPE_MISMATCH};
 }
 
+std::string makeFormattedListOfShards(const ClusterPtr & cluster)
+{
+    std::ostringstream os;
+
+    bool head = true;
+    os << "[";
+    for (const auto & shard_info : cluster->getShardsInfo())
+    {
+        (head ? os : os << ", ") << shard_info.shard_num;
+        head = false;
+    }
+    os << "]";
+
+    return os.str();
+}
+
 }
 
 
@@ -312,10 +328,23 @@ BlockInputStreams StorageDistributed::read(
 
     if (settings.optimize_skip_unused_shards)
     {
-        auto smaller_cluster = skipUnusedShards(cluster, query_info);
+        if (has_sharding_key)
+        {
+            auto smaller_cluster = skipUnusedShards(cluster, query_info);
 
-        if (smaller_cluster)
-            cluster = smaller_cluster;
+            if (smaller_cluster)
+            {
+                cluster = smaller_cluster;
+                LOG_DEBUG(log, "Reading from " << database_name << "." << table_name << ": "
+                               "Skipping irrelevant shards - the query will be sent to the following shards of the cluster (shard numbers): "
+                               " " << makeFormattedListOfShards(cluster));
+            }
+            else
+            {
+                LOG_DEBUG(log, "Reading from " << database_name << "." << table_name << ": "
+                               "Unable to figure out irrelevant shards from WHERE/PREWHERE clauses - the query will be sent to all shards of the cluster");
+            }
+        }
     }
 
     return ClusterProxy::executeQuery(
@@ -488,15 +517,32 @@ void StorageDistributed::ClusterNodeData::shutdownAndDropAllData()
 }
 
 /// Returns a new cluster with fewer shards if constant folding for `sharding_key_expr` is possible
-/// using constraints from "WHERE" condition, otherwise returns `nullptr`
+/// using constraints from "PREWHERE" and "WHERE" conditions, otherwise returns `nullptr`
 ClusterPtr StorageDistributed::skipUnusedShards(ClusterPtr cluster, const SelectQueryInfo & query_info)
 {
+    if (!has_sharding_key)
+    {
+        throw Exception("Internal error: cannot determine shards of a distributed table if no sharding expression is supplied", ErrorCodes::LOGICAL_ERROR);
+    }
+
     const auto & select = query_info.query->as<ASTSelectQuery &>();
 
-    if (!select.where() || !sharding_key_expr)
+    if (!select.prewhere() && !select.where())
+    {
         return nullptr;
+    }
 
-    const auto & blocks = evaluateExpressionOverConstantCondition(select.where(), sharding_key_expr);
+    ASTPtr condition_ast;
+    if (select.prewhere() && select.where())
+    {
+        condition_ast = makeASTFunction("and", select.prewhere()->clone(), select.where()->clone());
+    }
+    else
+    {
+        condition_ast = select.prewhere() ? select.prewhere()->clone() : select.where()->clone();
+    }
+
+    const auto blocks = evaluateExpressionOverConstantCondition(condition_ast, sharding_key_expr);
 
     // Can't get definite answer if we can skip any shards
     if (!blocks)
diff --git a/dbms/tests/queries/0_stateless/00754_distributed_optimize_skip_select_on_unused_shards_with_prewhere.reference b/dbms/tests/queries/0_stateless/00754_distributed_optimize_skip_select_on_unused_shards_with_prewhere.reference
new file mode 100644
index 00000000000..4c66ccfd2a2
--- /dev/null
+++ b/dbms/tests/queries/0_stateless/00754_distributed_optimize_skip_select_on_unused_shards_with_prewhere.reference
@@ -0,0 +1,15 @@
+OK
+OK
+1
+OK
+0
+1
+4
+4
+2
+4
+OK
+OK
+OK
+OK
+OK
diff --git a/dbms/tests/queries/0_stateless/00754_distributed_optimize_skip_select_on_unused_shards_with_prewhere.sh b/dbms/tests/queries/0_stateless/00754_distributed_optimize_skip_select_on_unused_shards_with_prewhere.sh
new file mode 100755
index 00000000000..c8ae239063a
--- /dev/null
+++ b/dbms/tests/queries/0_stateless/00754_distributed_optimize_skip_select_on_unused_shards_with_prewhere.sh
@@ -0,0 +1,100 @@
+#!/usr/bin/env bash
+
+CURDIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
+. $CURDIR/../shell_config.sh
+
+${CLICKHOUSE_CLIENT} --query "DROP TABLE IF EXISTS distributed_00754;"
+${CLICKHOUSE_CLIENT} --query "DROP TABLE IF EXISTS mergetree_00754;"
+
+${CLICKHOUSE_CLIENT} --query "
+    CREATE TABLE mergetree_00754 (a Int64, b Int64, c String) ENGINE = MergeTree ORDER BY (a, b);
+"
+${CLICKHOUSE_CLIENT} --query "
+    CREATE TABLE distributed_00754 AS mergetree_00754
+    ENGINE = Distributed(test_unavailable_shard, ${CLICKHOUSE_DATABASE}, mergetree_00754, jumpConsistentHash(a+b, 2));
+"
+
+${CLICKHOUSE_CLIENT} --query "INSERT INTO mergetree_00754 VALUES (0, 0, 'Hello');"
+${CLICKHOUSE_CLIENT} --query "INSERT INTO mergetree_00754 VALUES (1, 0, 'World');"
+${CLICKHOUSE_CLIENT} --query "INSERT INTO mergetree_00754 VALUES (0, 1, 'Hello');"
+${CLICKHOUSE_CLIENT} --query "INSERT INTO mergetree_00754 VALUES (1, 1, 'World');"
+
+# Should fail because the second shard is unavailable
+${CLICKHOUSE_CLIENT} --query "SELECT count(*) FROM distributed_00754;" 2>&1 \
+| fgrep -q "All connection tries failed" && echo 'OK' || echo 'FAIL'
+
+# Should fail without setting `optimize_skip_unused_shards` = 1
+${CLICKHOUSE_CLIENT} --query "SELECT count(*) FROM distributed_00754 PREWHERE a = 0 AND b = 0;" 2>&1 \
+| fgrep -q "All connection tries failed" && echo 'OK' || echo 'FAIL'
+
+# Should pass now
+${CLICKHOUSE_CLIENT} -n --query="
+    SET optimize_skip_unused_shards = 1;
+    SELECT count(*) FROM distributed_00754 PREWHERE a = 0 AND b = 0;
+"
+
+
+# Should still fail because of matching unavailable shard
+${CLICKHOUSE_CLIENT} -n --query="
+    SET optimize_skip_unused_shards = 1;
+    SELECT count(*) FROM distributed_00754 PREWHERE a = 2 AND b = 2;
+" 2>&1 \ | fgrep -q "All connection tries failed" && echo 'OK' || echo 'FAIL'
+
+# Try more complex expressions for constant folding - all should pass.
+
+${CLICKHOUSE_CLIENT} -n --query="
+    SET optimize_skip_unused_shards = 1;
+    SELECT count(*) FROM distributed_00754 PREWHERE a = 1 AND a = 0 WHERE b = 0;
+"
+
+${CLICKHOUSE_CLIENT} -n --query="
+    SET optimize_skip_unused_shards = 1;
+    SELECT count(*) FROM distributed_00754 PREWHERE a = 1 WHERE b = 1 AND length(c) = 5;
+"
+
+${CLICKHOUSE_CLIENT} -n --query="
+    SET optimize_skip_unused_shards = 1;
+    SELECT count(*) FROM distributed_00754 PREWHERE a IN (0, 1) AND b IN (0, 1) WHERE c LIKE '%l%';
+"
+
+${CLICKHOUSE_CLIENT} -n --query="
+    SET optimize_skip_unused_shards = 1;
+    SELECT count(*) FROM distributed_00754 PREWHERE a IN (0, 1) WHERE b IN (0, 1) AND c LIKE '%l%';
+"
+
+${CLICKHOUSE_CLIENT} -n --query="
+    SET optimize_skip_unused_shards = 1;
+    SELECT count(*) FROM distributed_00754 PREWHERE a = 0 AND b = 0 OR a = 1 AND b = 1 WHERE c LIKE '%l%';
+"
+
+${CLICKHOUSE_CLIENT} -n --query="
+    SET optimize_skip_unused_shards = 1;
+    SELECT count(*) FROM distributed_00754 PREWHERE (a = 0 OR a = 1) WHERE (b = 0 OR b = 1);
+"
+
+# These should fail.
+
+${CLICKHOUSE_CLIENT} -n --query="
+    SET optimize_skip_unused_shards = 1;
+    SELECT count(*) FROM distributed_00754 PREWHERE a = 0 AND b <= 1;
+" 2>&1 \ | fgrep -q "All connection tries failed" && echo 'OK' || echo 'FAIL'
+
+${CLICKHOUSE_CLIENT} -n --query="
+    SET optimize_skip_unused_shards = 1;
+    SELECT count(*) FROM distributed_00754 PREWHERE a = 0 WHERE c LIKE '%l%';
+" 2>&1 \ | fgrep -q "All connection tries failed" && echo 'OK' || echo 'FAIL'
+
+${CLICKHOUSE_CLIENT} -n --query="
+    SET optimize_skip_unused_shards = 1;
+    SELECT count(*) FROM distributed_00754 PREWHERE a = 0 OR a = 1 AND b = 0;
+" 2>&1 \ | fgrep -q "All connection tries failed" && echo 'OK' || echo 'FAIL'
+
+${CLICKHOUSE_CLIENT} -n --query="
+    SET optimize_skip_unused_shards = 1;
+    SELECT count(*) FROM distributed_00754 PREWHERE a = 0 AND b = 0 OR a = 2 AND b = 2;
+" 2>&1 \ | fgrep -q "All connection tries failed" && echo 'OK' || echo 'FAIL'
+
+${CLICKHOUSE_CLIENT} -n --query="
+    SET optimize_skip_unused_shards = 1;
+    SELECT count(*) FROM distributed_00754 PREWHERE a = 0 AND b = 0 OR c LIKE '%l%';
+" 2>&1 \ | fgrep -q "All connection tries failed" && echo 'OK' || echo 'FAIL'

From a2fe2fb7b15b62dd94962a69a19a671190821747 Mon Sep 17 00:00:00 2001
From: "philip.han" <philip.han@kakaocorp.com>
Date: Tue, 20 Aug 2019 07:55:02 +0900
Subject: [PATCH 100/107] Fixed the test for 00632_aggregation_window_funnel.

---
 .../0_stateless/00632_aggregation_window_funnel.reference       | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/dbms/tests/queries/0_stateless/00632_aggregation_window_funnel.reference b/dbms/tests/queries/0_stateless/00632_aggregation_window_funnel.reference
index da7b788b157..179ef0e0209 100644
--- a/dbms/tests/queries/0_stateless/00632_aggregation_window_funnel.reference
+++ b/dbms/tests/queries/0_stateless/00632_aggregation_window_funnel.reference
@@ -16,3 +16,5 @@
 1
 1
 1
+1
+1

From bca580653dc06493a1cea06753a5078983803082 Mon Sep 17 00:00:00 2001
From: Alexander Tokmakov <avtokmakov@yandex-team.ru>
Date: Tue, 20 Aug 2019 02:09:02 +0300
Subject: [PATCH 101/107] fix csv input

---
 dbms/src/Formats/CSVRowInputStream.cpp                 | 10 ++++------
 dbms/src/Processors/Formats/Impl/CSVRowInputFormat.cpp | 10 ++++------
 2 files changed, 8 insertions(+), 12 deletions(-)

diff --git a/dbms/src/Formats/CSVRowInputStream.cpp b/dbms/src/Formats/CSVRowInputStream.cpp
index 662e6306e25..4b1b6198486 100644
--- a/dbms/src/Formats/CSVRowInputStream.cpp
+++ b/dbms/src/Formats/CSVRowInputStream.cpp
@@ -348,10 +348,9 @@ bool OPTIMIZE(1) CSVRowInputStream::parseRowAndPrintDiagnosticInfo(MutableColumn
             const auto & current_column_type = data_types[table_column];
             const bool is_last_file_column =
                     file_column + 1 == column_indexes_for_input_fields.size();
-            const bool at_delimiter = *istr.position() == delimiter;
+            const bool at_delimiter = !istr.eof() && *istr.position() == delimiter;
             const bool at_last_column_line_end = is_last_file_column
-                    && (*istr.position() == '\n' || *istr.position() == '\r'
-                        || istr.eof());
+                    && (istr.eof() || *istr.position() == '\n' || *istr.position() == '\r');
 
             out << "Column " << file_column << ", " << std::string((file_column < 10 ? 2 : file_column < 100 ? 1 : 0), ' ')
                 << "name: " << header.safeGetByPosition(table_column).name << ", " << std::string(max_length_of_column_name - header.safeGetByPosition(table_column).name.size(), ' ')
@@ -514,10 +513,9 @@ void CSVRowInputStream::updateDiagnosticInfo()
 
 bool CSVRowInputStream::readField(IColumn & column, const DataTypePtr & type, bool is_last_file_column, size_t column_idx)
 {
-    const bool at_delimiter = *istr.position() == format_settings.csv.delimiter;
+    const bool at_delimiter = !istr.eof() || *istr.position() == format_settings.csv.delimiter;
     const bool at_last_column_line_end = is_last_file_column
-                                         && (*istr.position() == '\n' || *istr.position() == '\r'
-                                             || istr.eof());
+                                         && (istr.eof() || *istr.position() == '\n' || *istr.position() == '\r');
 
     if (format_settings.csv.empty_as_default
         && (at_delimiter || at_last_column_line_end))
diff --git a/dbms/src/Processors/Formats/Impl/CSVRowInputFormat.cpp b/dbms/src/Processors/Formats/Impl/CSVRowInputFormat.cpp
index b13436a6600..2b8c1be6016 100644
--- a/dbms/src/Processors/Formats/Impl/CSVRowInputFormat.cpp
+++ b/dbms/src/Processors/Formats/Impl/CSVRowInputFormat.cpp
@@ -349,10 +349,9 @@ bool OPTIMIZE(1) CSVRowInputFormat::parseRowAndPrintDiagnosticInfo(MutableColumn
             const auto & current_column_type = data_types[table_column];
             const bool is_last_file_column =
                     file_column + 1 == column_indexes_for_input_fields.size();
-            const bool at_delimiter = *in.position() == delimiter;
+            const bool at_delimiter = !in.eof() && *in.position() == delimiter;
             const bool at_last_column_line_end = is_last_file_column
-                                                 && (*in.position() == '\n' || *in.position() == '\r'
-                                                     || in.eof());
+                                                 && (in.eof() || *in.position() == '\n' || *in.position() == '\r');
 
             auto & header = getPort().getHeader();
             out << "Column " << file_column << ", " << std::string((file_column < 10 ? 2 : file_column < 100 ? 1 : 0), ' ')
@@ -516,10 +515,9 @@ void CSVRowInputFormat::updateDiagnosticInfo()
 
 bool CSVRowInputFormat::readField(IColumn & column, const DataTypePtr & type, bool is_last_file_column, size_t column_idx)
 {
-    const bool at_delimiter = *in.position() == format_settings.csv.delimiter;
+    const bool at_delimiter = !in.eof() && *in.position() == format_settings.csv.delimiter;
     const bool at_last_column_line_end = is_last_file_column
-                                         && (*in.position() == '\n' || *in.position() == '\r'
-                                             || in.eof());
+                                         && (in.eof() || *in.position() == '\n' || *in.position() == '\r');
 
     if (format_settings.csv.empty_as_default
         && (at_delimiter || at_last_column_line_end))

From e594c344f5ab9bba4ed810df9a8707c09508f161 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Tue, 20 Aug 2019 03:48:08 +0300
Subject: [PATCH 102/107] Fixed idiotic error in system.parts

---
 dbms/src/Storages/System/StorageSystemPartsBase.cpp | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/dbms/src/Storages/System/StorageSystemPartsBase.cpp b/dbms/src/Storages/System/StorageSystemPartsBase.cpp
index 7a242e74e75..bced500a072 100644
--- a/dbms/src/Storages/System/StorageSystemPartsBase.cpp
+++ b/dbms/src/Storages/System/StorageSystemPartsBase.cpp
@@ -148,10 +148,9 @@ StoragesInfoStream::StoragesInfoStream(const SelectQueryInfo & query_info, const
 
 StoragesInfo StoragesInfoStream::next()
 {
-    StoragesInfo info;
-
     while (next_row < rows)
     {
+        StoragesInfo info;
 
         info.database = (*database_column)[next_row].get<String>();
         info.table = (*table_column)[next_row].get<String>();
@@ -198,10 +197,10 @@ StoragesInfo StoragesInfoStream::next()
         if (!info.data)
             throw Exception("Unknown engine " + info.engine, ErrorCodes::LOGICAL_ERROR);
 
-        break;
+        return info;
     }
 
-    return info;
+    return {};
 }
 
 BlockInputStreams StorageSystemPartsBase::read(

From 0e99eb82f43c115acef59ffed58f1ae4b9f73b6f Mon Sep 17 00:00:00 2001
From: BayoNet <da-daos@yandex.ru>
Date: Tue, 20 Aug 2019 10:23:47 +0300
Subject: [PATCH 103/107] DOCAPI-7129: nested json insert. EN review. RU
 translation. (#6419)

* Update formats.md

* Update settings.md

* Link fix.

* DOCAPI-7129: RU translation.

* DOCAPI-7129: Fixed build of ZH docs.

* Update docs/en/interfaces/formats.md

Co-Authored-By: Ivan Blinkov <github@blinkov.ru>

* Update docs/en/operations/settings/settings.md

Co-Authored-By: Ivan Blinkov <github@blinkov.ru>

* Update docs/ru/interfaces/formats.md

Co-Authored-By: Ivan Blinkov <github@blinkov.ru>

* Update docs/ru/interfaces/formats.md

Co-Authored-By: Ivan Blinkov <github@blinkov.ru>

* Update docs/ru/interfaces/formats.md

Co-Authored-By: Ivan Blinkov <github@blinkov.ru>

* Update docs/ru/operations/settings/settings.md

Co-Authored-By: Ivan Blinkov <github@blinkov.ru>

* Update docs/ru/operations/settings/settings.md

Co-Authored-By: Ivan Blinkov <github@blinkov.ru>

* DOCAPI-7129: Clarifications and fixes.
---
 docs/en/interfaces/formats.md           | 13 ++---
 docs/en/operations/settings/settings.md | 10 ++--
 docs/ru/interfaces/formats.md           | 71 ++++++++++++++++++++++---
 docs/ru/operations/settings/settings.md | 44 ++++++++++++++-
 4 files changed, 119 insertions(+), 19 deletions(-)

diff --git a/docs/en/interfaces/formats.md b/docs/en/interfaces/formats.md
index 46a553089d9..c5dbbce674d 100644
--- a/docs/en/interfaces/formats.md
+++ b/docs/en/interfaces/formats.md
@@ -1,9 +1,6 @@
 # Formats for input and output data {#formats}
 
-ClickHouse can accept and return data in various formats. A format supported
-for input can be used to parse the data provided to `INSERT`s, to perform
-`SELECT`s from a file-backed table such as File, URL or HDFS, or to read an
-external dictionary. A format supported for output can be used to arrange the
+ClickHouse can accept and return data in various formats. A format supported for input can be used to parse the data provided to `INSERT`s, to perform `SELECT`s from a file-backed table such as File, URL or HDFS, or to read an external dictionary. A format supported for output can be used to arrange the
 results of a `SELECT`, and to perform `INSERT`s into a file-backed table.
 
 The supported formats are:
@@ -388,7 +385,7 @@ Unlike the [JSON](#json) format, there is no substitution of invalid UTF-8 seque
 
 ### Usage of Nested Structures {#jsoneachrow-nested}
 
-If you have a table with the [Nested](../data_types/nested_data_structures/nested.md) data type columns, you can insert JSON data having the same structure. Enable this functionality with the [input_format_import_nested_json](../operations/settings/settings.md#settings-input_format_import_nested_json) setting.
+If you have a table with [Nested](../data_types/nested_data_structures/nested.md) data type columns, you can insert JSON data with the same structure. Enable this feature with the [input_format_import_nested_json](../operations/settings/settings.md#settings-input_format_import_nested_json) setting.
 
 For example, consider the following table:
 
@@ -396,13 +393,13 @@ For example, consider the following table:
 CREATE TABLE json_each_row_nested (n Nested (s String, i Int32) ) ENGINE = Memory
 ```
 
-As you can find in the `Nested` data type description, ClickHouse treats each component of the nested structure as a separate column, `n.s` and `n.i` for our table. So you can insert the data the following way:
+As you can see in the `Nested` data type description, ClickHouse treats each component of the nested structure as a separate column (`n.s` and `n.i` for our table). You can insert data in the following way:
 
 ```sql
 INSERT INTO json_each_row_nested FORMAT JSONEachRow {"n.s": ["abc", "def"], "n.i": [1, 23]}
 ```
 
-To insert data as hierarchical JSON object set [input_format_import_nested_json=1](../operations/settings/settings.md#settings-input_format_import_nested_json).
+To insert data as a hierarchical JSON object, set [input_format_import_nested_json=1](../operations/settings/settings.md#settings-input_format_import_nested_json).
 
 ```json
 {
@@ -413,7 +410,7 @@ To insert data as hierarchical JSON object set [input_format_import_nested_json=
 }
 ```
 
-Without this setting ClickHouse throws the exception.
+Without this setting, ClickHouse throws an exception.
 
 ```sql
 SELECT name, value FROM system.settings WHERE name = 'input_format_import_nested_json'
diff --git a/docs/en/operations/settings/settings.md b/docs/en/operations/settings/settings.md
index 9ff1971ab88..9e298583b38 100644
--- a/docs/en/operations/settings/settings.md
+++ b/docs/en/operations/settings/settings.md
@@ -238,7 +238,7 @@ Default value: 0.
 
 ## input_format_import_nested_json {#settings-input_format_import_nested_json}
 
-Enables or disables inserting of JSON data with nested objects.
+Enables or disables the insertion of JSON data with nested objects.
 
 Supported formats:
 
@@ -275,7 +275,7 @@ Default value: 1.
 
 ## date_time_input_format {#settings-date_time_input_format}
 
-Enables or disables extended parsing of date and time formatted strings.
+Allows to choose a parser of text representation of date and time.
 
 The setting doesn't apply to [date and time functions](../../query_language/functions/date_time_functions.md).
 
@@ -283,11 +283,13 @@ Possible values:
 
 - `'best_effort'` — Enables extended parsing.
 
-    ClickHouse can parse the basic format `YYYY-MM-DD HH:MM:SS` and all the [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) date and time formats. For example, `'2018-06-08T01:02:03.000Z'`.
+    ClickHouse can parse the basic `YYYY-MM-DD HH:MM:SS` format and all [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) date and time formats. For example, `'2018-06-08T01:02:03.000Z'`.
 
 - `'basic'` — Use basic parser.
 
-    ClickHouse can parse only the basic format.
+    ClickHouse can parse only the basic `YYYY-MM-DD HH:MM:SS` format. For example, `'2019-08-20 10:18:56'`.
+
+Default value: `'basic'`.
 
 **See Also**
 
diff --git a/docs/ru/interfaces/formats.md b/docs/ru/interfaces/formats.md
index 20aa78630b7..20c919665d5 100644
--- a/docs/ru/interfaces/formats.md
+++ b/docs/ru/interfaces/formats.md
@@ -377,9 +377,68 @@ CREATE TABLE IF NOT EXISTS example_table
 
 В отличие от формата [JSON](#json), для `JSONEachRow` ClickHouse не заменяет невалидные UTF-8 последовательности. Значения экранируются так же, как и для формата `JSON`.
 
-!!! Примечание " Примечание"
+!!! note "Примечание"
     В строках может выводиться произвольный набор байт. Используйте формат `JSONEachRow`, если вы уверены, что данные в таблице могут быть представлены в формате JSON без потери информации.
 
+### Использование вложенных структур {#jsoneachrow-nested}
+
+Если у вас есть таблица со столбцами типа [Nested](../data_types/nested_data_structures/nested.md), то в неё можно вставить данные из JSON-документа с такой же структурой. Функциональность включается настройкой [input_format_import_nested_json](../operations/settings/settings.md#settings-input_format_import_nested_json).
+
+Например, рассмотрим следующую таблицу:
+
+```sql
+CREATE TABLE json_each_row_nested (n Nested (s String, i Int32) ) ENGINE = Memory
+```
+
+Из описания типа данных `Nested` видно, что ClickHouse трактует каждый компонент вложенной структуры как отдельный столбец (для нашей таблицы `n.s` и `n.i`). Можно вставить данные следующим образом:
+
+```sql
+INSERT INTO json_each_row_nested FORMAT JSONEachRow {"n.s": ["abc", "def"], "n.i": [1, 23]}
+```
+
+Чтобы вставить данные как иерархический объект JSON, установите [input_format_import_nested_json=1](../operations/settings/settings.md#settings-input_format_import_nested_json).
+
+```json
+{
+    "n": {
+        "s": ["abc", "def"],
+        "i": [1, 23]
+    }
+}
+```
+
+Без этой настройки ClickHouse сгенерирует исключение.
+
+```sql
+SELECT name, value FROM system.settings WHERE name = 'input_format_import_nested_json'
+```
+
+```text
+┌─name────────────────────────────┬─value─┐
+│ input_format_import_nested_json │ 0     │
+└─────────────────────────────────┴───────┘
+```
+
+```sql
+INSERT INTO json_each_row_nested FORMAT JSONEachRow {"n": {"s": ["abc", "def"], "i": [1, 23]}}
+```
+
+```text
+Code: 117. DB::Exception: Unknown field found while parsing JSONEachRow format: n: (at row 1)
+```
+
+```sql
+SET input_format_import_nested_json=1
+INSERT INTO json_each_row_nested FORMAT JSONEachRow {"n": {"s": ["abc", "def"], "i": [1, 23]}}
+SELECT * FROM json_each_row_nested
+```
+
+```text
+┌─n.s───────────┬─n.i────┐
+│ ['abc','def'] │ [1,23] │
+└───────────────┴────────┘
+```
+
 ## Native {#native}
 
 Самый эффективный формат. Данные пишутся и читаются блоками в бинарном виде. Для каждого блока пишется количество строк, количество столбцов, имена и типы столбцов, а затем кусочки столбцов этого блока, один за другим. То есть, этот формат является "столбцовым" - не преобразует столбцы в строки. Именно этот формат используется в родном интерфейсе - при межсерверном взаимодействии, при использовании клиента командной строки, при работе клиентов, написанных на C++.
@@ -399,7 +458,7 @@ CREATE TABLE IF NOT EXISTS example_table
 
 [NULL](../query_language/syntax.md) выводится как `ᴺᵁᴸᴸ`.
 
-``` sql
+```sql
 SELECT * FROM t_null
 ```
 ```
@@ -410,7 +469,7 @@ SELECT * FROM t_null
 
 В форматах `Pretty*` строки выводятся без экранирования. Ниже приведен пример для формата [PrettyCompact](#prettycompact):
 
-``` sql
+```sql
 SELECT 'String with \'quotes\' and \t character' AS Escaping_test
 ```
 
@@ -425,7 +484,7 @@ SELECT 'String with \'quotes\' and \t character' AS Escaping_test
 
 Формат `Pretty` поддерживает вывод тотальных значений (при использовании WITH TOTALS) и экстремальных значений (при настройке extremes выставленной в 1). В этих случаях, после основных данных выводятся тотальные значения, и экстремальные значения, в отдельных табличках. Пример (показан для формата [PrettyCompact](#prettycompact)):
 
-``` sql
+```sql
 SELECT EventDate, count() AS c FROM test.hits GROUP BY EventDate WITH TOTALS ORDER BY EventDate FORMAT PrettyCompact
 ```
 
@@ -516,7 +575,7 @@ Array представлены как длина в формате varint (unsig
 
 Пример:
 
-``` sql
+```sql
 SELECT * FROM t_null FORMAT Vertical
 ```
 ```
@@ -528,7 +587,7 @@ y: ᴺᵁᴸᴸ
 
 В формате `Vertical` строки выводятся без экранирования. Например:
 
-``` sql
+```sql
 SELECT 'string with \'quotes\' and \t with some special \n characters' AS test FORMAT Vertical
 ```
 
diff --git a/docs/ru/operations/settings/settings.md b/docs/ru/operations/settings/settings.md
index c3d17ddfe35..07c1e5ae977 100644
--- a/docs/ru/operations/settings/settings.md
+++ b/docs/ru/operations/settings/settings.md
@@ -233,7 +233,26 @@ Ok.
 - 0 — выключена.
 - 1 — включена.
 
-Значение по умолчанию: 0.
+Значение по умолчанию — 0.
+
+## input_format_import_nested_json {#settings-input_format_import_nested_json}
+
+Включает или отключает вставку данных JSON с вложенными объектами.
+
+Поддерживаемые форматы:
+
+- [JSONEachRow](../../interfaces/formats.md#jsoneachrow)
+
+Возможные значения:
+
+- 0 — выключена.
+- 1 — включена.
+
+Значение по умолчанию — 0.
+
+**Смотрите также**
+
+- [Использование вложенных структур](../../interfaces/formats.md#jsoneachrow-nested) with the `JSONEachRow` format.
 
 ## input_format_with_names_use_header {#settings-input_format_with_names_use_header}
 
@@ -253,6 +272,29 @@ Ok.
 
 Значение по умолчанию: 1.
 
+## date_time_input_format {#settings-date_time_input_format}
+
+Выбор парсера для текстового представления дат и времени при обработке входного формата.
+
+Настройка не применяется к [функциям для работы с датой и временем](../../query_language/functions/date_time_functions.md).
+
+Возможные значения:
+
+- `'best_effort'` — включает расширенный парсинг.
+
+    ClickHouse может парсить базовый формат `YYYY-MM-DD HH:MM:SS` и все форматы [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601). Например, `'2018-06-08T01:02:03.000Z'`.
+
+- `'basic'` — используется базовый парсер.
+
+    ClickHouse может парсить только базовый формат `YYYY-MM-DD HH:MM:SS`. Например, `'2019-08-20 10:18:56'`.
+
+Значение по умолчанию — `'basic'`.
+
+**Смотрите также**
+
+- [Тип данных DateTime.](../../data_types/datetime.md)
+- [Функции для работы с датой и временем.](../../query_language/functions/date_time_functions.md)
+
 ## join_default_strictness {#settings-join_default_strictness}
 
 Устанавливает строгость по умолчанию для [JOIN](../../query_language/select.md#select-join).

From 87e13c494ec9761129dee694c4e59e8c1f9b6c96 Mon Sep 17 00:00:00 2001
From: BayoNet <da-daos@yandex.ru>
Date: Tue, 20 Aug 2019 10:46:31 +0300
Subject: [PATCH 104/107] DOCAPI-7414: groupArrayMovingSum, groupArrayMovingAvg
 docs. EN review, RU translation. (#6463)

* Update reference.md

* DOCAPI-7414: RU translation

* DOCAPI-7414: Fix.

* Update docs/ru/query_language/agg_functions/reference.md

Co-Authored-By: Ivan Blinkov <github@blinkov.ru>

* Update docs/ru/query_language/agg_functions/reference.md

Co-Authored-By: Ivan Blinkov <github@blinkov.ru>

* Update docs/ru/query_language/agg_functions/reference.md

Co-Authored-By: Ivan Blinkov <github@blinkov.ru>

* Update docs/ru/query_language/agg_functions/reference.md

Co-Authored-By: Ivan Blinkov <github@blinkov.ru>
---
 .../query_language/agg_functions/reference.md |   8 +-
 .../query_language/agg_functions/reference.md | 150 +++++++++++++++++-
 2 files changed, 153 insertions(+), 5 deletions(-)

diff --git a/docs/en/query_language/agg_functions/reference.md b/docs/en/query_language/agg_functions/reference.md
index 3e3e1e2cc01..5f3007a60cd 100644
--- a/docs/en/query_language/agg_functions/reference.md
+++ b/docs/en/query_language/agg_functions/reference.md
@@ -681,11 +681,11 @@ groupArrayMovingSum(numbers_for_summing)
 groupArrayMovingSum(window_size)(numbers_for_summing)
 ```
 
-The function can take the window size as a parameter. If it not specified, the function takes the window size equal to the number of rows in the column.
+The function can take the window size as a parameter. If left unspecified, the function takes the window size equal to the number of rows in the column.
 
 **Parameters**
 
-- `numbers_for_summing` — [Expression](../syntax.md#syntax-expressions) resulting with a value in a numeric data type.
+- `numbers_for_summing` — [Expression](../syntax.md#syntax-expressions) resulting in a numeric data type value.
 - `window_size` — Size of the calculation window.
 
 **Returned values**
@@ -750,11 +750,11 @@ groupArrayMovingAvg(numbers_for_summing)
 groupArrayMovingAvg(window_size)(numbers_for_summing)
 ```
 
-The function can take the window size as a parameter. If it not specified, the function takes the window size equal to the number of rows in the column.
+The function can take the window size as a parameter. If left unspecified, the function takes the window size equal to the number of rows in the column.
 
 **Parameters**
 
-- `numbers_for_summing` — [Expression](../syntax.md#syntax-expressions) resulting with a value in a numeric data type.
+- `numbers_for_summing` — [Expression](../syntax.md#syntax-expressions) resulting in a numeric data type value.
 - `window_size` — Size of the calculation window.
 
 **Returned values**
diff --git a/docs/ru/query_language/agg_functions/reference.md b/docs/ru/query_language/agg_functions/reference.md
index 12308169f9a..b948b17abee 100644
--- a/docs/ru/query_language/agg_functions/reference.md
+++ b/docs/ru/query_language/agg_functions/reference.md
@@ -87,7 +87,7 @@ anyHeavy(column)
 
 **Аргументы**
 
-- `column` – Имя столбца.
+- `column` — имя столбца.
 
 **Пример**
 
@@ -681,6 +681,154 @@ uniqExact(x[, ...])
 - Значение по умолчанию для подстановки на пустые позиции.
 - Длина результирующего массива. Например, если вы хотите получать массивы одинакового размера для всех агрегатных ключей. При использовании этого параметра значение по умолчанию задавать обязательно.
 
+## groupArrayMovingSum {#agg_function-grouparraymovingsum}
+
+Вычисляет скользящую сумму входных значений.
+
+```
+groupArrayMovingSum(numbers_for_summing)
+groupArrayMovingSum(window_size)(numbers_for_summing)
+```
+
+Функция может принимать размер окна в качестве параметра. Если окно не указано, то функция использует размер окна, равный количеству строк в столбце.
+
+**Параметры**
+
+- `numbers_for_summing` — [выражение](../syntax.md#syntax-expressions), возвращающее значение числового типа.
+- `window_size` — размер окна.
+
+**Возвращаемые значения**
+
+- Массив того же размера и типа, что и входные данные.
+
+**Пример**
+
+Таблица с исходными данными:
+
+```sql
+CREATE TABLE t
+(
+    `int` UInt8,
+    `float` Float32,
+    `dec` Decimal32(2)
+)
+ENGINE = TinyLog
+```
+
+```text
+┌─int─┬─float─┬──dec─┐
+│   1 │   1.1 │ 1.10 │
+│   2 │   2.2 │ 2.20 │
+│   4 │   4.4 │ 4.40 │
+│   7 │  7.77 │ 7.77 │
+└─────┴───────┴──────┘
+```
+
+Запросы:
+
+```sql
+SELECT
+    groupArrayMovingSum(int) AS I,
+    groupArrayMovingSum(float) AS F,
+    groupArrayMovingSum(dec) AS D
+FROM t
+```
+
+```text
+┌─I──────────┬─F───────────────────────────────┬─D──────────────────────┐
+│ [1,3,7,14] │ [1.1,3.3000002,7.7000003,15.47] │ [1.10,3.30,7.70,15.47] │
+└────────────┴─────────────────────────────────┴────────────────────────┘
+```
+
+```sql
+SELECT
+    groupArrayMovingSum(2)(int) AS I,
+    groupArrayMovingSum(2)(float) AS F,
+    groupArrayMovingSum(2)(dec) AS D
+FROM t
+```
+
+```text
+┌─I──────────┬─F───────────────────────────────┬─D──────────────────────┐
+│ [1,3,6,11] │ [1.1,3.3000002,6.6000004,12.17] │ [1.10,3.30,6.60,12.17] │
+└────────────┴─────────────────────────────────┴────────────────────────┘
+```
+
+## groupArrayMovingAvg {#agg_function-grouparraymovingavg}
+
+Вычисляет скользящее среднее для входных значений.
+
+```
+groupArrayMovingAvg(numbers_for_summing)
+groupArrayMovingAvg(window_size)(numbers_for_summing)
+```
+
+Функция может принимать размер окна в качестве параметра. Если окно не указано, то функция использует размер окна, равный количеству строк в столбце.
+
+**Параметры**
+
+- `numbers_for_summing` — [выражение](../syntax.md#syntax-expressions), возвращающее значение числового типа.
+- `window_size` — размер окна.
+
+**Возвращаемые значения**
+
+- Массив того же размера и типа, что и входные данные.
+
+Функция использует [округление к меньшему по модулю](https://ru.wikipedia.org/wiki/Округление#Методы). Оно усекает десятичные разряды, незначимые для результирующего типа данных.
+
+**Пример**
+
+Таблица с исходными данными:
+
+```sql
+CREATE TABLE t
+(
+    `int` UInt8,
+    `float` Float32,
+    `dec` Decimal32(2)
+)
+ENGINE = TinyLog
+```
+
+```text
+┌─int─┬─float─┬──dec─┐
+│   1 │   1.1 │ 1.10 │
+│   2 │   2.2 │ 2.20 │
+│   4 │   4.4 │ 4.40 │
+│   7 │  7.77 │ 7.77 │
+└─────┴───────┴──────┘
+```
+
+Запросы:
+
+```sql
+SELECT
+    groupArrayMovingAvg(int) AS I,
+    groupArrayMovingAvg(float) AS F,
+    groupArrayMovingAvg(dec) AS D
+FROM t
+```
+
+```text
+┌─I─────────┬─F───────────────────────────────────┬─D─────────────────────┐
+│ [0,0,1,3] │ [0.275,0.82500005,1.9250001,3.8675] │ [0.27,0.82,1.92,3.86] │
+└───────────┴─────────────────────────────────────┴───────────────────────┘
+```
+
+```sql
+SELECT
+    groupArrayMovingAvg(2)(int) AS I,
+    groupArrayMovingAvg(2)(float) AS F,
+    groupArrayMovingAvg(2)(dec) AS D
+FROM t
+```
+
+```text
+┌─I─────────┬─F────────────────────────────────┬─D─────────────────────┐
+│ [0,1,3,5] │ [0.55,1.6500001,3.3000002,6.085] │ [0.55,1.65,3.30,6.08] │
+└───────────┴──────────────────────────────────┴───────────────────────┘
+```
+
 ## groupUniqArray(x), groupUniqArray(max_size)(x)
 
 Составляет массив из различных значений аргумента. Расход оперативной памяти такой же, как у функции `uniqExact`.

From a502424c3378572e3cf0a2e498d762d938a5bd93 Mon Sep 17 00:00:00 2001
From: Ivan <5627721+abyss7@users.noreply.github.com>
Date: Tue, 20 Aug 2019 14:17:57 +0300
Subject: [PATCH 105/107] Implement support for insertion into Kafka tables
 (#6012)

* Add write-callback on each row for RowOutputStream
* Fix build of new rdkafka library
* Poll messages if Kafka outgoing queue is full
* Add test
* Add test producer-consumer
* Truncate delimiter from last row in message
---
 dbms/src/Core/Settings.h                      |   2 +-
 .../BlockOutputStreamFromRowOutputStream.cpp  |  45 ------
 .../BlockOutputStreamFromRowOutputStream.h    |  38 -----
 dbms/src/Formats/FormatFactory.cpp            |  14 +-
 dbms/src/Formats/FormatFactory.h              |  12 +-
 dbms/src/Formats/NativeFormat.cpp             |   1 +
 dbms/src/Formats/NullFormat.cpp               |   1 +
 .../Formats/tests/block_row_transforms.cpp    |   3 +-
 .../Formats/tests/tab_separated_streams.cpp   |   3 +-
 dbms/src/IO/MemoryReadWriteBuffer.h           |   2 +-
 dbms/src/IO/WriteBuffer.h                     |   2 +-
 .../Processors/Formats/IRowOutputFormat.cpp   |   6 +-
 .../src/Processors/Formats/IRowOutputFormat.h |  13 +-
 .../Formats/Impl/BinaryRowOutputFormat.cpp    |  10 +-
 .../Formats/Impl/BinaryRowOutputFormat.h      |   3 +-
 .../Formats/Impl/CSVRowOutputFormat.cpp       |   7 +-
 .../Formats/Impl/CSVRowOutputFormat.h         |   3 +-
 .../Impl/JSONCompactRowOutputFormat.cpp       |   7 +-
 .../Formats/Impl/JSONCompactRowOutputFormat.h |   2 +-
 .../Impl/JSONEachRowRowOutputFormat.cpp       |   7 +-
 .../Formats/Impl/JSONEachRowRowOutputFormat.h |   3 +-
 .../Formats/Impl/JSONRowOutputFormat.cpp      |   8 +-
 .../Formats/Impl/JSONRowOutputFormat.h        |   3 +-
 .../Formats/Impl/MySQLOutputFormat.cpp        |  10 +-
 .../Formats/Impl/MySQLOutputFormat.h          |   1 -
 .../Processors/Formats/Impl/NativeFormat.cpp  |   1 +
 .../Processors/Formats/Impl/NullFormat.cpp    |   1 +
 .../Impl/ODBCDriver2BlockOutputFormat.cpp     |   2 +-
 .../Impl/ODBCDriverBlockOutputFormat.cpp      |   1 +
 .../Formats/Impl/ParquetBlockOutputFormat.cpp |   7 +-
 .../Formats/Impl/PrettyBlockOutputFormat.cpp  |   2 +
 .../Impl/PrettyCompactBlockOutputFormat.cpp   |   2 +
 .../Impl/PrettySpaceBlockOutputFormat.cpp     |   2 +
 .../Formats/Impl/ProtobufRowOutputFormat.cpp  |  12 +-
 .../Formats/Impl/ProtobufRowOutputFormat.h    |   1 +
 .../Formats/Impl/TSKVRowOutputFormat.cpp      |   7 +-
 .../Formats/Impl/TSKVRowOutputFormat.h        |   3 +-
 .../Impl/TabSeparatedRawRowOutputFormat.h     |  13 +-
 .../Impl/TabSeparatedRowOutputFormat.cpp      |  22 ++-
 .../Impl/TabSeparatedRowOutputFormat.h        |   9 +-
 .../Formats/Impl/ValuesRowOutputFormat.cpp    |   7 +-
 .../Formats/Impl/ValuesRowOutputFormat.h      |   3 +-
 .../Formats/Impl/VerticalRowOutputFormat.cpp  |   7 +-
 .../Formats/Impl/VerticalRowOutputFormat.h    |   3 +-
 .../Formats/Impl/XMLRowOutputFormat.cpp       |   7 +-
 .../Formats/Impl/XMLRowOutputFormat.h         |   3 +-
 .../Storages/Kafka/KafkaBlockInputStream.cpp  |  13 +-
 .../Storages/Kafka/KafkaBlockInputStream.h    |   2 +-
 .../Storages/Kafka/KafkaBlockOutputStream.cpp |  54 +++++++
 .../Storages/Kafka/KafkaBlockOutputStream.h   |  31 ++++
 .../Kafka/ReadBufferFromKafkaConsumer.h       |   2 +-
 dbms/src/Storages/Kafka/StorageKafka.cpp      | 140 ++++++++++--------
 dbms/src/Storages/Kafka/StorageKafka.h        |  27 ++--
 .../Kafka/WriteBufferToKafkaProducer.cpp      |  90 +++++++++++
 .../Kafka/WriteBufferToKafkaProducer.h        |  46 ++++++
 .../integration/test_storage_kafka/test.py    | 115 +++++++++++++-
 .../libcommon/include/ext/shared_ptr_helper.h |   2 +-
 utils/kafka/consume.py                        |   1 +
 58 files changed, 590 insertions(+), 254 deletions(-)
 delete mode 100644 dbms/src/Formats/BlockOutputStreamFromRowOutputStream.cpp
 delete mode 100644 dbms/src/Formats/BlockOutputStreamFromRowOutputStream.h
 create mode 100644 dbms/src/Storages/Kafka/KafkaBlockOutputStream.cpp
 create mode 100644 dbms/src/Storages/Kafka/KafkaBlockOutputStream.h
 create mode 100644 dbms/src/Storages/Kafka/WriteBufferToKafkaProducer.cpp
 create mode 100644 dbms/src/Storages/Kafka/WriteBufferToKafkaProducer.h

diff --git a/dbms/src/Core/Settings.h b/dbms/src/Core/Settings.h
index c4f374fbc70..86e8746e854 100644
--- a/dbms/src/Core/Settings.h
+++ b/dbms/src/Core/Settings.h
@@ -212,7 +212,7 @@ struct Settings : public SettingsCollection<Settings>
     M(SettingUInt64, insert_distributed_timeout, 0, "Timeout for insert query into distributed. Setting is used only with insert_distributed_sync enabled. Zero value means no timeout.") \
     M(SettingInt64, distributed_ddl_task_timeout, 180, "Timeout for DDL query responses from all hosts in cluster. If a ddl request has not been performed on all hosts, a response will contain a timeout error and a request will be executed in an async mode. Negative value means infinite.") \
     M(SettingMilliseconds, stream_flush_interval_ms, 7500, "Timeout for flushing data from streaming storages.") \
-    M(SettingMilliseconds, stream_poll_timeout_ms, 500, "Timeout for polling data from streaming storages.") \
+    M(SettingMilliseconds, stream_poll_timeout_ms, 500, "Timeout for polling data from/to streaming storages.") \
     M(SettingString, format_schema, "", "Schema identifier (used by schema-based formats)") \
     M(SettingBool, insert_allow_materialized_columns, 0, "If setting is enabled, Allow materialized columns in INSERT.") \
     M(SettingSeconds, http_connection_timeout, DEFAULT_HTTP_READ_BUFFER_CONNECTION_TIMEOUT, "HTTP connection timeout.") \
diff --git a/dbms/src/Formats/BlockOutputStreamFromRowOutputStream.cpp b/dbms/src/Formats/BlockOutputStreamFromRowOutputStream.cpp
deleted file mode 100644
index c4fabfa83d8..00000000000
--- a/dbms/src/Formats/BlockOutputStreamFromRowOutputStream.cpp
+++ /dev/null
@@ -1,45 +0,0 @@
-#include <Core/Block.h>
-#include <Formats/BlockOutputStreamFromRowOutputStream.h>
-
-
-namespace DB
-{
-
-BlockOutputStreamFromRowOutputStream::BlockOutputStreamFromRowOutputStream(RowOutputStreamPtr row_output_, const Block & header_)
-    : row_output(row_output_), header(header_) {}
-
-
-void BlockOutputStreamFromRowOutputStream::write(const Block & block)
-{
-    size_t rows = block.rows();
-    for (size_t i = 0; i < rows; ++i)
-    {
-        if (!first_row)
-            row_output->writeRowBetweenDelimiter();
-        first_row = false;
-        row_output->write(block, i);
-    }
-}
-
-
-void BlockOutputStreamFromRowOutputStream::setRowsBeforeLimit(size_t rows_before_limit)
-{
-    row_output->setRowsBeforeLimit(rows_before_limit);
-}
-
-void BlockOutputStreamFromRowOutputStream::setTotals(const Block & totals)
-{
-    row_output->setTotals(totals);
-}
-
-void BlockOutputStreamFromRowOutputStream::setExtremes(const Block & extremes)
-{
-    row_output->setExtremes(extremes);
-}
-
-void BlockOutputStreamFromRowOutputStream::onProgress(const Progress & progress)
-{
-    row_output->onProgress(progress);
-}
-
-}
diff --git a/dbms/src/Formats/BlockOutputStreamFromRowOutputStream.h b/dbms/src/Formats/BlockOutputStreamFromRowOutputStream.h
deleted file mode 100644
index ada924bb5b4..00000000000
--- a/dbms/src/Formats/BlockOutputStreamFromRowOutputStream.h
+++ /dev/null
@@ -1,38 +0,0 @@
-#pragma once
-
-#include <DataStreams/IBlockOutputStream.h>
-#include <Formats/IRowOutputStream.h>
-
-
-namespace DB
-{
-
-/** Transforms a stream to write data by rows to a stream to write data by blocks.
-  * For example, to write a text dump.
-  */
-class BlockOutputStreamFromRowOutputStream : public IBlockOutputStream
-{
-public:
-    BlockOutputStreamFromRowOutputStream(RowOutputStreamPtr row_output_, const Block & header_);
-
-    Block getHeader() const override { return header; }
-    void write(const Block & block) override;
-    void writePrefix() override { row_output->writePrefix(); }
-    void writeSuffix() override { row_output->writeSuffix(); }
-
-    void flush() override { row_output->flush(); }
-
-    void setRowsBeforeLimit(size_t rows_before_limit) override;
-    void setTotals(const Block & totals) override;
-    void setExtremes(const Block & extremes) override;
-    void onProgress(const Progress & progress) override;
-
-    String getContentType() const override { return row_output->getContentType(); }
-
-private:
-    RowOutputStreamPtr row_output;
-    Block header;
-    bool first_row = true;
-};
-
-}
diff --git a/dbms/src/Formats/FormatFactory.cpp b/dbms/src/Formats/FormatFactory.cpp
index 7fa4b59cf66..f587b2fd5ae 100644
--- a/dbms/src/Formats/FormatFactory.cpp
+++ b/dbms/src/Formats/FormatFactory.cpp
@@ -100,7 +100,8 @@ BlockInputStreamPtr FormatFactory::getInput(
 }
 
 
-BlockOutputStreamPtr FormatFactory::getOutput(const String & name, WriteBuffer & buf, const Block & sample, const Context & context) const
+BlockOutputStreamPtr FormatFactory::getOutput(
+    const String & name, WriteBuffer & buf, const Block & sample, const Context & context, WriteCallback callback) const
 {
     if (name == "PrettyCompactMonoBlock")
     {
@@ -124,14 +125,14 @@ BlockOutputStreamPtr FormatFactory::getOutput(const String & name, WriteBuffer &
         const Settings & settings = context.getSettingsRef();
         FormatSettings format_settings = getOutputFormatSetting(settings);
 
-        /** Materialization is needed, because formats can use the functions `IDataType`,
+        /**  Materialization is needed, because formats can use the functions `IDataType`,
           *  which only work with full columns.
           */
         return std::make_shared<MaterializingBlockOutputStream>(
-                output_getter(buf, sample, context, format_settings), sample);
+                output_getter(buf, sample, context, callback, format_settings), sample);
     }
 
-    auto format = getOutputFormat(name, buf, sample, context);
+    auto format = getOutputFormat(name, buf, sample, context, callback);
     return std::make_shared<MaterializingBlockOutputStream>(std::make_shared<OutputStreamToOutputFormat>(format), sample);
 }
 
@@ -165,7 +166,8 @@ InputFormatPtr FormatFactory::getInputFormat(
 }
 
 
-OutputFormatPtr FormatFactory::getOutputFormat(const String & name, WriteBuffer & buf, const Block & sample, const Context & context) const
+OutputFormatPtr FormatFactory::getOutputFormat(
+    const String & name, WriteBuffer & buf, const Block & sample, const Context & context, WriteCallback callback) const
 {
     const auto & output_getter = getCreators(name).output_processor_creator;
     if (!output_getter)
@@ -177,7 +179,7 @@ OutputFormatPtr FormatFactory::getOutputFormat(const String & name, WriteBuffer
     /** TODO: Materialization is needed, because formats can use the functions `IDataType`,
       *  which only work with full columns.
       */
-    return output_getter(buf, sample, context, format_settings);
+    return output_getter(buf, sample, context, callback, format_settings);
 }
 
 
diff --git a/dbms/src/Formats/FormatFactory.h b/dbms/src/Formats/FormatFactory.h
index 83728c96cd2..576faa9174e 100644
--- a/dbms/src/Formats/FormatFactory.h
+++ b/dbms/src/Formats/FormatFactory.h
@@ -41,6 +41,10 @@ public:
     /// It's initial purpose was to extract payload for virtual columns from Kafka Consumer ReadBuffer.
     using ReadCallback = std::function<void()>;
 
+    /// This callback allows to perform some additional actions after writing a single row.
+    /// It's initial purpose was to flush Kafka message for each row.
+    using WriteCallback = std::function<void()>;
+
 private:
     using InputCreator = std::function<BlockInputStreamPtr(
         ReadBuffer & buf,
@@ -55,6 +59,7 @@ private:
         WriteBuffer & buf,
         const Block & sample,
         const Context & context,
+        WriteCallback callback,
         const FormatSettings & settings)>;
 
     using InputProcessorCreator = std::function<InputFormatPtr(
@@ -68,6 +73,7 @@ private:
             WriteBuffer & buf,
             const Block & sample,
             const Context & context,
+            WriteCallback callback,
             const FormatSettings & settings)>;
 
     struct Creators
@@ -91,7 +97,7 @@ public:
         ReadCallback callback = {}) const;
 
     BlockOutputStreamPtr getOutput(const String & name, WriteBuffer & buf,
-        const Block & sample, const Context & context) const;
+        const Block & sample, const Context & context, WriteCallback callback = {}) const;
 
     InputFormatPtr getInputFormat(
         const String & name,
@@ -102,8 +108,8 @@ public:
         UInt64 rows_portion_size = 0,
         ReadCallback callback = {}) const;
 
-    OutputFormatPtr getOutputFormat(const String & name, WriteBuffer & buf,
-        const Block & sample, const Context & context) const;
+    OutputFormatPtr getOutputFormat(
+        const String & name, WriteBuffer & buf, const Block & sample, const Context & context, WriteCallback callback = {}) const;
 
     /// Register format by its name.
     void registerInputFormat(const String & name, InputCreator input_creator);
diff --git a/dbms/src/Formats/NativeFormat.cpp b/dbms/src/Formats/NativeFormat.cpp
index f324879608b..f9063e0eced 100644
--- a/dbms/src/Formats/NativeFormat.cpp
+++ b/dbms/src/Formats/NativeFormat.cpp
@@ -27,6 +27,7 @@ void registerOutputFormatNative(FormatFactory & factory)
         WriteBuffer & buf,
         const Block & sample,
         const Context &,
+        FormatFactory::WriteCallback,
         const FormatSettings &)
     {
         return std::make_shared<NativeBlockOutputStream>(buf, 0, sample);
diff --git a/dbms/src/Formats/NullFormat.cpp b/dbms/src/Formats/NullFormat.cpp
index 0012b4c54b2..d5376b70fe1 100644
--- a/dbms/src/Formats/NullFormat.cpp
+++ b/dbms/src/Formats/NullFormat.cpp
@@ -11,6 +11,7 @@ void registerOutputFormatNull(FormatFactory & factory)
         WriteBuffer &,
         const Block & sample,
         const Context &,
+        FormatFactory::WriteCallback,
         const FormatSettings &)
     {
         return std::make_shared<NullBlockOutputStream>(sample);
diff --git a/dbms/src/Formats/tests/block_row_transforms.cpp b/dbms/src/Formats/tests/block_row_transforms.cpp
index b2fe876fb2a..9edc520d85f 100644
--- a/dbms/src/Formats/tests/block_row_transforms.cpp
+++ b/dbms/src/Formats/tests/block_row_transforms.cpp
@@ -14,7 +14,6 @@
 
 #include <Formats/TabSeparatedRowInputStream.h>
 #include <Formats/BlockInputStreamFromRowInputStream.h>
-#include <Formats/BlockOutputStreamFromRowOutputStream.h>
 
 #include <DataStreams/copyData.h>
 #include <Processors/Formats/Impl/TabSeparatedRowOutputFormat.h>
@@ -47,7 +46,7 @@ try
 
     RowInputStreamPtr row_input = std::make_shared<TabSeparatedRowInputStream>(in_buf, sample, false, false, format_settings);
     BlockInputStreamFromRowInputStream block_input(row_input, sample, DEFAULT_INSERT_BLOCK_SIZE, 0, []{}, format_settings);
-    BlockOutputStreamPtr block_output = std::make_shared<OutputStreamToOutputFormat>(std::make_shared<TabSeparatedRowOutputFormat>(out_buf, sample, false, false, format_settings));
+    BlockOutputStreamPtr block_output = std::make_shared<OutputStreamToOutputFormat>(std::make_shared<TabSeparatedRowOutputFormat>(out_buf, sample, false, false, []{}, format_settings));
 
     copyData(block_input, *block_output);
 }
diff --git a/dbms/src/Formats/tests/tab_separated_streams.cpp b/dbms/src/Formats/tests/tab_separated_streams.cpp
index bb5e657229d..2c44ccf2b43 100644
--- a/dbms/src/Formats/tests/tab_separated_streams.cpp
+++ b/dbms/src/Formats/tests/tab_separated_streams.cpp
@@ -11,7 +11,6 @@
 
 #include <Formats/TabSeparatedRowInputStream.h>
 #include <Formats/BlockInputStreamFromRowInputStream.h>
-#include <Formats/BlockOutputStreamFromRowOutputStream.h>
 
 #include <DataStreams/copyData.h>
 #include <Processors/Formats/OutputStreamToOutputFormat.h>
@@ -44,7 +43,7 @@ try
     BlockInputStreamFromRowInputStream block_input(row_input, sample, DEFAULT_INSERT_BLOCK_SIZE, 0, []{}, format_settings);
 
     BlockOutputStreamPtr block_output = std::make_shared<OutputStreamToOutputFormat>(
-            std::make_shared<TabSeparatedRowOutputFormat>(out_buf, sample, false, false, format_settings));
+        std::make_shared<TabSeparatedRowOutputFormat>(out_buf, sample, false, false, [] {}, format_settings));
 
     copyData(block_input, *block_output);
     return 0;
diff --git a/dbms/src/IO/MemoryReadWriteBuffer.h b/dbms/src/IO/MemoryReadWriteBuffer.h
index 36750cb21b0..f9c11084f62 100644
--- a/dbms/src/IO/MemoryReadWriteBuffer.h
+++ b/dbms/src/IO/MemoryReadWriteBuffer.h
@@ -11,7 +11,7 @@
 namespace DB
 {
 
-/// Stores data in memory chunks, size of cunks are exponentially increasing during write
+/// Stores data in memory chunks, size of chunks are exponentially increasing during write
 /// Written data could be reread after write
 class MemoryWriteBuffer : public WriteBuffer, public IReadableWriteBuffer, boost::noncopyable, private Allocator<false>
 {
diff --git a/dbms/src/IO/WriteBuffer.h b/dbms/src/IO/WriteBuffer.h
index e6a73ea90e3..18c6c8c6640 100644
--- a/dbms/src/IO/WriteBuffer.h
+++ b/dbms/src/IO/WriteBuffer.h
@@ -35,7 +35,7 @@ public:
       */
     inline void next()
     {
-        if (!offset())
+        if (!offset() && available())
             return;
         bytes += offset();
 
diff --git a/dbms/src/Processors/Formats/IRowOutputFormat.cpp b/dbms/src/Processors/Formats/IRowOutputFormat.cpp
index 6db2802f232..9d40f056cd3 100644
--- a/dbms/src/Processors/Formats/IRowOutputFormat.cpp
+++ b/dbms/src/Processors/Formats/IRowOutputFormat.cpp
@@ -20,6 +20,9 @@ void IRowOutputFormat::consume(DB::Chunk chunk)
         first_row = false;
 
         write(columns, row);
+
+        if (write_single_row_callback)
+            write_single_row_callback();
     }
 }
 
@@ -96,6 +99,3 @@ void IRowOutputFormat::writeTotals(const DB::Columns & columns, size_t row_num)
 }
 
 }
-
-
-
diff --git a/dbms/src/Processors/Formats/IRowOutputFormat.h b/dbms/src/Processors/Formats/IRowOutputFormat.h
index 09bfe17a1b5..a702714a77d 100644
--- a/dbms/src/Processors/Formats/IRowOutputFormat.h
+++ b/dbms/src/Processors/Formats/IRowOutputFormat.h
@@ -1,8 +1,10 @@
 #pragma once
 
-#include <string>
+#include <Formats/FormatFactory.h>
 #include <Processors/Formats/IOutputFormat.h>
 
+#include <string>
+
 
 namespace DB
 {
@@ -22,8 +24,8 @@ protected:
     void finalize() override;
 
 public:
-    IRowOutputFormat(const Block & header, WriteBuffer & out_)
-        : IOutputFormat(header, out_), types(header.getDataTypes())
+    IRowOutputFormat(const Block & header, WriteBuffer & out_, FormatFactory::WriteCallback callback)
+        : IOutputFormat(header, out_), types(header.getDataTypes()), write_single_row_callback(callback)
     {
     }
 
@@ -57,6 +59,9 @@ private:
     bool prefix_written = false;
     bool suffix_written = false;
 
+    // Callback used to indicate that another row is written.
+    FormatFactory::WriteCallback write_single_row_callback;
+
     void writePrefixIfNot()
     {
         if (!prefix_written)
@@ -76,5 +81,3 @@ private:
 };
 
 }
-
-
diff --git a/dbms/src/Processors/Formats/Impl/BinaryRowOutputFormat.cpp b/dbms/src/Processors/Formats/Impl/BinaryRowOutputFormat.cpp
index fb728d1293b..1bbdfbf93fc 100644
--- a/dbms/src/Processors/Formats/Impl/BinaryRowOutputFormat.cpp
+++ b/dbms/src/Processors/Formats/Impl/BinaryRowOutputFormat.cpp
@@ -9,8 +9,8 @@
 namespace DB
 {
 
-BinaryRowOutputFormat::BinaryRowOutputFormat(WriteBuffer & out_, const Block & header, bool with_names_, bool with_types_)
-    : IRowOutputFormat(header, out_), with_names(with_names_), with_types(with_types_)
+BinaryRowOutputFormat::BinaryRowOutputFormat(WriteBuffer & out_, const Block & header, bool with_names_, bool with_types_, FormatFactory::WriteCallback callback)
+    : IRowOutputFormat(header, out_, callback), with_names(with_names_), with_types(with_types_)
 {
 }
 
@@ -53,18 +53,20 @@ void registerOutputFormatProcessorRowBinary(FormatFactory & factory)
         WriteBuffer & buf,
         const Block & sample,
         const Context &,
+        FormatFactory::WriteCallback callback,
         const FormatSettings &)
     {
-        return std::make_shared<BinaryRowOutputFormat>(buf, sample, false, false);
+        return std::make_shared<BinaryRowOutputFormat>(buf, sample, false, false, callback);
     });
 
     factory.registerOutputFormatProcessor("RowBinaryWithNamesAndTypes", [](
         WriteBuffer & buf,
         const Block & sample,
         const Context &,
+        FormatFactory::WriteCallback callback,
         const FormatSettings &)
     {
-        return std::make_shared<BinaryRowOutputFormat>(buf, sample, true, true);
+        return std::make_shared<BinaryRowOutputFormat>(buf, sample, true, true, callback);
     });
 }
 
diff --git a/dbms/src/Processors/Formats/Impl/BinaryRowOutputFormat.h b/dbms/src/Processors/Formats/Impl/BinaryRowOutputFormat.h
index 23e7be0a558..0452a1e3e0f 100644
--- a/dbms/src/Processors/Formats/Impl/BinaryRowOutputFormat.h
+++ b/dbms/src/Processors/Formats/Impl/BinaryRowOutputFormat.h
@@ -17,7 +17,7 @@ class WriteBuffer;
 class BinaryRowOutputFormat: public IRowOutputFormat
 {
 public:
-    BinaryRowOutputFormat(WriteBuffer & out_, const Block & header, bool with_names_, bool with_types_);
+    BinaryRowOutputFormat(WriteBuffer & out_, const Block & header, bool with_names_, bool with_types_, FormatFactory::WriteCallback callback);
 
     String getName() const override { return "BinaryRowOutputFormat"; }
 
@@ -32,4 +32,3 @@ protected:
 };
 
 }
-
diff --git a/dbms/src/Processors/Formats/Impl/CSVRowOutputFormat.cpp b/dbms/src/Processors/Formats/Impl/CSVRowOutputFormat.cpp
index 8f17b8f15c8..081dcf890a0 100644
--- a/dbms/src/Processors/Formats/Impl/CSVRowOutputFormat.cpp
+++ b/dbms/src/Processors/Formats/Impl/CSVRowOutputFormat.cpp
@@ -8,8 +8,8 @@ namespace DB
 {
 
 
-CSVRowOutputFormat::CSVRowOutputFormat(WriteBuffer & out_, const Block & header_, bool with_names_, const FormatSettings & format_settings_)
-    : IRowOutputFormat(header_, out_), with_names(with_names_), format_settings(format_settings_)
+CSVRowOutputFormat::CSVRowOutputFormat(WriteBuffer & out_, const Block & header_, bool with_names_, FormatFactory::WriteCallback callback, const FormatSettings & format_settings_)
+    : IRowOutputFormat(header_, out_, callback), with_names(with_names_), format_settings(format_settings_)
 {
     auto & sample = getPort(PortKind::Main).getHeader();
     size_t columns = sample.columns();
@@ -77,9 +77,10 @@ void registerOutputFormatProcessorCSV(FormatFactory & factory)
             WriteBuffer & buf,
             const Block & sample,
             const Context &,
+            FormatFactory::WriteCallback callback,
             const FormatSettings & format_settings)
         {
-                return std::make_shared<CSVRowOutputFormat>(buf, sample, with_names, format_settings);
+                return std::make_shared<CSVRowOutputFormat>(buf, sample, with_names, callback, format_settings);
         });
     }
 }
diff --git a/dbms/src/Processors/Formats/Impl/CSVRowOutputFormat.h b/dbms/src/Processors/Formats/Impl/CSVRowOutputFormat.h
index 803d3aa80a6..28bd8edf31a 100644
--- a/dbms/src/Processors/Formats/Impl/CSVRowOutputFormat.h
+++ b/dbms/src/Processors/Formats/Impl/CSVRowOutputFormat.h
@@ -20,7 +20,7 @@ public:
     /** with_names - output in the first line a header with column names
       * with_types - output in the next line header with the names of the types
       */
-    CSVRowOutputFormat(WriteBuffer & out_, const Block & header_, bool with_names_, const FormatSettings & format_settings_);
+    CSVRowOutputFormat(WriteBuffer & out_, const Block & header_, bool with_names_, FormatFactory::WriteCallback callback, const FormatSettings & format_settings_);
 
     String getName() const override { return "CSVRowOutputFormat"; }
 
@@ -45,4 +45,3 @@ protected:
 };
 
 }
-
diff --git a/dbms/src/Processors/Formats/Impl/JSONCompactRowOutputFormat.cpp b/dbms/src/Processors/Formats/Impl/JSONCompactRowOutputFormat.cpp
index 72292cc0a26..011054dfce7 100644
--- a/dbms/src/Processors/Formats/Impl/JSONCompactRowOutputFormat.cpp
+++ b/dbms/src/Processors/Formats/Impl/JSONCompactRowOutputFormat.cpp
@@ -8,8 +8,8 @@ namespace DB
 {
 
 JSONCompactRowOutputFormat::JSONCompactRowOutputFormat(
-    WriteBuffer & out_, const Block & header, const FormatSettings & settings_)
-    : JSONRowOutputFormat(out_, header, settings_)
+    WriteBuffer & out_, const Block & header, FormatFactory::WriteCallback callback, const FormatSettings & settings_)
+    : JSONRowOutputFormat(out_, header, callback, settings_)
 {
 }
 
@@ -81,9 +81,10 @@ void registerOutputFormatProcessorJSONCompact(FormatFactory & factory)
         WriteBuffer & buf,
         const Block & sample,
         const Context &,
+        FormatFactory::WriteCallback callback,
         const FormatSettings & format_settings)
     {
-        return std::make_shared<JSONCompactRowOutputFormat>(buf, sample, format_settings);
+        return std::make_shared<JSONCompactRowOutputFormat>(buf, sample, callback, format_settings);
     });
 }
 
diff --git a/dbms/src/Processors/Formats/Impl/JSONCompactRowOutputFormat.h b/dbms/src/Processors/Formats/Impl/JSONCompactRowOutputFormat.h
index e2b5ce76f88..f4002f74287 100644
--- a/dbms/src/Processors/Formats/Impl/JSONCompactRowOutputFormat.h
+++ b/dbms/src/Processors/Formats/Impl/JSONCompactRowOutputFormat.h
@@ -16,7 +16,7 @@ struct FormatSettings;
 class JSONCompactRowOutputFormat : public JSONRowOutputFormat
 {
 public:
-    JSONCompactRowOutputFormat(WriteBuffer & out_, const Block & header, const FormatSettings & settings_);
+    JSONCompactRowOutputFormat(WriteBuffer & out_, const Block & header, FormatFactory::WriteCallback callback, const FormatSettings & settings_);
 
     String getName() const override { return "JSONCompactRowOutputFormat"; }
 
diff --git a/dbms/src/Processors/Formats/Impl/JSONEachRowRowOutputFormat.cpp b/dbms/src/Processors/Formats/Impl/JSONEachRowRowOutputFormat.cpp
index cf23e06c9a6..513420d29b4 100644
--- a/dbms/src/Processors/Formats/Impl/JSONEachRowRowOutputFormat.cpp
+++ b/dbms/src/Processors/Formats/Impl/JSONEachRowRowOutputFormat.cpp
@@ -8,8 +8,8 @@ namespace DB
 {
 
 
-JSONEachRowRowOutputFormat::JSONEachRowRowOutputFormat(WriteBuffer & out_, const Block & header_, const FormatSettings & settings_)
-    : IRowOutputFormat(header_, out_), settings(settings_)
+JSONEachRowRowOutputFormat::JSONEachRowRowOutputFormat(WriteBuffer & out_, const Block & header_, FormatFactory::WriteCallback callback, const FormatSettings & settings_)
+    : IRowOutputFormat(header_, out_, callback), settings(settings_)
 {
     auto & sample = getPort(PortKind::Main).getHeader();
     size_t columns = sample.columns();
@@ -57,9 +57,10 @@ void registerOutputFormatProcessorJSONEachRow(FormatFactory & factory)
         WriteBuffer & buf,
         const Block & sample,
         const Context &,
+        FormatFactory::WriteCallback callback,
         const FormatSettings & format_settings)
     {
-        return std::make_shared<JSONEachRowRowOutputFormat>(buf, sample, format_settings);
+        return std::make_shared<JSONEachRowRowOutputFormat>(buf, sample, callback, format_settings);
     });
 }
 
diff --git a/dbms/src/Processors/Formats/Impl/JSONEachRowRowOutputFormat.h b/dbms/src/Processors/Formats/Impl/JSONEachRowRowOutputFormat.h
index 66b3fa88652..d3931e080f5 100644
--- a/dbms/src/Processors/Formats/Impl/JSONEachRowRowOutputFormat.h
+++ b/dbms/src/Processors/Formats/Impl/JSONEachRowRowOutputFormat.h
@@ -15,7 +15,7 @@ namespace DB
 class JSONEachRowRowOutputFormat : public IRowOutputFormat
 {
 public:
-    JSONEachRowRowOutputFormat(WriteBuffer & out_, const Block & header_, const FormatSettings & settings_);
+    JSONEachRowRowOutputFormat(WriteBuffer & out_, const Block & header_, FormatFactory::WriteCallback callback, const FormatSettings & settings_);
 
     String getName() const override { return "JSONEachRowRowOutputFormat"; }
 
@@ -37,4 +37,3 @@ private:
 };
 
 }
-
diff --git a/dbms/src/Processors/Formats/Impl/JSONRowOutputFormat.cpp b/dbms/src/Processors/Formats/Impl/JSONRowOutputFormat.cpp
index f0d791a6554..90cff3f1498 100644
--- a/dbms/src/Processors/Formats/Impl/JSONRowOutputFormat.cpp
+++ b/dbms/src/Processors/Formats/Impl/JSONRowOutputFormat.cpp
@@ -2,14 +2,13 @@
 #include <IO/WriteBufferValidUTF8.h>
 #include <Processors/Formats/Impl/JSONRowOutputFormat.h>
 #include <Formats/FormatFactory.h>
-#include <Formats/BlockOutputStreamFromRowOutputStream.h>
 
 
 namespace DB
 {
 
-JSONRowOutputFormat::JSONRowOutputFormat(WriteBuffer & out_, const Block & header, const FormatSettings & settings_)
-    : IRowOutputFormat(header, out_), settings(settings_)
+JSONRowOutputFormat::JSONRowOutputFormat(WriteBuffer & out_, const Block & header, FormatFactory::WriteCallback callback, const FormatSettings & settings_)
+    : IRowOutputFormat(header, out_, callback), settings(settings_)
 {
     auto & sample = getPort(PortKind::Main).getHeader();
     NamesAndTypesList columns(sample.getNamesAndTypesList());
@@ -248,9 +247,10 @@ void registerOutputFormatProcessorJSON(FormatFactory & factory)
         WriteBuffer & buf,
         const Block & sample,
         const Context &,
+        FormatFactory::WriteCallback callback,
         const FormatSettings & format_settings)
     {
-        return std::make_shared<JSONRowOutputFormat>(buf, sample, format_settings);
+        return std::make_shared<JSONRowOutputFormat>(buf, sample, callback, format_settings);
     });
 }
 
diff --git a/dbms/src/Processors/Formats/Impl/JSONRowOutputFormat.h b/dbms/src/Processors/Formats/Impl/JSONRowOutputFormat.h
index 5df98475ea3..f9aea3a3e8b 100644
--- a/dbms/src/Processors/Formats/Impl/JSONRowOutputFormat.h
+++ b/dbms/src/Processors/Formats/Impl/JSONRowOutputFormat.h
@@ -16,7 +16,7 @@ namespace DB
 class JSONRowOutputFormat : public IRowOutputFormat
 {
 public:
-    JSONRowOutputFormat(WriteBuffer & out_, const Block & header, const FormatSettings & settings_);
+    JSONRowOutputFormat(WriteBuffer & out_, const Block & header, FormatFactory::WriteCallback callback, const FormatSettings & settings_);
 
     String getName() const override { return "JSONRowOutputFormat"; }
 
@@ -81,4 +81,3 @@ protected:
 };
 
 }
-
diff --git a/dbms/src/Processors/Formats/Impl/MySQLOutputFormat.cpp b/dbms/src/Processors/Formats/Impl/MySQLOutputFormat.cpp
index f046c810fbd..f7ba96a63bd 100644
--- a/dbms/src/Processors/Formats/Impl/MySQLOutputFormat.cpp
+++ b/dbms/src/Processors/Formats/Impl/MySQLOutputFormat.cpp
@@ -107,10 +107,12 @@ void MySQLOutputFormat::flush()
 void registerOutputFormatProcessorMySQLWrite(FormatFactory & factory)
 {
     factory.registerOutputFormatProcessor(
-        "MySQLWire", [](WriteBuffer & buf, const Block & sample, const Context & context, const FormatSettings & settings)
-        {
-            return std::make_shared<MySQLOutputFormat>(buf, sample, context, settings);
-        });
+        "MySQLWire",
+        [](WriteBuffer & buf,
+           const Block & sample,
+           const Context & context,
+           FormatFactory::WriteCallback,
+           const FormatSettings & settings) { return std::make_shared<MySQLOutputFormat>(buf, sample, context, settings); });
 }
 
 }
diff --git a/dbms/src/Processors/Formats/Impl/MySQLOutputFormat.h b/dbms/src/Processors/Formats/Impl/MySQLOutputFormat.h
index d5691936862..39d04818dee 100644
--- a/dbms/src/Processors/Formats/Impl/MySQLOutputFormat.h
+++ b/dbms/src/Processors/Formats/Impl/MySQLOutputFormat.h
@@ -40,4 +40,3 @@ private:
 };
 
 }
-
diff --git a/dbms/src/Processors/Formats/Impl/NativeFormat.cpp b/dbms/src/Processors/Formats/Impl/NativeFormat.cpp
index 0abab1e964d..6ac0e30e0a8 100644
--- a/dbms/src/Processors/Formats/Impl/NativeFormat.cpp
+++ b/dbms/src/Processors/Formats/Impl/NativeFormat.cpp
@@ -161,6 +161,7 @@ void registerOutputFormatProcessorNative(FormatFactory & factory)
         WriteBuffer & buf,
         const Block & sample,
         const Context &,
+        FormatFactory::WriteCallback,
         const FormatSettings &)
     {
         return std::make_shared<NativeOutputFormatFromNativeBlockOutputStream>(sample, buf);
diff --git a/dbms/src/Processors/Formats/Impl/NullFormat.cpp b/dbms/src/Processors/Formats/Impl/NullFormat.cpp
index be754294c45..cf1dc7186ab 100644
--- a/dbms/src/Processors/Formats/Impl/NullFormat.cpp
+++ b/dbms/src/Processors/Formats/Impl/NullFormat.cpp
@@ -22,6 +22,7 @@ void registerOutputFormatProcessorNull(FormatFactory & factory)
         WriteBuffer & buf,
         const Block & sample,
         const Context &,
+        FormatFactory::WriteCallback,
         const FormatSettings &)
     {
         return std::make_shared<NullOutputFormat>(sample, buf);
diff --git a/dbms/src/Processors/Formats/Impl/ODBCDriver2BlockOutputFormat.cpp b/dbms/src/Processors/Formats/Impl/ODBCDriver2BlockOutputFormat.cpp
index 7f30c5bfdc4..9ada3d16516 100644
--- a/dbms/src/Processors/Formats/Impl/ODBCDriver2BlockOutputFormat.cpp
+++ b/dbms/src/Processors/Formats/Impl/ODBCDriver2BlockOutputFormat.cpp
@@ -107,7 +107,7 @@ void ODBCDriver2BlockOutputFormat::writePrefix()
 void registerOutputFormatProcessorODBCDriver2(FormatFactory & factory)
 {
     factory.registerOutputFormatProcessor(
-        "ODBCDriver2", [](WriteBuffer & buf, const Block & sample, const Context &, const FormatSettings & format_settings)
+        "ODBCDriver2", [](WriteBuffer & buf, const Block & sample, const Context &, FormatFactory::WriteCallback, const FormatSettings & format_settings)
         {
             return std::make_shared<ODBCDriver2BlockOutputFormat>(buf, sample, format_settings);
         });
diff --git a/dbms/src/Processors/Formats/Impl/ODBCDriverBlockOutputFormat.cpp b/dbms/src/Processors/Formats/Impl/ODBCDriverBlockOutputFormat.cpp
index 3f84bacbfaf..467bfb614e3 100644
--- a/dbms/src/Processors/Formats/Impl/ODBCDriverBlockOutputFormat.cpp
+++ b/dbms/src/Processors/Formats/Impl/ODBCDriverBlockOutputFormat.cpp
@@ -70,6 +70,7 @@ void registerOutputFormatProcessorODBCDriver(FormatFactory & factory)
         WriteBuffer & buf,
         const Block & sample,
         const Context &,
+        FormatFactory::WriteCallback,
         const FormatSettings & format_settings)
     {
         return std::make_shared<ODBCDriverBlockOutputFormat>(buf, sample, format_settings);
diff --git a/dbms/src/Processors/Formats/Impl/ParquetBlockOutputFormat.cpp b/dbms/src/Processors/Formats/Impl/ParquetBlockOutputFormat.cpp
index 224b0e6d2d8..1956403654e 100644
--- a/dbms/src/Processors/Formats/Impl/ParquetBlockOutputFormat.cpp
+++ b/dbms/src/Processors/Formats/Impl/ParquetBlockOutputFormat.cpp
@@ -423,7 +423,12 @@ void ParquetBlockOutputFormat::finalize()
 void registerOutputFormatProcessorParquet(FormatFactory & factory)
 {
     factory.registerOutputFormatProcessor(
-        "Parquet", [](WriteBuffer & buf, const Block & sample, const Context & /*context*/, const FormatSettings & format_settings)
+        "Parquet",
+        [](WriteBuffer & buf,
+           const Block & sample,
+           const Context & /*context*/,
+           FormatFactory::WriteCallback,
+           const FormatSettings & format_settings)
         {
             auto impl = std::make_shared<ParquetBlockOutputFormat>(buf, sample, format_settings);
             /// TODO
diff --git a/dbms/src/Processors/Formats/Impl/PrettyBlockOutputFormat.cpp b/dbms/src/Processors/Formats/Impl/PrettyBlockOutputFormat.cpp
index 84c4fc7cbc3..f6a8222d854 100644
--- a/dbms/src/Processors/Formats/Impl/PrettyBlockOutputFormat.cpp
+++ b/dbms/src/Processors/Formats/Impl/PrettyBlockOutputFormat.cpp
@@ -261,6 +261,7 @@ void registerOutputFormatProcessorPretty(FormatFactory & factory)
         WriteBuffer & buf,
         const Block & sample,
         const Context &,
+        FormatFactory::WriteCallback,
         const FormatSettings & format_settings)
     {
         return std::make_shared<PrettyBlockOutputFormat>(buf, sample, format_settings);
@@ -270,6 +271,7 @@ void registerOutputFormatProcessorPretty(FormatFactory & factory)
         WriteBuffer & buf,
         const Block & sample,
         const Context &,
+        FormatFactory::WriteCallback,
         const FormatSettings & format_settings)
     {
         FormatSettings changed_settings = format_settings;
diff --git a/dbms/src/Processors/Formats/Impl/PrettyCompactBlockOutputFormat.cpp b/dbms/src/Processors/Formats/Impl/PrettyCompactBlockOutputFormat.cpp
index 53fef75a97c..15652dec08d 100644
--- a/dbms/src/Processors/Formats/Impl/PrettyCompactBlockOutputFormat.cpp
+++ b/dbms/src/Processors/Formats/Impl/PrettyCompactBlockOutputFormat.cpp
@@ -134,6 +134,7 @@ void registerOutputFormatProcessorPrettyCompact(FormatFactory & factory)
         WriteBuffer & buf,
         const Block & sample,
         const Context &,
+        FormatFactory::WriteCallback,
         const FormatSettings & format_settings)
     {
         return std::make_shared<PrettyCompactBlockOutputFormat>(buf, sample, format_settings);
@@ -143,6 +144,7 @@ void registerOutputFormatProcessorPrettyCompact(FormatFactory & factory)
         WriteBuffer & buf,
         const Block & sample,
         const Context &,
+        FormatFactory::WriteCallback,
         const FormatSettings & format_settings)
     {
         FormatSettings changed_settings = format_settings;
diff --git a/dbms/src/Processors/Formats/Impl/PrettySpaceBlockOutputFormat.cpp b/dbms/src/Processors/Formats/Impl/PrettySpaceBlockOutputFormat.cpp
index 2b75d867327..a420f438b19 100644
--- a/dbms/src/Processors/Formats/Impl/PrettySpaceBlockOutputFormat.cpp
+++ b/dbms/src/Processors/Formats/Impl/PrettySpaceBlockOutputFormat.cpp
@@ -103,6 +103,7 @@ void registerOutputFormatProcessorPrettySpace(FormatFactory & factory)
         WriteBuffer & buf,
         const Block & sample,
         const Context &,
+        FormatFactory::WriteCallback,
         const FormatSettings & format_settings)
     {
         return std::make_shared<PrettySpaceBlockOutputFormat>(buf, sample, format_settings);
@@ -112,6 +113,7 @@ void registerOutputFormatProcessorPrettySpace(FormatFactory & factory)
         WriteBuffer & buf,
         const Block & sample,
         const Context &,
+        FormatFactory::WriteCallback,
         const FormatSettings & format_settings)
     {
         FormatSettings changed_settings = format_settings;
diff --git a/dbms/src/Processors/Formats/Impl/ProtobufRowOutputFormat.cpp b/dbms/src/Processors/Formats/Impl/ProtobufRowOutputFormat.cpp
index 30e27c68f1e..96b19337b3d 100644
--- a/dbms/src/Processors/Formats/Impl/ProtobufRowOutputFormat.cpp
+++ b/dbms/src/Processors/Formats/Impl/ProtobufRowOutputFormat.cpp
@@ -23,8 +23,9 @@ namespace ErrorCodes
 ProtobufRowOutputFormat::ProtobufRowOutputFormat(
     WriteBuffer & out_,
     const Block & header,
+    FormatFactory::WriteCallback callback,
     const FormatSchemaInfo & format_schema)
-    : IRowOutputFormat(header, out_)
+    : IRowOutputFormat(header, out_, callback)
     , data_types(header.getDataTypes())
     , writer(out, ProtobufSchemas::instance().getMessageTypeForFormatSchema(format_schema), header.getNames())
 {
@@ -46,9 +47,14 @@ void ProtobufRowOutputFormat::write(const Columns & columns, size_t row_num)
 void registerOutputFormatProcessorProtobuf(FormatFactory & factory)
 {
     factory.registerOutputFormatProcessor(
-        "Protobuf", [](WriteBuffer & buf, const Block & header, const Context & context, const FormatSettings &)
+        "Protobuf",
+        [](WriteBuffer & buf,
+           const Block & header,
+           const Context & context,
+           FormatFactory::WriteCallback callback,
+           const FormatSettings &)
         {
-            return std::make_shared<ProtobufRowOutputFormat>(buf, header, FormatSchemaInfo(context, "Protobuf"));
+            return std::make_shared<ProtobufRowOutputFormat>(buf, header, callback, FormatSchemaInfo(context, "Protobuf"));
         });
 }
 
diff --git a/dbms/src/Processors/Formats/Impl/ProtobufRowOutputFormat.h b/dbms/src/Processors/Formats/Impl/ProtobufRowOutputFormat.h
index 96bd85e317d..ae8ebbf28f4 100644
--- a/dbms/src/Processors/Formats/Impl/ProtobufRowOutputFormat.h
+++ b/dbms/src/Processors/Formats/Impl/ProtobufRowOutputFormat.h
@@ -35,6 +35,7 @@ public:
     ProtobufRowOutputFormat(
         WriteBuffer & out_,
         const Block & header,
+        FormatFactory::WriteCallback callback,
         const FormatSchemaInfo & format_schema);
 
     String getName() const override { return "ProtobufRowOutputFormat"; }
diff --git a/dbms/src/Processors/Formats/Impl/TSKVRowOutputFormat.cpp b/dbms/src/Processors/Formats/Impl/TSKVRowOutputFormat.cpp
index f1c13af9c5d..f1fbc72b9ee 100644
--- a/dbms/src/Processors/Formats/Impl/TSKVRowOutputFormat.cpp
+++ b/dbms/src/Processors/Formats/Impl/TSKVRowOutputFormat.cpp
@@ -8,8 +8,8 @@
 namespace DB
 {
 
-TSKVRowOutputFormat::TSKVRowOutputFormat(WriteBuffer & out_, const Block & header, const FormatSettings & format_settings_)
-    : TabSeparatedRowOutputFormat(out_, header, false, false, format_settings_)
+TSKVRowOutputFormat::TSKVRowOutputFormat(WriteBuffer & out_, const Block & header, FormatFactory::WriteCallback callback, const FormatSettings & format_settings_)
+    : TabSeparatedRowOutputFormat(out_, header, false, false, callback, format_settings_)
 {
     auto & sample = getPort(PortKind::Main).getHeader();
     NamesAndTypesList columns(sample.getNamesAndTypesList());
@@ -46,9 +46,10 @@ void registerOutputFormatProcessorTSKV(FormatFactory & factory)
         WriteBuffer & buf,
         const Block & sample,
         const Context &,
+        FormatFactory::WriteCallback callback,
         const FormatSettings & settings)
     {
-        return std::make_shared<TSKVRowOutputFormat>(buf, sample, settings);
+        return std::make_shared<TSKVRowOutputFormat>(buf, sample, callback, settings);
     });
 }
 
diff --git a/dbms/src/Processors/Formats/Impl/TSKVRowOutputFormat.h b/dbms/src/Processors/Formats/Impl/TSKVRowOutputFormat.h
index 607fa5fdc9b..7166176e2f4 100644
--- a/dbms/src/Processors/Formats/Impl/TSKVRowOutputFormat.h
+++ b/dbms/src/Processors/Formats/Impl/TSKVRowOutputFormat.h
@@ -14,7 +14,7 @@ namespace DB
 class TSKVRowOutputFormat: public TabSeparatedRowOutputFormat
 {
 public:
-    TSKVRowOutputFormat(WriteBuffer & out_, const Block & header, const FormatSettings & format_settings);
+    TSKVRowOutputFormat(WriteBuffer & out_, const Block & header, FormatFactory::WriteCallback callback, const FormatSettings & format_settings);
 
     String getName() const override { return "TSKVRowOutputFormat"; }
 
@@ -27,4 +27,3 @@ protected:
 };
 
 }
-
diff --git a/dbms/src/Processors/Formats/Impl/TabSeparatedRawRowOutputFormat.h b/dbms/src/Processors/Formats/Impl/TabSeparatedRawRowOutputFormat.h
index c2cf31fc196..42ebd846dfc 100644
--- a/dbms/src/Processors/Formats/Impl/TabSeparatedRawRowOutputFormat.h
+++ b/dbms/src/Processors/Formats/Impl/TabSeparatedRawRowOutputFormat.h
@@ -13,8 +13,16 @@ namespace DB
 class TabSeparatedRawRowOutputFormat : public TabSeparatedRowOutputFormat
 {
 public:
-    TabSeparatedRawRowOutputFormat(WriteBuffer & out_, const Block & header_, bool with_names_, bool with_types_, const FormatSettings & format_settings_)
-        : TabSeparatedRowOutputFormat(out_, header_, with_names_, with_types_, format_settings_) {}
+    TabSeparatedRawRowOutputFormat(
+        WriteBuffer & out_,
+        const Block & header_,
+        bool with_names_,
+        bool with_types_,
+        FormatFactory::WriteCallback callback,
+        const FormatSettings & format_settings_)
+        : TabSeparatedRowOutputFormat(out_, header_, with_names_, with_types_, callback, format_settings_)
+    {
+    }
 
     String getName() const override { return "TabSeparatedRawRowOutputFormat"; }
 
@@ -25,4 +33,3 @@ public:
 };
 
 }
-
diff --git a/dbms/src/Processors/Formats/Impl/TabSeparatedRowOutputFormat.cpp b/dbms/src/Processors/Formats/Impl/TabSeparatedRowOutputFormat.cpp
index 92058323102..ae3a1fb9af0 100644
--- a/dbms/src/Processors/Formats/Impl/TabSeparatedRowOutputFormat.cpp
+++ b/dbms/src/Processors/Formats/Impl/TabSeparatedRowOutputFormat.cpp
@@ -6,10 +6,14 @@
 
 namespace DB
 {
-
 TabSeparatedRowOutputFormat::TabSeparatedRowOutputFormat(
-    WriteBuffer & out_, const Block & header_, bool with_names_, bool with_types_, const FormatSettings & format_settings_)
-    : IRowOutputFormat(header_, out_), with_names(with_names_), with_types(with_types_), format_settings(format_settings_)
+    WriteBuffer & out_,
+    const Block & header_,
+    bool with_names_,
+    bool with_types_,
+    FormatFactory::WriteCallback callback,
+    const FormatSettings & format_settings_)
+    : IRowOutputFormat(header_, out_, callback), with_names(with_names_), with_types(with_types_), format_settings(format_settings_)
 {
 }
 
@@ -75,9 +79,10 @@ void registerOutputFormatProcessorTabSeparated(FormatFactory & factory)
             WriteBuffer & buf,
             const Block & sample,
             const Context &,
+            FormatFactory::WriteCallback callback,
             const FormatSettings & settings)
         {
-            return std::make_shared<TabSeparatedRowOutputFormat>(buf, sample, false, false, settings);
+            return std::make_shared<TabSeparatedRowOutputFormat>(buf, sample, false, false, callback, settings);
         });
     }
 
@@ -87,9 +92,10 @@ void registerOutputFormatProcessorTabSeparated(FormatFactory & factory)
             WriteBuffer & buf,
             const Block & sample,
             const Context &,
+            FormatFactory::WriteCallback callback,
             const FormatSettings & settings)
         {
-            return std::make_shared<TabSeparatedRawRowOutputFormat>(buf, sample, false, false, settings);
+            return std::make_shared<TabSeparatedRawRowOutputFormat>(buf, sample, false, false, callback, settings);
         });
     }
 
@@ -99,9 +105,10 @@ void registerOutputFormatProcessorTabSeparated(FormatFactory & factory)
             WriteBuffer & buf,
             const Block & sample,
             const Context &,
+            FormatFactory::WriteCallback callback,
             const FormatSettings & settings)
         {
-            return std::make_shared<TabSeparatedRowOutputFormat>(buf, sample, true, false, settings);
+            return std::make_shared<TabSeparatedRowOutputFormat>(buf, sample, true, false, callback, settings);
         });
     }
 
@@ -111,9 +118,10 @@ void registerOutputFormatProcessorTabSeparated(FormatFactory & factory)
             WriteBuffer & buf,
             const Block & sample,
             const Context &,
+            FormatFactory::WriteCallback callback,
             const FormatSettings & settings)
         {
-            return std::make_shared<TabSeparatedRowOutputFormat>(buf, sample, true, true, settings);
+            return std::make_shared<TabSeparatedRowOutputFormat>(buf, sample, true, true, callback, settings);
         });
     }
 }
diff --git a/dbms/src/Processors/Formats/Impl/TabSeparatedRowOutputFormat.h b/dbms/src/Processors/Formats/Impl/TabSeparatedRowOutputFormat.h
index a00cd2d8fdd..3d3f82e7833 100644
--- a/dbms/src/Processors/Formats/Impl/TabSeparatedRowOutputFormat.h
+++ b/dbms/src/Processors/Formats/Impl/TabSeparatedRowOutputFormat.h
@@ -18,7 +18,13 @@ public:
     /** with_names - output in the first line a header with column names
       * with_types - output the next line header with the names of the types
       */
-    TabSeparatedRowOutputFormat(WriteBuffer & out_, const Block & header_, bool with_names_, bool with_types_, const FormatSettings & format_settings_);
+    TabSeparatedRowOutputFormat(
+        WriteBuffer & out_,
+        const Block & header_,
+        bool with_names_,
+        bool with_types_,
+        FormatFactory::WriteCallback callback,
+        const FormatSettings & format_settings_);
 
     String getName() const override { return "TabSeparatedRowOutputFormat"; }
 
@@ -40,4 +46,3 @@ protected:
 };
 
 }
-
diff --git a/dbms/src/Processors/Formats/Impl/ValuesRowOutputFormat.cpp b/dbms/src/Processors/Formats/Impl/ValuesRowOutputFormat.cpp
index 80c4135dfb3..e773cbf167c 100644
--- a/dbms/src/Processors/Formats/Impl/ValuesRowOutputFormat.cpp
+++ b/dbms/src/Processors/Formats/Impl/ValuesRowOutputFormat.cpp
@@ -10,8 +10,8 @@ namespace DB
 {
 
 
-ValuesRowOutputFormat::ValuesRowOutputFormat(WriteBuffer & out_, const Block & header_, const FormatSettings & format_settings_)
-    : IRowOutputFormat(header_, out_), format_settings(format_settings_)
+ValuesRowOutputFormat::ValuesRowOutputFormat(WriteBuffer & out_, const Block & header_, FormatFactory::WriteCallback callback, const FormatSettings & format_settings_)
+    : IRowOutputFormat(header_, out_, callback), format_settings(format_settings_)
 {
 }
 
@@ -47,9 +47,10 @@ void registerOutputFormatProcessorValues(FormatFactory & factory)
         WriteBuffer & buf,
         const Block & sample,
         const Context &,
+        FormatFactory::WriteCallback callback,
         const FormatSettings & settings)
     {
-        return std::make_shared<ValuesRowOutputFormat>(buf, sample, settings);
+        return std::make_shared<ValuesRowOutputFormat>(buf, sample, callback, settings);
     });
 }
 
diff --git a/dbms/src/Processors/Formats/Impl/ValuesRowOutputFormat.h b/dbms/src/Processors/Formats/Impl/ValuesRowOutputFormat.h
index f7a28002c92..b507a157e57 100644
--- a/dbms/src/Processors/Formats/Impl/ValuesRowOutputFormat.h
+++ b/dbms/src/Processors/Formats/Impl/ValuesRowOutputFormat.h
@@ -15,7 +15,7 @@ class WriteBuffer;
 class ValuesRowOutputFormat : public IRowOutputFormat
 {
 public:
-    ValuesRowOutputFormat(WriteBuffer & out_, const Block & header_, const FormatSettings & format_settings_);
+    ValuesRowOutputFormat(WriteBuffer & out_, const Block & header_, FormatFactory::WriteCallback callback, const FormatSettings & format_settings_);
 
     String getName() const override { return "ValuesRowOutputFormat"; }
 
@@ -30,4 +30,3 @@ private:
 };
 
 }
-
diff --git a/dbms/src/Processors/Formats/Impl/VerticalRowOutputFormat.cpp b/dbms/src/Processors/Formats/Impl/VerticalRowOutputFormat.cpp
index 744ad2d0953..6e794c9a79b 100644
--- a/dbms/src/Processors/Formats/Impl/VerticalRowOutputFormat.cpp
+++ b/dbms/src/Processors/Formats/Impl/VerticalRowOutputFormat.cpp
@@ -11,8 +11,8 @@ namespace DB
 {
 
 VerticalRowOutputFormat::VerticalRowOutputFormat(
-    WriteBuffer & out_, const Block & header_, const FormatSettings & format_settings_)
-    : IRowOutputFormat(header_, out_), format_settings(format_settings_)
+    WriteBuffer & out_, const Block & header_, FormatFactory::WriteCallback callback, const FormatSettings & format_settings_)
+    : IRowOutputFormat(header_, out_, callback), format_settings(format_settings_)
 {
     auto & sample = getPort(PortKind::Main).getHeader();
     size_t columns = sample.columns();
@@ -169,9 +169,10 @@ void registerOutputFormatProcessorVertical(FormatFactory & factory)
         WriteBuffer & buf,
         const Block & sample,
         const Context &,
+        FormatFactory::WriteCallback callback,
         const FormatSettings & settings)
     {
-        return std::make_shared<VerticalRowOutputFormat>(buf, sample, settings);
+        return std::make_shared<VerticalRowOutputFormat>(buf, sample, callback, settings);
     });
 }
 
diff --git a/dbms/src/Processors/Formats/Impl/VerticalRowOutputFormat.h b/dbms/src/Processors/Formats/Impl/VerticalRowOutputFormat.h
index 2a0d248bab8..aa40a6a5ad6 100644
--- a/dbms/src/Processors/Formats/Impl/VerticalRowOutputFormat.h
+++ b/dbms/src/Processors/Formats/Impl/VerticalRowOutputFormat.h
@@ -18,7 +18,7 @@ class Context;
 class VerticalRowOutputFormat : public IRowOutputFormat
 {
 public:
-    VerticalRowOutputFormat(WriteBuffer & out_, const Block & header_, const FormatSettings & format_settings_);
+    VerticalRowOutputFormat(WriteBuffer & out_, const Block & header_, FormatFactory::WriteCallback callback, const FormatSettings & format_settings_);
 
     String getName() const override { return "VerticalRowOutputFormat"; }
 
@@ -50,4 +50,3 @@ protected:
 };
 
 }
-
diff --git a/dbms/src/Processors/Formats/Impl/XMLRowOutputFormat.cpp b/dbms/src/Processors/Formats/Impl/XMLRowOutputFormat.cpp
index 545f80692cc..07335fc6c49 100644
--- a/dbms/src/Processors/Formats/Impl/XMLRowOutputFormat.cpp
+++ b/dbms/src/Processors/Formats/Impl/XMLRowOutputFormat.cpp
@@ -7,8 +7,8 @@
 namespace DB
 {
 
-XMLRowOutputFormat::XMLRowOutputFormat(WriteBuffer & out_, const Block & header_, const FormatSettings & format_settings_)
-    : IRowOutputFormat(header_, out_), format_settings(format_settings_)
+XMLRowOutputFormat::XMLRowOutputFormat(WriteBuffer & out_, const Block & header_, FormatFactory::WriteCallback callback, const FormatSettings & format_settings_)
+    : IRowOutputFormat(header_, out_, callback), format_settings(format_settings_)
 {
     auto & sample = getPort(PortKind::Main).getHeader();
     NamesAndTypesList columns(sample.getNamesAndTypesList());
@@ -246,9 +246,10 @@ void registerOutputFormatProcessorXML(FormatFactory & factory)
         WriteBuffer & buf,
         const Block & sample,
         const Context &,
+        FormatFactory::WriteCallback callback,
         const FormatSettings & settings)
     {
-        return std::make_shared<XMLRowOutputFormat>(buf, sample, settings);
+        return std::make_shared<XMLRowOutputFormat>(buf, sample, callback, settings);
     });
 }
 
diff --git a/dbms/src/Processors/Formats/Impl/XMLRowOutputFormat.h b/dbms/src/Processors/Formats/Impl/XMLRowOutputFormat.h
index b2370090c32..8c3da59cfd1 100644
--- a/dbms/src/Processors/Formats/Impl/XMLRowOutputFormat.h
+++ b/dbms/src/Processors/Formats/Impl/XMLRowOutputFormat.h
@@ -16,7 +16,7 @@ namespace DB
 class XMLRowOutputFormat : public IRowOutputFormat
 {
 public:
-    XMLRowOutputFormat(WriteBuffer & out_, const Block & header_, const FormatSettings & format_settings_);
+    XMLRowOutputFormat(WriteBuffer & out_, const Block & header_, FormatFactory::WriteCallback callback, const FormatSettings & format_settings_);
 
     String getName() const override { return "XMLRowOutputFormat"; }
 
@@ -75,4 +75,3 @@ protected:
 };
 
 }
-
diff --git a/dbms/src/Storages/Kafka/KafkaBlockInputStream.cpp b/dbms/src/Storages/Kafka/KafkaBlockInputStream.cpp
index d13df2ae7bc..1962e4fbc63 100644
--- a/dbms/src/Storages/Kafka/KafkaBlockInputStream.cpp
+++ b/dbms/src/Storages/Kafka/KafkaBlockInputStream.cpp
@@ -33,7 +33,7 @@ KafkaBlockInputStream::~KafkaBlockInputStream()
         buffer->reset();
     }
 
-    storage.pushBuffer(buffer);
+    storage.pushReadBuffer(buffer);
 }
 
 Block KafkaBlockInputStream::getHeader() const
@@ -43,11 +43,12 @@ Block KafkaBlockInputStream::getHeader() const
 
 void KafkaBlockInputStream::readPrefixImpl()
 {
-    buffer = storage.tryClaimBuffer(context.getSettingsRef().queue_max_wait_ms.totalMilliseconds());
+    auto timeout = std::chrono::milliseconds(context.getSettingsRef().queue_max_wait_ms.totalMilliseconds());
+    buffer = storage.popReadBuffer(timeout);
     claimed = !!buffer;
 
     if (!buffer)
-        buffer = storage.createBuffer();
+        return;
 
     buffer->subBufferAs<ReadBufferFromKafkaConsumer>()->subscribe(storage.getTopics());
 
@@ -80,6 +81,9 @@ void KafkaBlockInputStream::readPrefixImpl()
 
 Block KafkaBlockInputStream::readImpl()
 {
+    if (!buffer)
+        return Block();
+
     Block block = children.back()->read();
     if (!block)
         return block;
@@ -99,6 +103,9 @@ Block KafkaBlockInputStream::readImpl()
 
 void KafkaBlockInputStream::readSuffixImpl()
 {
+    if (!buffer)
+        return;
+
     buffer->subBufferAs<ReadBufferFromKafkaConsumer>()->commit();
 
     broken = false;
diff --git a/dbms/src/Storages/Kafka/KafkaBlockInputStream.h b/dbms/src/Storages/Kafka/KafkaBlockInputStream.h
index a7e82034eb9..fef7f8d0469 100644
--- a/dbms/src/Storages/Kafka/KafkaBlockInputStream.h
+++ b/dbms/src/Storages/Kafka/KafkaBlockInputStream.h
@@ -27,7 +27,7 @@ private:
     Names column_names;
     UInt64 max_block_size;
 
-    BufferPtr buffer;
+    ConsumerBufferPtr buffer;
     MutableColumns virtual_columns;
     bool broken = true, claimed = false;
 };
diff --git a/dbms/src/Storages/Kafka/KafkaBlockOutputStream.cpp b/dbms/src/Storages/Kafka/KafkaBlockOutputStream.cpp
new file mode 100644
index 00000000000..574b3bd9fd1
--- /dev/null
+++ b/dbms/src/Storages/Kafka/KafkaBlockOutputStream.cpp
@@ -0,0 +1,54 @@
+#include "KafkaBlockOutputStream.h"
+
+#include <Formats/FormatFactory.h>
+
+namespace DB
+{
+
+namespace ErrorCodes
+{
+
+extern int CANNOT_CREATE_IO_BUFFER;
+
+}
+
+KafkaBlockOutputStream::KafkaBlockOutputStream(StorageKafka & storage_, const Context & context_) : storage(storage_), context(context_)
+{
+}
+
+KafkaBlockOutputStream::~KafkaBlockOutputStream()
+{
+}
+
+Block KafkaBlockOutputStream::getHeader() const
+{
+    return storage.getSampleBlockNonMaterialized();
+}
+
+void KafkaBlockOutputStream::writePrefix()
+{
+    buffer = storage.createWriteBuffer();
+    if (!buffer)
+        throw Exception("Failed to create Kafka producer!", ErrorCodes::CANNOT_CREATE_IO_BUFFER);
+
+    child = FormatFactory::instance().getOutput(storage.getFormatName(), *buffer, getHeader(), context, [this]{ buffer->count_row(); });
+}
+
+void KafkaBlockOutputStream::write(const Block & block)
+{
+    child->write(block);
+}
+
+void KafkaBlockOutputStream::writeSuffix()
+{
+    child->writeSuffix();
+    flush();
+}
+
+void KafkaBlockOutputStream::flush()
+{
+    if (buffer)
+        buffer->flush();
+}
+
+}
diff --git a/dbms/src/Storages/Kafka/KafkaBlockOutputStream.h b/dbms/src/Storages/Kafka/KafkaBlockOutputStream.h
new file mode 100644
index 00000000000..daa1c7bd98b
--- /dev/null
+++ b/dbms/src/Storages/Kafka/KafkaBlockOutputStream.h
@@ -0,0 +1,31 @@
+#pragma once
+
+#include <DataStreams/IBlockOutputStream.h>
+#include <Interpreters/Context.h>
+#include <Storages/Kafka/StorageKafka.h>
+
+namespace DB
+{
+
+class KafkaBlockOutputStream : public IBlockOutputStream
+{
+public:
+    explicit KafkaBlockOutputStream(StorageKafka & storage_, const Context & context_);
+    ~KafkaBlockOutputStream() override;
+
+    Block getHeader() const override;
+
+    void writePrefix() override;
+    void write(const Block & block) override;
+    void writeSuffix() override;
+
+    void flush() override;
+
+private:
+    StorageKafka & storage;
+    Context context;
+    ProducerBufferPtr buffer;
+    BlockOutputStreamPtr child;
+};
+
+}
diff --git a/dbms/src/Storages/Kafka/ReadBufferFromKafkaConsumer.h b/dbms/src/Storages/Kafka/ReadBufferFromKafkaConsumer.h
index a8295152d91..8f78eae23e1 100644
--- a/dbms/src/Storages/Kafka/ReadBufferFromKafkaConsumer.h
+++ b/dbms/src/Storages/Kafka/ReadBufferFromKafkaConsumer.h
@@ -10,7 +10,7 @@
 namespace DB
 {
 
-using BufferPtr = std::shared_ptr<DelimitedReadBuffer>;
+using ConsumerBufferPtr = std::shared_ptr<DelimitedReadBuffer>;
 using ConsumerPtr = std::shared_ptr<cppkafka::Consumer>;
 
 class ReadBufferFromKafkaConsumer : public ReadBuffer
diff --git a/dbms/src/Storages/Kafka/StorageKafka.cpp b/dbms/src/Storages/Kafka/StorageKafka.cpp
index 7cfcb4caf10..e429ef505de 100644
--- a/dbms/src/Storages/Kafka/StorageKafka.cpp
+++ b/dbms/src/Storages/Kafka/StorageKafka.cpp
@@ -16,6 +16,7 @@
 #include <Parsers/ASTLiteral.h>
 #include <Storages/Kafka/KafkaSettings.h>
 #include <Storages/Kafka/KafkaBlockInputStream.h>
+#include <Storages/Kafka/KafkaBlockOutputStream.h>
 #include <Storages/StorageFactory.h>
 #include <Storages/StorageMaterializedView.h>
 #include <boost/algorithm/string/replace.hpp>
@@ -106,7 +107,7 @@ StorageKafka::StorageKafka(
     , skip_broken(skip_broken_)
     , intermediate_commit(intermediate_commit_)
 {
-    task = global_context.getSchedulePool().createTask(log->name(), [this]{ streamThread(); });
+    task = global_context.getSchedulePool().createTask(log->name(), [this]{ threadFunc(); });
     task->deactivate();
 }
 
@@ -140,14 +141,21 @@ BlockInputStreams StorageKafka::read(
 }
 
 
+BlockOutputStreamPtr StorageKafka::write(const ASTPtr &, const Context & context)
+{
+    if (topics.size() > 1)
+        throw Exception("Can't write to Kafka table with multiple topics!", ErrorCodes::NOT_IMPLEMENTED);
+    return std::make_shared<KafkaBlockOutputStream>(*this, context);
+}
+
+
 void StorageKafka::startup()
 {
     for (size_t i = 0; i < num_consumers; ++i)
     {
-        // Make buffer available
         try
         {
-            pushBuffer(createBuffer());
+            pushReadBuffer(createReadBuffer());
             ++num_created_consumers;
         }
         catch (const cppkafka::Exception &)
@@ -169,7 +177,7 @@ void StorageKafka::shutdown()
     // Close all consumers
     for (size_t i = 0; i < num_created_consumers; ++i)
     {
-        auto buffer = claimBuffer();
+        auto buffer = popReadBuffer();
         // FIXME: not sure if we really close consumers here, and if we really need to close them here.
     }
 
@@ -193,10 +201,70 @@ void StorageKafka::updateDependencies()
 }
 
 
-BufferPtr StorageKafka::createBuffer()
+void StorageKafka::pushReadBuffer(ConsumerBufferPtr buffer)
 {
+    std::lock_guard lock(mutex);
+    buffers.push_back(buffer);
+    semaphore.set();
+}
+
+
+ConsumerBufferPtr StorageKafka::popReadBuffer()
+{
+    return popReadBuffer(std::chrono::milliseconds::zero());
+}
+
+
+ConsumerBufferPtr StorageKafka::popReadBuffer(std::chrono::milliseconds timeout)
+{
+    // Wait for the first free buffer
+    if (timeout == std::chrono::milliseconds::zero())
+        semaphore.wait();
+    else
+    {
+        if (!semaphore.tryWait(timeout.count()))
+            return nullptr;
+    }
+
+    // Take the first available buffer from the list
+    std::lock_guard lock(mutex);
+    auto buffer = buffers.back();
+    buffers.pop_back();
+    return buffer;
+}
+
+
+ProducerBufferPtr StorageKafka::createWriteBuffer()
+{
+    cppkafka::Configuration conf;
+    conf.set("metadata.broker.list", brokers);
+    conf.set("group.id", group);
+    conf.set("client.id", VERSION_FULL);
+    // TODO: fill required settings
+    updateConfiguration(conf);
+
+    auto producer = std::make_shared<cppkafka::Producer>(conf);
+    const Settings & settings = global_context.getSettingsRef();
+    size_t poll_timeout = settings.stream_poll_timeout_ms.totalMilliseconds();
+
+    return std::make_shared<WriteBufferToKafkaProducer>(
+        producer, topics[0], row_delimiter ? std::optional<char>{row_delimiter} : std::optional<char>(), 1, 1024, std::chrono::milliseconds(poll_timeout));
+}
+
+
+ConsumerBufferPtr StorageKafka::createReadBuffer()
+{
+    cppkafka::Configuration conf;
+    conf.set("metadata.broker.list", brokers);
+    conf.set("group.id", group);
+    conf.set("client.id", VERSION_FULL);
+    conf.set("auto.offset.reset", "smallest"); // If no offset stored for this group, read all messages from the start
+    conf.set("enable.auto.commit", "false"); // We manually commit offsets after a stream successfully finished
+    conf.set("enable.partition.eof", "false"); // Ignore EOF messages
+    updateConfiguration(conf);
+
     // Create a consumer and subscribe to topics
-    auto consumer = std::make_shared<cppkafka::Consumer>(createConsumerConfiguration());
+    auto consumer = std::make_shared<cppkafka::Consumer>(conf);
 
     // Limit the number of batched messages to allow early cancellations
     const Settings & settings = global_context.getSettingsRef();
@@ -209,61 +277,9 @@ BufferPtr StorageKafka::createBuffer()
         std::make_unique<ReadBufferFromKafkaConsumer>(consumer, log, batch_size, poll_timeout, intermediate_commit), row_delimiter);
 }
 
-BufferPtr StorageKafka::claimBuffer()
+
+void StorageKafka::updateConfiguration(cppkafka::Configuration & conf)
 {
-    return tryClaimBuffer(-1L);
-}
-
-BufferPtr StorageKafka::tryClaimBuffer(long wait_ms)
-{
-    // Wait for the first free buffer
-    if (wait_ms >= 0)
-    {
-        if (!semaphore.tryWait(wait_ms))
-            return nullptr;
-    }
-    else
-        semaphore.wait();
-
-    // Take the first available buffer from the list
-    std::lock_guard lock(mutex);
-    auto buffer = buffers.back();
-    buffers.pop_back();
-    return buffer;
-}
-
-void StorageKafka::pushBuffer(BufferPtr buffer)
-{
-    std::lock_guard lock(mutex);
-    buffers.push_back(buffer);
-    semaphore.set();
-}
-
-
-cppkafka::Configuration StorageKafka::createConsumerConfiguration()
-{
-    cppkafka::Configuration conf;
-
-    LOG_TRACE(log, "Setting brokers: " << brokers);
-    conf.set("metadata.broker.list", brokers);
-
-    LOG_TRACE(log, "Setting Group ID: " << group << " Client ID: clickhouse");
-    conf.set("group.id", group);
-
-    conf.set("client.id", VERSION_FULL);
-
-    // If no offset stored for this group, read all messages from the start
-    conf.set("auto.offset.reset", "smallest");
-
-    // We manually commit offsets after a stream successfully finished
-    conf.set("enable.auto.commit", "false");
-
-    // Ignore EOF messages
-    conf.set("enable.partition.eof", "false");
-
-    // for debug logs inside rdkafka
-    // conf.set("debug", "consumer,cgrp,topic,fetch");
-
     // Update consumer configuration from the configuration
     const auto & config = global_context.getConfigRef();
     if (config.has(CONFIG_PREFIX))
@@ -276,8 +292,6 @@ cppkafka::Configuration StorageKafka::createConsumerConfiguration()
         if (config.has(topic_config_key))
             loadFromConfig(conf, config, topic_config_key);
     }
-
-    return conf;
 }
 
 bool StorageKafka::checkDependencies(const String & current_database_name, const String & current_table_name)
@@ -307,7 +321,7 @@ bool StorageKafka::checkDependencies(const String & current_database_name, const
     return true;
 }
 
-void StorageKafka::streamThread()
+void StorageKafka::threadFunc()
 {
     try
     {
diff --git a/dbms/src/Storages/Kafka/StorageKafka.h b/dbms/src/Storages/Kafka/StorageKafka.h
index f9b6609def5..b42ce93e668 100644
--- a/dbms/src/Storages/Kafka/StorageKafka.h
+++ b/dbms/src/Storages/Kafka/StorageKafka.h
@@ -5,11 +5,11 @@
 #include <DataStreams/IBlockOutputStream.h>
 #include <Storages/IStorage.h>
 #include <Storages/Kafka/ReadBufferFromKafkaConsumer.h>
-#include <Poco/Event.h>
+#include <Storages/Kafka/WriteBufferToKafkaProducer.h>
+
 #include <Poco/Semaphore.h>
 #include <ext/shared_ptr_helper.h>
 
-#include <cppkafka/cppkafka.h>
 #include <mutex>
 
 namespace DB
@@ -36,14 +36,20 @@ public:
         size_t max_block_size,
         unsigned num_streams) override;
 
+    BlockOutputStreamPtr write(
+        const ASTPtr & query,
+        const Context & context
+    ) override;
+
     void rename(const String & /* new_path_to_db */, const String & new_database_name, const String & new_table_name) override;
 
     void updateDependencies() override;
 
-    BufferPtr createBuffer();
-    BufferPtr claimBuffer();
-    BufferPtr tryClaimBuffer(long wait_ms);
-    void pushBuffer(BufferPtr buf);
+    void pushReadBuffer(ConsumerBufferPtr buf);
+    ConsumerBufferPtr popReadBuffer();
+    ConsumerBufferPtr popReadBuffer(std::chrono::milliseconds timeout);
+
+    ProducerBufferPtr createWriteBuffer();
 
     const auto & getTopics() const { return topics; }
     const auto & getFormatName() const { return format_name; }
@@ -84,7 +90,7 @@ private:
     // Consumer list
     Poco::Semaphore semaphore;
     std::mutex mutex;
-    std::vector<BufferPtr> buffers; /// available buffers for Kafka consumers
+    std::vector<ConsumerBufferPtr> buffers; /// available buffers for Kafka consumers
 
     size_t skip_broken;
 
@@ -94,9 +100,12 @@ private:
     BackgroundSchedulePool::TaskHolder task;
     std::atomic<bool> stream_cancelled{false};
 
-    cppkafka::Configuration createConsumerConfiguration();
+    ConsumerBufferPtr createReadBuffer();
 
-    void streamThread();
+    // Update Kafka configuration with values from CH user configuration.
+    void updateConfiguration(cppkafka::Configuration & conf);
+
+    void threadFunc();
     bool streamToViews();
     bool checkDependencies(const String & database_name, const String & table_name);
 };
diff --git a/dbms/src/Storages/Kafka/WriteBufferToKafkaProducer.cpp b/dbms/src/Storages/Kafka/WriteBufferToKafkaProducer.cpp
new file mode 100644
index 00000000000..f88b7eaad5c
--- /dev/null
+++ b/dbms/src/Storages/Kafka/WriteBufferToKafkaProducer.cpp
@@ -0,0 +1,90 @@
+#include "WriteBufferToKafkaProducer.h"
+
+namespace DB
+{
+WriteBufferToKafkaProducer::WriteBufferToKafkaProducer(
+    ProducerPtr producer_,
+    const std::string & topic_,
+    std::optional<char> delimiter,
+    size_t rows_per_message,
+    size_t chunk_size_,
+    std::chrono::milliseconds poll_timeout)
+    : WriteBuffer(nullptr, 0)
+    , producer(producer_)
+    , topic(topic_)
+    , delim(delimiter)
+    , max_rows(rows_per_message)
+    , chunk_size(chunk_size_)
+    , timeout(poll_timeout)
+{
+}
+
+WriteBufferToKafkaProducer::~WriteBufferToKafkaProducer()
+{
+    assert(rows == 0 && chunks.empty());
+}
+
+void WriteBufferToKafkaProducer::count_row()
+{
+    if (++rows % max_rows == 0)
+    {
+        std::string payload;
+        payload.reserve((chunks.size() - 1) * chunk_size + offset());
+        for (auto i = chunks.begin(), e = --chunks.end(); i != e; ++i)
+            payload.append(*i);
+        int trunk_delim = delim && chunks.back()[offset() - 1] == delim ? 1 : 0;
+        payload.append(chunks.back(), 0, offset() - trunk_delim);
+
+        while (true)
+        {
+            try
+            {
+                producer->produce(cppkafka::MessageBuilder(topic).payload(payload));
+            }
+            catch (cppkafka::HandleException & e)
+            {
+                if (e.get_error() == RD_KAFKA_RESP_ERR__QUEUE_FULL)
+                {
+                    producer->poll(timeout);
+                    continue;
+                }
+                throw e;
+            }
+
+            break;
+        }
+
+        rows = 0;
+        chunks.clear();
+        set(nullptr, 0);
+    }
+}
+
+void WriteBufferToKafkaProducer::flush()
+{
+    // For unknown reason we may hit some internal timeout when inserting for the first time.
+    while (true)
+    {
+        try
+        {
+            producer->flush(timeout);
+        }
+        catch (cppkafka::HandleException & e)
+        {
+            if (e.get_error() == RD_KAFKA_RESP_ERR__TIMED_OUT)
+                continue;
+            throw e;
+        }
+
+        break;
+    }
+}
+
+void WriteBufferToKafkaProducer::nextImpl()
+{
+    chunks.push_back(std::string());
+    chunks.back().resize(chunk_size);
+    set(chunks.back().data(), chunk_size);
+}
+
+}
diff --git a/dbms/src/Storages/Kafka/WriteBufferToKafkaProducer.h b/dbms/src/Storages/Kafka/WriteBufferToKafkaProducer.h
new file mode 100644
index 00000000000..d11766d7f35
--- /dev/null
+++ b/dbms/src/Storages/Kafka/WriteBufferToKafkaProducer.h
@@ -0,0 +1,46 @@
+#pragma once
+
+#include <IO/WriteBuffer.h>
+
+#include <cppkafka/cppkafka.h>
+
+#include <list>
+
+namespace DB
+{
+
+class WriteBufferToKafkaProducer;
+
+using ProducerBufferPtr = std::shared_ptr<WriteBufferToKafkaProducer>;
+using ProducerPtr = std::shared_ptr<cppkafka::Producer>;
+
+class WriteBufferToKafkaProducer : public WriteBuffer
+{
+public:
+    WriteBufferToKafkaProducer(
+        ProducerPtr producer_,
+        const std::string & topic_,
+        std::optional<char> delimiter,
+        size_t rows_per_message,
+        size_t chunk_size_,
+        std::chrono::milliseconds poll_timeout);
+    ~WriteBufferToKafkaProducer() override;
+
+    void count_row();
+    void flush();
+
+private:
+    void nextImpl() override;
+
+    ProducerPtr producer;
+    const std::string topic;
+    const std::optional<char> delim;
+    const size_t max_rows;
+    const size_t chunk_size;
+    const std::chrono::milliseconds timeout;
+
+    size_t rows = 0;
+    std::list<std::string> chunks;
+};
+
+}
diff --git a/dbms/tests/integration/test_storage_kafka/test.py b/dbms/tests/integration/test_storage_kafka/test.py
index 09b13d884f6..0f0cf6996ef 100644
--- a/dbms/tests/integration/test_storage_kafka/test.py
+++ b/dbms/tests/integration/test_storage_kafka/test.py
@@ -1,14 +1,17 @@
 import os.path as p
+import random
+import threading
 import time
 import pytest
 
 from helpers.cluster import ClickHouseCluster
 from helpers.test_tools import TSV
+from helpers.client import QueryRuntimeException
 
 import json
 import subprocess
 import kafka.errors
-from kafka import KafkaAdminClient, KafkaProducer
+from kafka import KafkaAdminClient, KafkaProducer, KafkaConsumer
 from google.protobuf.internal.encoder import _VarintBytes
 
 """
@@ -69,6 +72,17 @@ def kafka_produce(topic, messages, timestamp=None):
     print ("Produced {} messages for topic {}".format(len(messages), topic))
 
 
+def kafka_consume(topic):
+    consumer = KafkaConsumer(bootstrap_servers="localhost:9092", auto_offset_reset="earliest")
+    consumer.subscribe(topics=(topic))
+    for toppar, messages in consumer.poll(5000).items():
+        if toppar.topic == topic:
+            for message in messages:
+                yield message.value
+    consumer.unsubscribe()
+    consumer.close()
+
+
 def kafka_produce_protobuf_messages(topic, start_index, num_messages):
     data = ''
     for i in range(start_index, start_index + num_messages):
@@ -490,6 +504,105 @@ def test_kafka_virtual_columns_with_materialized_view(kafka_cluster):
     kafka_check_result(result, True, 'test_kafka_virtual2.reference')
 
 
+def test_kafka_insert(kafka_cluster):
+    instance.query('''
+        CREATE TABLE test.kafka (key UInt64, value UInt64)
+            ENGINE = Kafka
+            SETTINGS kafka_broker_list = 'kafka1:19092',
+                     kafka_topic_list = 'insert1',
+                     kafka_group_name = 'insert1',
+                     kafka_format = 'TSV',
+                     kafka_row_delimiter = '\\n';
+    ''')
+
+    values = []
+    for i in range(50):
+        values.append("({i}, {i})".format(i=i))
+    values = ','.join(values)
+
+    while True:
+        try:
+            instance.query("INSERT INTO test.kafka VALUES {}".format(values))
+            break
+        except QueryRuntimeException as e:
+            if 'Local: Timed out.' in str(e):
+                continue
+            else:
+                raise
+
+    messages = []
+    while True:
+        messages.extend(kafka_consume('insert1'))
+        if len(messages) == 50:
+            break
+
+    result = '\n'.join(messages)
+    kafka_check_result(result, True)
+
+
+def test_kafka_produce_consume(kafka_cluster):
+    instance.query('''
+        CREATE TABLE test.kafka (key UInt64, value UInt64)
+            ENGINE = Kafka
+            SETTINGS kafka_broker_list = 'kafka1:19092',
+                     kafka_topic_list = 'insert2',
+                     kafka_group_name = 'insert2',
+                     kafka_format = 'TSV',
+                     kafka_row_delimiter = '\\n';
+    ''')
+
+    messages_num = 10000
+    def insert():
+        values = []
+        for i in range(messages_num):
+            values.append("({i}, {i})".format(i=i))
+        values = ','.join(values)
+
+        while True:
+            try:
+                instance.query("INSERT INTO test.kafka VALUES {}".format(values))
+                break
+            except QueryRuntimeException as e:
+                if 'Local: Timed out.' in str(e):
+                    continue
+                else:
+                    raise
+
+    threads = []
+    threads_num = 16
+    for _ in range(threads_num):
+        threads.append(threading.Thread(target=insert))
+    for thread in threads:
+        time.sleep(random.uniform(0, 1))
+        thread.start()
+
+    instance.query('''
+        DROP TABLE IF EXISTS test.view;
+        DROP TABLE IF EXISTS test.consumer;
+        CREATE TABLE test.view (key UInt64, value UInt64)
+            ENGINE = MergeTree
+            ORDER BY key;
+        CREATE MATERIALIZED VIEW test.consumer TO test.view AS
+            SELECT * FROM test.kafka;
+    ''')
+
+    while True:
+        result = instance.query('SELECT count() FROM test.view')
+        time.sleep(1)
+        if int(result) == messages_num * threads_num:
+            break
+
+    instance.query('''
+        DROP TABLE test.consumer;
+        DROP TABLE test.view;
+    ''')
+
+    for thread in threads:
+        thread.join()
+
+    assert int(result) == messages_num * threads_num, 'ClickHouse lost some messages: {}'.format(result)
+
+
 if __name__ == '__main__':
     cluster.start()
     raw_input("Cluster created, press any key to destroy...")
diff --git a/libs/libcommon/include/ext/shared_ptr_helper.h b/libs/libcommon/include/ext/shared_ptr_helper.h
index 7e882e03391..f7fd7c38ace 100644
--- a/libs/libcommon/include/ext/shared_ptr_helper.h
+++ b/libs/libcommon/include/ext/shared_ptr_helper.h
@@ -12,7 +12,7 @@ namespace ext
   *
   * Downsides:
   * - your class cannot be final;
-  * - bad compilation error messages;
+  * - awful compilation error messages;
   * - bad code navigation.
   * - different dynamic type of created object, you cannot use typeid.
   */
diff --git a/utils/kafka/consume.py b/utils/kafka/consume.py
index ce2a0ef6a96..34a1997d3e6 100755
--- a/utils/kafka/consume.py
+++ b/utils/kafka/consume.py
@@ -26,6 +26,7 @@ def main():
         'bootstrap_servers': f'{args.server}:{args.port}',
         'client_id': args.client,
         'group_id': args.group,
+        'auto_offset_reset': 'earliest',
     }
     client = kafka.KafkaConsumer(**config)
 

From e986d6ba530e005cc3c2a6a5e84de1cdb9134c97 Mon Sep 17 00:00:00 2001
From: BayoNet <da-daos@yandex.ru>
Date: Tue, 20 Aug 2019 15:06:52 +0300
Subject: [PATCH 106/107] DOCAPI-7459: skip_unavailable_shards docs (#6361)

* Link fix.

* DOCAPI-7459: skip_unavailable_shards docs

* Update dbms/src/Core/Settings.h

Co-Authored-By: Ivan Blinkov <github@blinkov.ru>

* Update docs/en/operations/settings/settings.md

Co-Authored-By: Ivan Blinkov <github@blinkov.ru>

* Update docs/en/operations/settings/settings.md

Co-Authored-By: Ivan Blinkov <github@blinkov.ru>

* Update docs/en/operations/settings/settings.md

Co-Authored-By: Ivan Blinkov <github@blinkov.ru>

* DOCAPI-7459: Markup fixes.
---
 dbms/src/Core/Settings.h                      |  2 +-
 .../en/operations/server_settings/settings.md |  9 ++++---
 docs/en/operations/settings/settings.md       | 26 +++++++++++++++++++
 docs/en/operations/table_engines/buffer.md    | 19 ++++++++++----
 docs/en/operations/table_engines/mergetree.md |  1 +
 5 files changed, 47 insertions(+), 10 deletions(-)

diff --git a/dbms/src/Core/Settings.h b/dbms/src/Core/Settings.h
index 86e8746e854..877f99856c9 100644
--- a/dbms/src/Core/Settings.h
+++ b/dbms/src/Core/Settings.h
@@ -99,7 +99,7 @@ struct Settings : public SettingsCollection<Settings>
     M(SettingUInt64, parallel_replicas_count, 0, "") \
     M(SettingUInt64, parallel_replica_offset, 0, "") \
     \
-    M(SettingBool, skip_unavailable_shards, false, "Silently skip unavailable shards.") \
+    M(SettingBool, skip_unavailable_shards, false, "If 1, ClickHouse silently skips unavailable shards and nodes unresolvable through DNS. Shard is marked as unavailable when none of the replicas can be reached.") \
     \
     M(SettingBool, distributed_group_by_no_merge, false, "Do not merge aggregation states from different servers for distributed query processing - in case it is for certain that there are different keys on different shards.") \
     M(SettingBool, optimize_skip_unused_shards, false, "Assumes that data is distributed by sharding_key. Optimization to skip unused shards if SELECT query filters by sharding_key.") \
diff --git a/docs/en/operations/server_settings/settings.md b/docs/en/operations/server_settings/settings.md
index bf2a430f7d8..2be36a6e0c6 100644
--- a/docs/en/operations/server_settings/settings.md
+++ b/docs/en/operations/server_settings/settings.md
@@ -555,11 +555,9 @@ If the table doesn't exist, ClickHouse will create it. If the structure of the q
 ```
 
 
-## remote_servers
+## remote_servers {#server_settings_remote_servers}
 
-Configuration of clusters used by the Distributed table engine.
-
-For more information, see the section "[Table engines/Distributed](../../operations/table_engines/distributed.md)".
+Configuration of clusters used by the [Distributed](../../operations/table_engines/distributed.md) table engine and by the `cluster` table function.
 
 **Example**
 
@@ -569,6 +567,9 @@ For more information, see the section "[Table engines/Distributed](../../operati
 
 For the value of the `incl` attribute, see the section "[Configuration files](../configuration_files.md#configuration_files)".
 
+**See Also**
+
+- [skip_unavailable_shards](../settings/settings.md#settings-skip_unavailable_shards)
 
 ## timezone
 
diff --git a/docs/en/operations/settings/settings.md b/docs/en/operations/settings/settings.md
index 9e298583b38..02d5871894b 100644
--- a/docs/en/operations/settings/settings.md
+++ b/docs/en/operations/settings/settings.md
@@ -836,3 +836,29 @@ Possible values:
 Default value: `uniqExact`.
 
 [Original article](https://clickhouse.yandex/docs/en/operations/settings/settings/) <!--hide-->
+
+
+## skip_unavailable_shards {#settings-skip_unavailable_shards}
+
+Enables or disables silent skipping of:
+
+- Node, if its name cannot be resolved through DNS.
+
+    When skipping is disabled, ClickHouse requires that all the nodes in the [cluster configuration](../server_settings/settings.md#server_settings_remote_servers) can be resolvable through DNS. Otherwise, ClickHouse throws an exception when trying to perform a query on the cluster.
+
+    If skipping is enabled, ClickHouse considers unresolved nodes as unavailable and tries to resolve them at every connection attempt. Such behavior creates the risk of wrong cluster configuration because a user can specify the wrong node name, and ClickHouse doesn't report about it. However, this can be useful in systems with dynamic DNS, for example, [Kubernetes](https://kubernetes.io), where nodes can be unresolvable during downtime, and this is not an error.
+
+- Shard, if there are no available replicas of the shard.
+
+    When skipping is disabled, ClickHouse throws an exception.
+
+    When skipping is enabled, ClickHouse returns a partial answer and doesn't report about issues with nodes availability.
+
+Possible values:
+
+- 1 — skipping enabled.
+- 0 — skipping disabled.
+
+Default value: 0.
+
+[Original article](https://clickhouse.yandex/docs/en/operations/settings/settings/) <!-- hide -->
diff --git a/docs/en/operations/table_engines/buffer.md b/docs/en/operations/table_engines/buffer.md
index d8e240b8013..18024918835 100644
--- a/docs/en/operations/table_engines/buffer.md
+++ b/docs/en/operations/table_engines/buffer.md
@@ -2,17 +2,26 @@
 
 Buffers the data to write in RAM, periodically flushing it to another table. During the read operation, data is read from the buffer and the other table simultaneously.
 
-```
+```sql
 Buffer(database, table, num_layers, min_time, max_time, min_rows, max_rows, min_bytes, max_bytes)
 ```
 
-Engine parameters:database, table – The table to flush data to. Instead of the database name, you can use a constant expression that returns a string. num_layers – Parallelism layer. Physically, the table will be represented as 'num_layers' of independent buffers. Recommended value: 16. min_time, max_time, min_rows, max_rows, min_bytes, and max_bytes are conditions for flushing data from the buffer.
+Engine parameters:
 
-Data is flushed from the buffer and written to the destination table if all the 'min' conditions or at least one 'max' condition are met.min_time, max_time – Condition for the time in seconds from the moment of the first write to the buffer. min_rows, max_rows – Condition for the number of rows in the buffer. min_bytes, max_bytes – Condition for the number of bytes in the buffer.
+- `database` – Database name. Instead of the database name, you can use a constant expression that returns a string.
+- `table` – Table to flush data to. 
+- `num_layers` – Parallelism layer. Physically, the table will be represented as 'num_layers' of independent buffers. Recommended value: 16.
+- `min_time`, `max_time`, `min_rows`, `max_rows`, `min_bytes`, and `max_bytes` – Conditions for flushing data from the buffer.
 
-During the write operation, data is inserted to a 'num_layers' number of random buffers. Or, if the data part to insert is large enough (greater than 'max_rows' or 'max_bytes'), it is written directly to the destination table, omitting the buffer.
+Data is flushed from the buffer and written to the destination table if all the `min*` conditions or at least one `max*` condition are met.
 
-The conditions for flushing the data are calculated separately for each of the 'num_layers' buffers. For example, if num_layers = 16 and max_bytes = 100000000, the maximum RAM consumption is 1.6 GB.
+- `min_time`, `max_time` – Condition for the time in seconds from the moment of the first write to the buffer.
+- `min_rows`, `max_rows` – Condition for the number of rows in the buffer. 
+- `min_bytes`, `max_bytes` – Condition for the number of bytes in the buffer.
+
+During the write operation, data is inserted to a `num_layers` number of random buffers. Or, if the data part to insert is large enough (greater than `max_rows` or `max_bytes`), it is written directly to the destination table, omitting the buffer.
+
+The conditions for flushing the data are calculated separately for each of the `num_layers` buffers. For example, if `num_layers = 16` and `max_bytes = 100000000`, the maximum RAM consumption is 1.6 GB.
 
 Example:
 
diff --git a/docs/en/operations/table_engines/mergetree.md b/docs/en/operations/table_engines/mergetree.md
index d28c5595942..a3646d3d0e9 100644
--- a/docs/en/operations/table_engines/mergetree.md
+++ b/docs/en/operations/table_engines/mergetree.md
@@ -172,6 +172,7 @@ The number of columns in the primary key is not explicitly limited. Depending on
 - Improve the performance of an index.
 
     If the primary key is `(a, b)`, then adding another column `c` will improve the performance if the following conditions are met:
+    
     - There are queries with a condition on column `c`.
     - Long data ranges (several times longer than the `index_granularity`) with identical values for `(a, b)` are common. In other words, when adding another column allows you to skip quite long data ranges.
 

From 06bb0af3869b44ceff7ce4c69c6a23fa3bb4942f Mon Sep 17 00:00:00 2001
From: Nikolai Kochetov <nik-kochetov@yandex-team.ru>
Date: Tue, 20 Aug 2019 18:03:35 +0300
Subject: [PATCH 107/107] Fix build.

---
 .../Formats/Impl/JSONEachRowWithProgressRowOutputFormat.cpp    | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/dbms/src/Processors/Formats/Impl/JSONEachRowWithProgressRowOutputFormat.cpp b/dbms/src/Processors/Formats/Impl/JSONEachRowWithProgressRowOutputFormat.cpp
index 6d448b00203..33fc1c9920b 100644
--- a/dbms/src/Processors/Formats/Impl/JSONEachRowWithProgressRowOutputFormat.cpp
+++ b/dbms/src/Processors/Formats/Impl/JSONEachRowWithProgressRowOutputFormat.cpp
@@ -34,9 +34,10 @@ void registerOutputFormatProcessorJSONEachRowWithProgress(FormatFactory & factor
             WriteBuffer & buf,
             const Block & sample,
             const Context &,
+            FormatFactory::WriteCallback callback,
             const FormatSettings & format_settings)
     {
-        return std::make_shared<JSONEachRowWithProgressRowOutputFormat>(buf, sample, format_settings);
+        return std::make_shared<JSONEachRowWithProgressRowOutputFormat>(buf, sample, callback, format_settings);
     });
 }